Repository navigation
Expand file tree
/
Copy pathtransition_binding.py
More file actions
190 lines (173 loc) · 7.44 KB
/
Copy pathtransition_binding.py
File metadata and controls
190 lines (173 loc) · 7.44 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
"""Add public transition tools to an existing neutral caller request.
Keep its actual namespace builder,task,budget,transport and final adapter.
The only extra ordinary mounts are readonly public client/socket/reference.
"""
from contextlib import contextmanager
from dataclasses import replace
from pathlib import Path
import stat
from infinicoder.runtime.agent_execution import CoreRequest, UnsupportedCore
from infinicoder.runtime.native_plain import NativePlainObserver
from infinicoder.execution.native_sandbox import NativeSandboxExecution
from infinicoder.verification.native_transition_probe import NativeTransitionProbe
from infinicoder.verification.public_transition_probe import PublicTransitionContract
from infinicoder.verification.transition_public_cpu import (
CLIENT,
SOCKET,
REFERENCE,
TransitionAcceptance,
_public_reference_bytes,
)
from infinicoder.verification.transition_reports import PublicTransitionCapability
class TransitionNamespaceExecution(NativeSandboxExecution):
"""Preserve a caller's original bwrap builder,including protected overlays."""
def __init__(self, original, state):
if not isinstance(original, NativeSandboxExecution) or original.snapshot_trials:
raise UnsupportedCore("single-run caller NativeSandboxExecution required")
self.original = original
self.state = Path(state).resolve()
self.transition_mounts = None
super().__init__(
self._builder,
original.scratch,
env=original.env,
snapshot_trials=original.snapshot_trials,
trial_generated_paths=original.trial_generated_paths,
task_environment=original.task_environment,
)
self.identity = original.identity + ";readonly_public_transition_mounts_v1"
self.command_limit = original.command_limit
def _builder(self, workspace, command):
argv = list(self.original.sandbox_argv(workspace, command))
if (
not command
or len(argv) <= len(command)
or argv[-len(command) :] != list(command)
or Path(argv[0]).name != "bwrap"
):
raise UnsupportedCore("original bwrap builder with exact command suffix required")
if self.transition_mounts is not None:
client, socket, reference = self.transition_mounts
argv[-len(command) : -len(command)] = [
"--ro-bind",
str(client),
CLIENT,
"--ro-bind",
str(socket),
SOCKET,
"--ro-bind",
str(reference),
REFERENCE,
]
return argv
def validate(self, request):
self.original.validate(request)
super().validate(request)
self._builder(request.workspace, ["/bin/true"])
@contextmanager
def bind_transition_service(self, client, socket, reference):
client, socket, reference = map(lambda p: Path(p).absolute(), (client, socket, reference))
if (
self.transition_mounts is not None
or client != self.state / "transition-client.py"
or reference != self.state / "transition-reference.py"
or not client.is_file()
or not reference.is_file()
or not stat.S_ISSOCK(socket.lstat().st_mode)
or any(p.is_symlink() for v in (client, socket, reference) for p in (v, *v.parents))
):
raise UnsupportedCore("exact task-owned readonly transition service required")
self.transition_mounts = client, socket, reference
try:
yield
finally:
self.transition_mounts = None
class PublicTransitionMaterials:
"""Explicit public reference/capability without inferring an execution type."""
def __init__(self, contract, reference, workspace, state, operation, exposed_runtime_roots):
if not isinstance(contract, PublicTransitionContract):
raise TypeError("explicit public contract required")
self.contract = contract
self.data = contract.manifest()
self.reference = Path(reference).absolute()
self.raw = None
self.workspace = Path(workspace).resolve()
self.state = Path(state).resolve()
if not isinstance(exposed_runtime_roots, tuple) or not exposed_runtime_roots:
raise ValueError("caller must declare original exposed runtime roots")
self.runtime_roots = tuple(Path(p).resolve() for p in exposed_runtime_roots)
if any(not Path(p).is_absolute() for p in exposed_runtime_roots):
raise ValueError("absolute exposed runtime roots required")
self.capability = PublicTransitionCapability(contract, operation)
self._validate_reference()
def _validate_reference(self):
self.raw = _public_reference_bytes(
self.reference, self.workspace, self.state, self.runtime_roots, self.data, self.raw
)
def validate(self, request):
self._validate_reference()
self.capability.validate(request)
def attach_public_transition(
request,
contract,
reference_script,
operation,
*,
automatic,
exposed_runtime_roots,
count_messages=None,
tokenizer_identity=None,
):
"""Return a request with the same original task and independent acceptance.
Both ON/OFF get the identical manual run/read material. Only ON consumes
automatic edit feedback. Unsupported workflows are refused,never erased.
Caller capabilities remain explicit;there is no model-selected runner.
"""
if not isinstance(request, CoreRequest) or type(automatic) is not bool:
raise TypeError("CoreRequest and explicit automatic boolean required")
if (
request.candidate_search is not None
or request.repair_adapter is not None
or request.planning_adapter is not None
or request.context_adapter is not None
and type(request.context_adapter) is not NativePlainObserver
):
raise UnsupportedCore(
"transition attachment requires the neutral single-run context;existing workflows are not cleared"
)
counter = (
count_messages
if count_messages is not None
else getattr(request.transport_adapter, "counter", None)
)
identity = (
tokenizer_identity if tokenizer_identity is not None else getattr(counter, "identity", None)
)
if not callable(counter) or not isinstance(identity, str) or not identity:
raise ValueError("actual caller tokenizer counter and identity required")
materials = PublicTransitionMaterials(
contract,
reference_script,
request.workspace,
request.state_dir,
operation,
exposed_runtime_roots,
)
paths = tuple(
dict.fromkeys((*getattr(request.context_adapter, "paths", ()), *contract.observed_paths))
)
execution = TransitionNamespaceExecution(request.execution_adapter, request.state_dir)
context = (
NativeTransitionProbe(
counter,
tokenizer_identity=identity,
implementation_paths=paths,
capability=materials.capability,
)
if automatic
else NativePlainObserver(counter, tokenizer_identity=identity, implementation_paths=paths)
)
acceptance = TransitionAcceptance(request.acceptance_adapter, materials, execution, context)
return replace(
request, execution_adapter=execution, acceptance_adapter=acceptance, context_adapter=context
)