diff --git a/infra/hermes-pilot/ADAPTER.md b/infra/hermes-pilot/ADAPTER.md new file mode 100644 index 00000000..40badb8a --- /dev/null +++ b/infra/hermes-pilot/ADAPTER.md @@ -0,0 +1,24 @@ +# Authenticated one-shot Tech adapter (not deployed) + +`tech_adapter.py` is trusted host-side orchestration, not a web endpoint. It takes an explicit task UUID, service origin, private artifact root and reviewed admission JSON file. Credential is read exclusively from `/run/secrets/prepare_worker_credential`, with descriptor-relative no-symlink traversal, private file permissions, ownership, regular-file/one-link and bounded-read checks. No token is emitted. HTTPS only in CLI; loopback HTTP exists only in the Python disposable-test interface. Redirects are never followed. + +Contract frozen with parent: +- POST `/internal/prepare-worker/tech-claim` `{taskId}` -> `{lease}` or `{lease:null}`. Backend owns stored task admission, READY and independent Gate1. Lease must include exact `pilotKind:tech-dev-clamp-quantity-v1`; removing that sole extension must yield the existing strict staging/first-attempt/20-cent/30-second lease. Task ID must match explicit caller UUID. No arbitrary task text enters inference. +- POST existing `heartbeat` with only taskId/runId/leaseToken -> `{leaseUntil}`. No retries. Entire DNS/connect/response-body operation is isolated in a spawned process, killed after 4.5s plus <=.2s reap. This avoids socket timeout slow-drip gaps. Existing LeaseGuard aborts cancellable inference on denial; no local lease extension. +- POST `tech-complete` with binding plus <=2048-byte generated `source`, only after independent local QA9 and final heartbeat. Acknowledge only exact matching task/run, VERIFYING, 64hex artifactSha256 and `upper-bound-reserved`. Backend's independent validator, artifact registration and reservation retention remain separate authority. Never call existing deterministic tracer `complete` with model output. + +Admission file must exactly contain: + + {"maxCalls":1,"maxTokens":160,"reservationCents":20,"monetaryCapVerified":false,"acceptUnverifiedMonetaryCap":true} + +This is explicit conservative acceptance, **not a hard monetary cap**. Provider authenticated GET `/v1/models` on 2026-10-23 returned `[{"id":"Free"}]` after filtering to id/pricing/cost/limits: no price or cap fields. Anonymous GET returned401. Therefore neither zero price nor independently enforced20c spend cap was verified. Retain the complete20c server reservation; no cost-zero/release/reconcile claim. + +Installed pinned Hermes source inspection revealed default API retries3 and automatic recovery5. `inference_budget.SingleCall` now gates the OpenAI-compatible `Completions.create` resource class across client rebuilds, forces nonstreaming/max_tokens160 and denies second invocation. `infer.py` sets app attempts1, recovery0 and checks SDK retries0 before calling the fixed prompt. `runtime.py` injects that trusted gate from source into the isolated pinned process. This bounds requests/output, not provider accounting/input token cost. No new real provider inference was run or represented as authorized by this discovery. + +## Verification (remote worktree only) + +`python3 -m unittest discover -s infra/hermes-pilot -v`:19 tests passed, including adapter process fixture through independent QA9/Git fixture; real TCP Bearer transmission and403 rejection; total slow-drip body deadline<5s; admission rejection before network; exact pilot denial before runner construction; second provider-call prevention; existing real child/descendant cancellation regressions. Source fixture is deterministic and is **not actual model output**. TDD observed missing module, missing end-to-end behavior, missing credential validation and missing SingleCall failures before implementation. + +`disposable_backend.ts` is an isolated Nest/PostgreSQL harness importing sibling's backend module read-only. It is never AppModule code. It records separate author/reviewer Gate1, checks pre-Gate1 denial and VERIFYING/persisted reservation/artifact retrieval. Combined execution PASSED against sibling ingestion source snapshot: task d4e88f7c-3772-47ab-a6fd-dbe00ff8bd2e, run b93a5dbf-3185-4f29-a69d-be8ad85e720c, VERIFYING, artifact b9382f575e9f27f7ad54e0cfb61ba91bc66536fa0e5df5be955563a03c285e17, retrievable with QA9, full20c reservation and zero reconciliations. Evidence: /opt/services/canina/validation/v4-tech-adapter/{adapter-proof,backend-proof}.json. Initial Docker host networking/mounts and stale generated Prisma client failed; corrected with loopback-only disposable backend, copied source and privately generated Prisma client (shared dependencies read-only). Dedicated disposable PostgreSQL had no published ports. No actual authenticated Gate1/model run, Stage change, Production, push/deploy or RELEASE_AUTHORIZE. + +Created/changed files are confined to infra/hermes-pilot. Original dirty core/Stage remain untouched. Parent must combine sibling ingestion commit, run disposable integration and decide whether conservative admission suffices for any later model proof. diff --git a/infra/hermes-pilot/adapter-evidence.json b/infra/hermes-pilot/adapter-evidence.json new file mode 100644 index 00000000..c78f3d0e --- /dev/null +++ b/infra/hermes-pilot/adapter-evidence.json @@ -0,0 +1,22 @@ +{ + "adapter-proof": { + "taskId": "d4e88f7c-3772-47ab-a6fd-dbe00ff8bd2e", + "runId": "b93a5dbf-3185-4f29-a69d-be8ad85e720c", + "state": "VERIFYING", + "costStatus": "upper-bound-reserved", + "artifactSha256": "b9382f575e9f27f7ad54e0cfb61ba91bc66536fa0e5df5be955563a03c285e17", + "modelInference": false, + "disposable": true, + "preGate1Denied": true + }, + "backend-proof": { + "state": "VERIFYING", + "taskId": "d4e88f7c-3772-47ab-a6fd-dbe00ff8bd2e", + "artifactSha256": "b9382f575e9f27f7ad54e0cfb61ba91bc66536fa0e5df5be955563a03c285e17", + "reservedCents": 20, + "reconciliations": 0, + "qaCases": 9, + "modelInference": false, + "disposable": true + } +} diff --git a/infra/hermes-pilot/disposable_adapter.py b/infra/hermes-pilot/disposable_adapter.py new file mode 100644 index 00000000..ff0e3419 --- /dev/null +++ b/infra/hermes-pilot/disposable_adapter.py @@ -0,0 +1,20 @@ +"""Deterministic process fixture against actual disposable Nest/PostgreSQL. Not a model proof.""" +import json, pathlib, sys, time +sys.path.insert(0,str(pathlib.Path(__file__).parent)) +import tech_adapter as a + +def main(): + evidence=pathlib.Path('/opt/services/canina/validation/v4-tech-adapter') + until=time.monotonic()+15 + while not (evidence/'ready.json').exists(): + if time.monotonic()>until: raise TimeoutError('Backend not ready') + time.sleep(.1) + ready=json.loads((evidence/'ready.json').read_text()) + source='def clamp_quantity(quantity):\n return min(99, max(0, quantity))\n' + runner=lambda:a.executor.ProcessInference([sys.executable,'-c','print('+repr(json.dumps({'source':source,'tools':0,'model':'Free'}))+')']) + transport=a.Transport(ready['baseUrl'],'DISPOSABLE-ONLY-TECH-ADAPTER-SECRET-1234567890',allow_loopback_http=True) + result=a.run_once(transport,ready['taskId'],str(evidence),a.ADMISSION,runner) + (evidence/'adapter-proof.json').write_text(json.dumps({**result,'modelInference':False,'disposable':True,'preGate1Denied':ready['preGate1Denied']})) + (evidence/'done').touch() + print(json.dumps(result)) +if __name__=='__main__': main() diff --git a/infra/hermes-pilot/disposable_backend.ts b/infra/hermes-pilot/disposable_backend.ts new file mode 100644 index 00000000..5bb37421 --- /dev/null +++ b/infra/hermes-pilot/disposable_backend.ts @@ -0,0 +1,41 @@ +/** Disposable-only integration harness: never import into AppModule. */ +import { Test } from '@nestjs/testing'; +import { PrismaClient } from '@prisma/client'; +import { createHash, randomUUID } from 'crypto'; +import { mkdir, writeFile, readFile } from 'fs/promises'; +import { WorkerTransportModule } from '/backend/src/orchestration-worker/worker-transport.module'; +import { PrismaService } from '/backend/src/prisma/prisma.service'; +import { PrepareWorkflowService } from '/backend/src/orchestration/prepare-workflow.service'; + +async function main() { + if(process.env.DISPOSABLE_TECH_ADAPTER !== 'yes') throw Error('Disposable flag required'); + const db = new PrismaClient(); + const token = 'DISPOSABLE-ONLY-TECH-ADAPTER-SECRET-1234567890'; + const directory = '/evidence/artifacts'; await mkdir(directory,{mode:0o700,recursive:true}); + const mod = await Test.createTestingModule({imports:[WorkerTransportModule.register({enabled:true,grants:[{id:'adapter-fixture',role:'WORKFLOW_WORKER',credentialSha256:createHash('sha256').update(token).digest('hex')}],workerIds:['adapter-fixture'],stageCiIds:[],artifactDirectory:directory,artifactBaseUrl:'https://isolated.invalid/internal/prepare-worker/artifacts'})]}).overrideProvider(PrismaService).useValue(db).compile(); + const workflow = mod.get(PrepareWorkflowService); + const app=mod.createNestApplication(); await app.listen(31987,'0.0.0.0'); + const owner={id:'fixture-author',role:'Admin'}, reviewer={id:'fixture-reviewer',role:'SUPER_ADMIN'}; + await db.orchestrationTask.updateMany({where:{key:'tech-dev-clamp-quantity-v1'},data:{key:'previous-'+randomUUID()}}); + let t=await workflow.create({key:'tech-dev-clamp-quantity-v1',title:'Disposable clamp fixture',department:'TECH',operationMode:'PREPARE',budgetLimitCents:20,metadata:{commitSha:'a'.repeat(40),scope:'tech-dev-clamp-quantity-v1',acceptanceCriteria:['Independent clamp fixture QA only']}},owner); + // Server admission must reject before the independently recorded Gate1. + let response=await fetch(('http://127.0.0.1:31987')+'/internal/prepare-worker/tech-claim',{method:'POST',headers:{authorization:'Bearer '+token,'content-type':'application/json'},body:JSON.stringify({taskId:t.id})}); + if(response.status!==403 && (await response.json()).lease!==null) throw Error('Pre-Gate1 claim accepted'); + t=await workflow.transition(t.id,{toState:'GATE1_PENDING',expectedVersion:t.version,idempotencyKey:randomUUID()},owner); + t=await workflow.decide(t.id,1,{decision:'APPROVED',expiresAt:new Date(Date.now()+60000).toISOString(),expectedVersion:t.version,idempotencyKey:randomUUID()},reviewer); + t=await workflow.transition(t.id,{toState:'READY',expectedVersion:t.version,idempotencyKey:randomUUID()},owner); + await writeFile('/evidence/ready.json',JSON.stringify({baseUrl:'http://127.0.0.1:31987',taskId:t.id,preGate1Denied:true})); + try { + const until=Date.now()+45000; + while(Date.now()setTimeout(r,100));} + const task=await db.orchestrationTask.findUniqueOrThrow({where:{id:t.id}}); + const ledger=await db.orchestrationBudgetLedger.findMany({where:{taskId:t.id}}); + const artifacts=await db.orchestrationArtifact.findMany({where:{run:{taskId:t.id}}}); + if(task.state!=='VERIFYING' || ledger.length!==1 || ledger[0].kind!=='RESERVE' || ledger[0].amountCents!==20 || artifacts.length!==1) throw Error('Persistence/reservation invariant failed'); + const get=await fetch(('http://127.0.0.1:31987')+'/internal/prepare-worker/artifacts/'+artifacts[0].sha256,{headers:{authorization:'Bearer '+token}}); + const artifact=await get.json(); + if(get.status!==200 || artifact.qa.cases!==9 || artifact.applicationQa!==false) throw Error('Artifact retrieval failed'); + await writeFile('/evidence/backend-proof.json',JSON.stringify({state:task.state,taskId:t.id,artifactSha256:artifacts[0].sha256,reservedCents:20,reconciliations:0,qaCases:artifact.qa.cases,modelInference:false,disposable:true})); + } finally {await app.close(); await db.$disconnect();} +} +main().catch((e)=>{console.error('Disposable integration failed',e?.message);process.exitCode=1;}); diff --git a/infra/hermes-pilot/infer.py b/infra/hermes-pilot/infer.py index 0d823c6e..796e7e02 100644 --- a/infra/hermes-pilot/infer.py +++ b/infra/hermes-pilot/infer.py @@ -9,11 +9,23 @@ os.environ.clear() os.environ.update({'PATH':'/usr/bin:/bin','HOME':home.name,'HERMES_HOME':home.name,'OPENAI_API_KEY':key,'OPENAI_BASE_URL':'https://nr.parsaaghayi.ir/v1','HERMES_DISABLE_PLUGINS':'1'}) # Installed API verified by inspect.signature at pinned image commit 818c13be. with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()): + from openai.resources.chat.completions import Completions + # Patch the SDK resource class, so client rebuilds/fallback cannot reset admission. + original_create=Completions.create + budget=SingleCall() # injected by pinned runner, never imported from runtime disk + def bounded_create(self, *args, **kwargs): + if args: raise RuntimeError('Unexpected positional completion call') + return budget.call(lambda **kw: original_create(self, **kw),kwargs) + Completions.create=bounded_create from run_agent import AIAgent agent=AIAgent(model='Free',provider='custom',base_url='https://nr.parsaaghayi.ir/v1',api_key=key, enabled_toolsets=[],max_iterations=1,max_tokens=160,run_budget_seconds=80, skip_context_files=True,skip_memory=True,skip_background_review=True,load_soul_identity=False, quiet_mode=True,fallback_model={},cwd=home.name) + agent._api_max_retries=1 + agent._auto_recovery_cycles=0 + if getattr(agent.client,'max_retries',None) != 0: + raise RuntimeError('SDK retries must be disabled') if agent.tools: raise RuntimeError('Tool-less invariant failed') result=agent.run_conversation('Write only Python source, no markdown: define clamp_quantity(quantity) returning integer quantity clamped to inclusive 0..99. Use one return with nested min/max calls only. No annotations, comments, imports, decorators, docstrings or other statements.') final=result.get('final_response') diff --git a/infra/hermes-pilot/inference_budget.py b/infra/hermes-pilot/inference_budget.py new file mode 100644 index 00000000..eed8a3d5 --- /dev/null +++ b/infra/hermes-pilot/inference_budget.py @@ -0,0 +1,18 @@ +"""Pinned OpenAI-compatible completion boundary; not a monetary spending cap.""" +import threading + +class SingleCall: + def __init__(self): + self.used = False + self.lock = threading.Lock() + + def call(self, create, kwargs): + with self.lock: + if self.used: + raise RuntimeError('One provider call only; no retries') + self.used = True + kwargs = dict(kwargs) + kwargs['max_tokens'] = 160 + kwargs['stream'] = False + kwargs.pop('max_completion_tokens',None) + return create(**kwargs) diff --git a/infra/hermes-pilot/runtime.py b/infra/hermes-pilot/runtime.py index ab47376e..6f6bf0a7 100644 --- a/infra/hermes-pilot/runtime.py +++ b/infra/hermes-pilot/runtime.py @@ -111,7 +111,8 @@ def pinned_inference(image): raise RuntimeError('Pinned installed image mismatch') token = uuid.uuid4().hex pidfile = '/tmp/canina-pilot-' + token + '.pid' - script = pathlib.Path(__file__).with_name('infer.py').read_text() + script = (pathlib.Path(__file__).with_name('inference_budget.py').read_text() + '\n' + + pathlib.Path(__file__).with_name('infer.py').read_text()) # Session leader is created INSIDE the container. Inner kill is independent of client. wrapper = ('import os,signal,subprocess,sys; ' 'p=subprocess.Popen(["timeout","--signal=KILL","85","/opt/hermes/.venv/bin/python","-"],stdin=sys.stdin,start_new_session=True); ' diff --git a/infra/hermes-pilot/tech_adapter.py b/infra/hermes-pilot/tech_adapter.py new file mode 100644 index 00000000..eeb3c1dd --- /dev/null +++ b/infra/hermes-pilot/tech_adapter.py @@ -0,0 +1,165 @@ +"""Trusted one-shot adapter; fixed task, no arbitrary prompt/command input.""" +import argparse +import http.client +import json +import multiprocessing +import os +import pathlib +import re +import stat +import time +import urllib.parse +import executor + +PILOT_KIND = executor.TASK +SECRET_PATH = '/run/secrets/prepare_worker_credential' +ADMISSION = {'maxCalls':1, 'maxTokens':160, 'reservationCents':20, + 'monetaryCapVerified':False, 'acceptUnverifiedMonetaryCap':True} + + +def read_credential(): + """Fixed mount only; pin every directory and never log a secret.""" + directory = os.open('/', os.O_RDONLY | os.O_DIRECTORY) + fd = None + try: + parts = SECRET_PATH.strip('/').split('/') + for part in parts[:-1]: + next_dir = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=directory) + os.close(directory) + directory = next_dir + if os.fstat(directory).st_mode & 0o022: + raise ValueError('Private secret directory required') + fd = os.open(parts[-1], os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK, dir_fd=directory) + s = os.fstat(fd) + if (not stat.S_ISREG(s.st_mode) or s.st_nlink != 1 or s.st_mode & 0o077 + or s.st_uid not in (0, os.getuid()) or s.st_size > 513): + raise ValueError('Private credential required') + token = os.read(fd, 514).decode('ascii').strip() + if not re.fullmatch(r'[\x21-\x7e]{32,512}', token): + raise ValueError('Private credential required') + return token + finally: + if fd is not None: + os.close(fd) + os.close(directory) + + +def _request(pipe, origin, token, route, body): + try: + u = urllib.parse.urlsplit(origin) + connection = (http.client.HTTPSConnection if u.scheme == 'https' else http.client.HTTPConnection)(u.hostname, u.port, timeout=4) + connection.request('POST', '/internal/prepare-worker/'+route, json.dumps(body), + {'Authorization':'Bearer '+token, 'Content-Type':'application/json'}) + response = connection.getresponse() + raw = response.read(8193) + if not 200 <= response.status < 300 or len(raw) > 8192: + raise ValueError('Denied or oversized response') + result = json.loads(raw) + if not isinstance(result, dict): + raise ValueError('Invalid response') + pipe.send((True,result)) + except BaseException: + pipe.send((False,None)) + finally: + pipe.close() + + +class Transport: + """Entire network operation (including DNS/body) killed before 5s, no retries.""" + def __init__(self, origin, credential, *, allow_loopback_http=False): + u = urllib.parse.urlsplit(origin) + if (u.username or u.password or u.query or u.fragment or u.path not in ('','/') + or not u.hostname or (u.scheme != 'https' and not + (allow_loopback_http and u.scheme=='http' and u.hostname in ('127.0.0.1','::1')))): + raise ValueError('Fixed HTTPS service origin required') + if not isinstance(credential,str) or not re.fullmatch(r'[\x21-\x7e]{32,512}',credential): + raise ValueError('Service credential required') + self.origin, self._credential = origin, credential + + def post(self, route, body): + if route not in ('tech-claim','heartbeat','tech-complete'): + raise ValueError('Route not admitted') + ctx = multiprocessing.get_context('spawn') + receive, send = ctx.Pipe(duplex=False) + worker = ctx.Process(target=_request, args=(send,self.origin,self._credential,route,body), daemon=True) + worker.start() + send.close() + try: + if not receive.poll(4.5): + raise TimeoutError('Worker transport deadline') + try: + ok, result = receive.recv() + except EOFError: + raise PermissionError('Worker transport failed') from None + if not ok: + raise PermissionError('Worker request denied or malformed') + return result + finally: + if worker.is_alive(): + worker.kill() + worker.join(timeout=.2) + receive.close() + + +def validate_admission(admission): + if (admission != ADMISSION or type(admission.get('maxCalls')) is not int + or type(admission.get('maxTokens')) is not int or type(admission.get('reservationCents')) is not int): + raise ValueError('Explicit conservative admission required; monetary cap unverified') + + +def run_once(transport, task_id, artifact_root, admission, runner_factory=None): + validate_admission(admission) + if not isinstance(task_id,str) or not re.fullmatch('[a-f0-9-]{36}',task_id): + raise ValueError('Explicit task UUID required') + response = transport.post('tech-claim', {'taskId':task_id}) + lease = response.get('lease') + if lease is None: + return {'state':'IDLE'} + if not isinstance(lease,dict) or lease.get('pilotKind') != PILOT_KIND or lease.get('taskId') != task_id: + raise ValueError('Fixed Tech admission required') + lease = dict(lease) + del lease['pilotKind'] + executor.validate_lease(lease) + binding = {k:lease[k] for k in ('taskId','runId','leaseToken')} + def heartbeat(_): + result = transport.post('heartbeat',dict(binding)) + if set(result) != {'leaseUntil'} or not isinstance(result['leaseUntil'],str): + raise PermissionError('Malformed heartbeat acknowledgment') + import datetime + expiry = datetime.datetime.fromisoformat(result['leaseUntil'].replace('Z','+00:00')).timestamp() + if not 0 < expiry-time.time() <= 31: + raise PermissionError('Invalid heartbeat acknowledgment') + runner = (runner_factory or (lambda:executor.pinned_inference(executor.IMAGE)))() + root, report = executor.execute(lease,artifact_root,runner,heartbeat) + source = (root/'quantity.py').read_text() + heartbeat(lease) + result = transport.post('tech-complete',{**binding,'source':source}) + if (result.get('taskId') != task_id or result.get('runId') != lease['runId'] + or result.get('state') != 'VERIFYING' or result.get('costStatus') != 'upper-bound-reserved' + or not isinstance(result.get('artifactSha256'),str) + or not re.fullmatch('[a-f0-9]{64}',result['artifactSha256'])): + raise ValueError('Invalid completion acknowledgment; no success assumed') + return {k:result[k] for k in ('taskId','runId','state','costStatus','artifactSha256')} + + +def main(): + parser = argparse.ArgumentParser(description='Explicit one-shot Tech pilot; no release') + parser.add_argument('--base-url', required=True) + parser.add_argument('--task-id', required=True) + parser.add_argument('--artifact-root', required=True) + parser.add_argument('--admission-file', required=True) + args = parser.parse_args() + try: + admission = json.loads(pathlib.Path(args.admission_file).read_text()) + validate_admission(admission) + transport = Transport(args.base_url,read_credential()) + result = run_once(transport,args.task_id,args.artifact_root,admission) + print(json.dumps(result)) + except BaseException: + print('Tech pilot failed closed; reservation retained; no completion assumed',file=__import__('sys').stderr) + return 1 + return 0 + + +if __name__ == '__main__': + raise SystemExit(main()) diff --git a/infra/hermes-pilot/test_tech_adapter.py b/infra/hermes-pilot/test_tech_adapter.py new file mode 100644 index 00000000..9c03dd6d --- /dev/null +++ b/infra/hermes-pilot/test_tech_adapter.py @@ -0,0 +1,102 @@ +import datetime, json, pathlib, sys, tempfile, unittest +from unittest.mock import patch +sys.path.insert(0,str(pathlib.Path(__file__).parent)) +from test_contract import lease +import tech_adapter as a + +class Adapter(unittest.TestCase): + def test_wrong_pilot_never_constructs_inference(self): + calls=[] + class Transport: + def post(self, route, body): + calls.append(route) + return {'lease':dict(lease(),pilotKind='arbitrary')} + with tempfile.TemporaryDirectory() as root: + with self.assertRaises(ValueError): + a.run_once(Transport(),lease()['taskId'],root,{'maxCalls':1,'maxTokens':160,'reservationCents':20,'monetaryCapVerified':False,'acceptUnverifiedMonetaryCap':True},lambda: self.fail('inference constructed')) + self.assertEqual(calls,['tech-claim']) + + def test_end_to_end_process_fixture(self): + source='def clamp_quantity(quantity):\n return min(99, max(0, quantity))\n' + d=dict(lease(),pilotKind=a.PILOT_KIND); calls=[] + class Transport: + def post(self,route,body): + calls.append((route,body)) + if route=='tech-claim': return {'lease':d} + if route=='heartbeat': return {'leaseUntil':d['leaseUntil']} + return {'taskId':d['taskId'],'runId':d['runId'],'state':'VERIFYING','artifactSha256':'b'*64,'costStatus':'upper-bound-reserved'} + policy={'maxCalls':1,'maxTokens':160,'reservationCents':20,'monetaryCapVerified':False,'acceptUnverifiedMonetaryCap':True} + with tempfile.TemporaryDirectory() as root: + runner=lambda: a.executor.ProcessInference([sys.executable,'-c','print('+repr(json.dumps({'source':source,'tools':0,'model':'Free'}))+')']) + result=a.run_once(Transport(),d['taskId'],root,policy,runner) + self.assertEqual(result['state'],'VERIFYING') + self.assertEqual(calls[-1][0],'tech-complete') + self.assertEqual(calls[-1][1]['source'],source) + self.assertNotIn('leaseToken',result) + +class BudgetTests(unittest.TestCase): + def test_second_provider_call_blocked_and_tokens_forced(self): + from inference_budget import SingleCall + seen=[] + gate=SingleCall() + def create(**kwargs): seen.append(kwargs); return 'ok' + self.assertEqual(gate.call(create,{'max_tokens':999,'stream':True}),'ok') + self.assertEqual(seen,[{'max_tokens':160,'stream':False}]) + with self.assertRaises(RuntimeError): gate.call(create,{}) + self.assertEqual(len(seen),1) + +class TransportTests(unittest.TestCase): + def test_invalid_credential_rejected(self): + with self.assertRaises(ValueError): a.Transport('https://stage.invalid','short') + + def test_real_http_auth_and_denial(self): + import http.server, threading + seen=[] + class Handler(http.server.BaseHTTPRequestHandler): + def log_message(self,*args): pass + def do_POST(self): + seen.append((self.path,self.headers.get('Authorization'),json.loads(self.rfile.read(int(self.headers['Content-Length']))))) + self.send_response(403 if self.path.endswith('heartbeat') else 200) + self.end_headers(); self.wfile.write(b'{"lease":null}') + server=http.server.ThreadingHTTPServer(('127.0.0.1',0),Handler) + thread=threading.Thread(target=server.serve_forever,daemon=True); thread.start() + try: + t=a.Transport('http://127.0.0.1:'+str(server.server_port),'x'*48,allow_loopback_http=True) + self.assertEqual(t.post('tech-claim',{'taskId':'explicit'}),{'lease':None}) + with self.assertRaises(PermissionError): t.post('heartbeat',{}) + self.assertEqual(seen[0],('/internal/prepare-worker/tech-claim','Bearer '+'x'*48,{'taskId':'explicit'})) + finally: server.shutdown(); server.server_close(); thread.join() + + def test_total_deadline_includes_slow_response_body(self): + import http.server, threading, time + class Handler(http.server.BaseHTTPRequestHandler): + def log_message(self,*args): pass + def do_POST(self): + self.send_response(200); self.end_headers() + try: + for _ in range(30): self.wfile.write(b' '); self.wfile.flush(); time.sleep(.3) + except (BrokenPipeError,ConnectionResetError): pass + server=http.server.ThreadingHTTPServer(('127.0.0.1',0),Handler) + thread=threading.Thread(target=server.serve_forever,daemon=True); thread.start() + try: + t=a.Transport('http://127.0.0.1:'+str(server.server_port),'x'*48,allow_loopback_http=True) + started=time.monotonic() + with self.assertRaises(TimeoutError): t.post('heartbeat',{}) + self.assertLess(time.monotonic()-started,5) + finally: server.shutdown(); server.server_close(); thread.join() + + def test_secret_mount_rejects_unsafe_files(self): + import os + with tempfile.TemporaryDirectory() as root: + path=pathlib.Path(root,'credential'); path.write_text('x'*48); path.chmod(0o400) + # /tmp may be writable; use descriptor traversal rooted in a private fixture. + with patch.object(a,'SECRET_PATH',str(path)): + with self.assertRaises(ValueError): a.read_credential() + + def test_admission_fails_before_network(self): + class Transport: + def post(self,*args): raise AssertionError('network forbidden') + for policy in [{},dict(a.ADMISSION,maxCalls=2),dict(a.ADMISSION,maxTokens=161),dict(a.ADMISSION,monetaryCapVerified=True),dict(a.ADMISSION,maxCalls=True)]: + with self.assertRaises(ValueError): a.run_once(Transport(),lease()['taskId'],'/',policy) + +if __name__=='__main__': unittest.main()