@milpa/comal 0.0.0-stage → 0.1.1

package/src/cloud-client.mjs

@@ -0,0 +1,66 @@
+import { readFile, writeFile, mkdir, rename, unlink, lstat, open, readdir, realpath } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { createHash, randomBytes } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+import { networkFetch } from '../backend/verifier/transport.mjs';
+
+const hash=bytes=>createHash('sha256').update(bytes).digest('hex');
+const defaultOrigin='https://comal.milpahq.com';
+export function cloudOrigin(value=defaultOrigin,env=process.env){const url=new URL(value);if(url.username||url.password||url.pathname!=='/'||url.search||url.hash)throw Error('Comal Cloud requires an origin without a path or credentials.');if(url.protocol!=='https:'&&!(env.COMAL_ENV==='test'&&url.protocol==='http:'&&['localhost','127.0.0.1','[::1]','comal.localhost'].includes(url.hostname)))throw Error('Comal Cloud requires HTTPS.');return url.origin;}
+export class CloudClient {
+  constructor({env=process.env,file,origin,fetcher=networkFetch}={}){this.env=env;this.file=file||env.COMAL_CLOUD_CONFIG||path.join(env.XDG_CONFIG_HOME||path.join(os.homedir(),'.config'),'comal','cloud','credentials.json');this.explicitOrigin=origin||env.COMAL_CLOUD_ORIGIN;this.fetcher=fetcher;}
+  async credentials(){try{const stat=await lstat(this.file);if(!stat.isFile()||stat.isSymbolicLink()||(stat.mode&0o077)!==0||process.getuid&&stat.uid!==process.getuid())throw Error('Comal credentials must be a private file (0600) owned by your user.');const handle=await open(this.file,constants.O_RDONLY|constants.O_NOFOLLOW);let value;try{const current=await handle.stat();if(current.ino!==stat.ino||current.dev!==stat.dev||current.size>16384)throw Error('The credential file changed or is too large.');value=JSON.parse(await handle.readFile('utf8'));}finally{await handle.close();}const origin=cloudOrigin(value.origin,this.env);if(this.explicitOrigin&&cloudOrigin(this.explicitOrigin,this.env)!==origin)throw Error('The requested origin does not match the saved Comal session. Log in to that origin.');if(typeof value.token!=='string'||!/^[A-Za-z0-9_-]{43}$/.test(value.token))throw Error('Invalid Comal credential. Log in again.');return{...value,origin};}catch(error){if(error.code==='ENOENT')return null;throw error;}}
+  async save(value){const directory=path.dirname(this.file);await mkdir(directory,{recursive:true,mode:0o700});const stat=await lstat(directory);if(!stat.isDirectory()||stat.isSymbolicLink()||(stat.mode&0o077)!==0)throw Error('The Comal credential directory must be private (0700).');const temp=path.join(directory,'.cloud-'+randomBytes(12).toString('hex'));try{await writeFile(temp,JSON.stringify(value)+'\n',{mode:0o600,flag:'wx'});await rename(temp,this.file);}finally{await unlink(temp).catch(error=>{if(error.code!=='ENOENT')throw error;});}}
+  async request(origin,operation,input={},token,signal){const networkOrigin=this.env.COMAL_CLOUD_NETWORK_ORIGIN;if(networkOrigin&&this.env.COMAL_ENV!=='test')throw Error('Comal laboratory transport is disabled in production.');const response=await this.fetcher(origin+'/api/operations/'+encodeURIComponent(operation),{networkOrigin,method:'POST',headers:{'Content-Type':'application/json',...(token?{Authorization:'Bearer '+token}:{})},body:JSON.stringify(input),signal:signal?AbortSignal.any([signal,AbortSignal.timeout(operation==='media.upload'?90000:30000)]):AbortSignal.timeout(operation==='media.upload'?90000:30000),maxBytes:2097152});if(response.headers.get('content-length')>2097152)throw Error('Comal response is too large.');const reader=response.body?.getReader();let length=0,parts=[];if(reader){try{for(;;){const{done,value}=await reader.read();if(done)break;length+=value.byteLength;if(length>2097152){await reader.cancel();throw Error('Comal response is too large.');}parts.push(Buffer.from(value));}}finally{reader.releaseLock();}}let body;try{body=JSON.parse(Buffer.concat(parts).toString('utf8'));}catch{throw Error('Comal returned an invalid response (HTTP '+response.status+').');}if(!response.ok||!body.ok){const error=Error((body.error?.code||'CLOUD_HTTP')+': '+(body.error?.message||'HTTP '+response.status));error.code=body.error?.code;error.status=response.status;throw error;}return body.result;}
+  async invoke(operation,input={},options={}){const credential=await this.credentials();if(!credential)throw Error('Connect your account with comal cloud login.');if(options.expectedAccount&&(credential.origin!==options.expectedAccount.origin||credential.user_id!==options.expectedAccount.user_id))throw Error('The Comal account changed during publication. Check the destination and publish again.');if(credential.expires_at<=Date.now()/1000)throw Error('Your Comal session expired. Use comal cloud login.');return this.request(credential.origin,operation,input,credential.token,options.signal);}
+  async status(options={}){const credential=await this.credentials();if(!credential)return{authenticated:false,origin:cloudOrigin(this.explicitOrigin||defaultOrigin,this.env)};const result=await this.invoke('account.inspect',{},options);const workspaces=await this.invoke('workspaces.list',{},options);return{authenticated:true,origin:credential.origin,user:result.user,identities:result.identities,expires_at:credential.expires_at,workspaces:workspaces.workspaces};}
+  async login({label=os.hostname()+' · Comal CLI',signal,onCode=()=>{}}={}){const origin=cloudOrigin(this.explicitOrigin||defaultOrigin,this.env);const proof=randomBytes(32).toString('base64url');const flow=await this.request(origin,'device.begin',{label:label.slice(0,80),code_challenge:createHash('sha256').update(proof).digest('base64url')},null,signal);if(!/^[A-Za-z0-9_-]{43}$/.test(flow.device_code)||!Number.isSafeInteger(flow.expires_in)||flow.expires_in<1||flow.expires_in>600)throw Error('Invalid CLI connection contract.');const uri=new URL(flow.verification_uri_complete);if(uri.origin!==origin||uri.pathname!=='/connect')throw Error('Comal returned a different authentication destination.');await onCode({verification_uri:flow.verification_uri,verification_uri_complete:flow.verification_uri_complete,user_code:flow.user_code,expires_in:flow.expires_in});const deadline=Date.now()+flow.expires_in*1000;let interval=5;while(Date.now()<deadline){await delay(interval*1000,null,{signal});const result=await this.request(origin,'device.exchange',{device_code:flow.device_code,code_verifier:proof},null,signal);if(result.status==='authorization_pending')continue;if(result.status==='slow_down'){interval=Math.min(30,Math.max(interval+5,result.interval||10));continue;}if(result.status==='access_denied')throw Error('The connection was denied in Comal.');if(result.status!=='authenticated'||!/^[A-Za-z0-9_-]{43}$/.test(result.access_token)||!Number.isSafeInteger(result.expires_at))throw Error('Comal returned an invalid token exchange.');await this.save({version:1,origin,token:result.access_token,user_id:result.user_id,expires_at:result.expires_at});return this.status({signal});}throw Error('The Comal code expired. Start the connection again.');}
+  async logout({signal}={}){const credential=await this.credentials();if(!credential)return{revoked:false,local_session:false};try{await this.request(credential.origin,'account.logout',{},credential.token,signal);}catch(error){if(error.code!=='AUTH_INVALID')throw error;}await unlink(this.file);return{revoked:true,local_session:false,origin:credential.origin};}
+}
+const staticTypes=new Set(['html','htm','js','mjs','css','json','map','txt','svg','png','jpg','jpeg','webp','gif','ico','woff','woff2']);
+export async function bundleArtifact(directory,{workspaceRoot,onVideo}={}){const base=await realpath(directory);if(workspaceRoot){const workspace=await realpath(workspaceRoot);if(base!==workspace&&!base.startsWith(workspace+path.sep))throw Error('Publication must stay within this session workspace.');}const files=[];let bytes=0,videos=0;async function visit(relative=''){const entries=await readdir(path.join(base,relative),{withFileTypes:true});entries.sort((a,b)=>a.name.localeCompare(b.name,'en'));for(const entry of entries){if(entry.name.startsWith('.'))continue;const name=relative?relative+'/'+entry.name:entry.name;const full=path.join(base,name);if(Buffer.byteLength(name)>512||/[\\%\x00-\x20\x7f?#]/.test(name)||name.split('/').some(part=>!part||part.startsWith('.')))throw Error('Published paths must be normalized relative paths without spaces or reserved characters: '+name);if(entry.isSymbolicLink())throw Error('Symbolic links cannot be published: '+name);if(entry.isDirectory()){await visit(name);continue;}if(entry.isFile()&&path.extname(entry.name).toLowerCase()==='.mp4'&&onVideo){if(++videos>4)throw Error('An artifact supports up to four videos.');await onVideo(full,name);continue;}if(!entry.isFile()||!staticTypes.has(path.extname(entry.name).slice(1).toLowerCase()))throw Error('The directory must contain only static web files: '+name);if(files.length>=256)throw Error('The artifact exceeds 256 files.');const current=await realpath(full);if(!current.startsWith(base+path.sep))throw Error('A file is outside the publication directory.');const handle=await open(full,constants.O_RDONLY|constants.O_NOFOLLOW);try{const stat=await handle.stat();if(!stat.isFile()||bytes+stat.size>8388608)throw Error('The artifact exceeds 8 MiB.');const content=await handle.readFile();bytes+=content.length;if(bytes>8388608)throw Error('The artifact exceeds 8 MiB.');files.push({path:name,content_base64:content.toString('base64'),sha256:hash(content)});}finally{await handle.close();}}}await visit();if(!files.length&&!videos)throw Error('The publication directory is empty.');return files;}
+async function captureArtifactVideo(file,workspaceRoot){
+  const absolute=path.resolve(file),base=await realpath(workspaceRoot);const actual=await realpath(absolute);
+  if(!actual.startsWith(base+path.sep))throw Error('Video must stay inside the session workspace.');
+  if(path.extname(absolute).toLowerCase()!=='.mp4')throw Error('Only source MP4 videos are supported.');
+  const inspected=await lstat(actual,{bigint:true});
+  const handle=await open(actual,constants.O_RDONLY|constants.O_NOFOLLOW|constants.O_NONBLOCK);
+  let content;
+  try{const before=await handle.stat({bigint:true});if(before.ino!==inspected.ino||before.dev!==inspected.dev||!before.isFile()||before.size<16n||before.size>8388608n)throw Error('A source MP4 of at most 8 MiB is required.');
+    const buffer=Buffer.alloc(Number(before.size)+1);let length=0;while(length<buffer.length){const read=await handle.read(buffer,length,buffer.length-length,null);if(!read.bytesRead)break;length+=read.bytesRead;}
+    const after=await handle.stat({bigint:true});if(length!==Number(before.size)||before.ino!==after.ino||before.dev!==after.dev||before.mtimeNs!==after.mtimeNs||before.ctimeNs!==after.ctimeNs)throw Error('Video changed while being captured.');
+    if(await realpath(absolute)!==actual)throw Error('Video path changed during capture.');const current=await lstat(actual,{bigint:true});if(current.ino!==before.ino||current.dev!==before.dev)throw Error('Video path changed during capture.');
+    content=buffer.subarray(0,length);if(content.subarray(4,8).toString()!=='ftyp')throw Error('The selected file is not an MP4.');
+  }finally{await handle.close();}
+  return content;
+}
+async function sendArtifactVideo(client,content,{workspace_id,session_id},options={}){
+  const account=await client.credentials();if(!account)throw Error('Connect your account with /cloud login.');
+  if(options.expectedAccount&&(options.expectedAccount.origin!==account.origin||options.expectedAccount.user_id!==account.user_id))throw Error('The Comal account changed before video upload.');
+  const authority={...options,expectedAccount:{origin:account.origin,user_id:account.user_id}};
+  let result=await client.invoke('media.upload',{workspace_id,session_id,sha256:hash(content),content_base64:content.toString('base64')},authority);
+  const deadline=Date.now()+90000;
+  while(result.status!=='ready'&&Date.now()<deadline){if(result.status==='failed')throw Error('Gumlet could not process this video. Inspect media '+result.id+'.');await delay(2000,null,{signal:options.signal});result=await client.invoke('media.inspect',{media_id:result.id},authority);}
+  if(result.status!=='ready')throw Error('Video '+result.id+' is still processing. Retry the same source to reconcile it without another upload.');
+  return result;
+}
+export async function uploadArtifactVideo(client,{file,workspaceRoot,...metadata},options={}){return sendArtifactVideo(client,await captureArtifactVideo(file,workspaceRoot),metadata,options);}
+export async function publishArtifact(client,{directory,workspaceRoot=directory,...metadata},options={}){
+  const account=await client.credentials();if(!account)throw Error('Connect your account with comal cloud login.');
+  const authority={...options,expectedAccount:{origin:account.origin,user_id:account.user_id}},media=[],videos=[];
+  const files=await bundleArtifact(directory,{workspaceRoot,onVideo:async(file,name)=>{
+    videos.push({content:await captureArtifactVideo(file,workspaceRoot),path:name.slice(0,-4)+'.player.html'});
+  }});
+  if(metadata.entrypoint?.toLowerCase().endsWith('.mp4'))metadata.entrypoint=metadata.entrypoint.slice(0,-4)+'.player.html';
+  if(videos.length){
+    const paths=new Set(files.map(file=>file.path));for(const video of videos){if(paths.has(video.path))throw Error('Generated video player conflicts with another published path: '+video.path);paths.add(video.path);}
+    if(paths.size>256||files.reduce((sum,file)=>sum+Buffer.byteLength(file.content_base64,'base64'),0)+videos.length*2048>8388608)throw Error('The artifact exceeds its static budget including generated video players.');
+    if(!paths.has(metadata.entrypoint)||!/[.]html?$/i.test(metadata.entrypoint))throw Error('The entrypoint must exist as HTML or a selected MP4; use clip.mp4 for its generated player.');
+  }
+  for(const capture of videos){const video=await sendArtifactVideo(client,capture.content,metadata,authority);media.push({path:capture.path,media_id:video.id});}
+  const input={...metadata,files,...(media.length?{media}:{})};
+  input.request_id='comal_'+hash(JSON.stringify({origin:account.origin,user:account.user_id,input}));
+  return client.invoke('artifacts.publish',input,authority);
+}

package/src/code-run-worker.mjs

@@ -0,0 +1,70 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { getQuickJS } from 'quickjs-emscripten';
+
+const { code, catalogue, limits } = workerData;
+const module = await getQuickJS(), runtime = module.newRuntime();
+runtime.setMemoryLimit(limits.memoryBytes); runtime.setMaxStackSize(limits.stackBytes);
+let cpuLeft = limits.cpuMs, activeStart = performance.now(), stopped = false, sequence = 0, emitted = 2;
+runtime.setInterruptHandler(() => performance.now() - activeStart > cpuLeft);
+const vm = runtime.newContext(), pending = new Map(), output = [];
+const allowedNames = new Set(catalogue.map(row => row.name));
+const enter = fn => { activeStart = performance.now(); try { return fn(); } finally { cpuLeft -= performance.now() - activeStart; } };
+const expose = (name, fn) => { const handle = vm.newFunction(name, fn); vm.setProp(vm.global, name, handle); handle.dispose(); };
+const jsonHandle = value => vm.unwrapResult(enter(() => vm.evalCode(`JSON.parse(${JSON.stringify(JSON.stringify(value))})`)));
+function fail(error) {
+  if (stopped) return; stopped = true;
+  const message = error.message || String(error);
+  const code = error.code || (cpuLeft <= 0 || /interrupted/.test(message) ? 'CODE_RUN_CPU_LIMIT' : /out of memory|allocation failed/i.test(message) ? 'CODE_RUN_MEMORY_LIMIT' : /stack overflow/i.test(message) ? 'CODE_RUN_STACK_LIMIT' : /output byte limit/.test(message) ? 'CODE_RUN_OUTPUT_LIMIT' : /call\/concurrency limit/.test(message) ? 'CODE_RUN_CALL_LIMIT' : /argument byte limit/.test(message) ? 'CODE_RUN_ARGUMENT_LIMIT' : /outside the read-only caller catalogue/.test(message) ? 'CODE_RUN_TOOL_UNAVAILABLE' : 'CODE_RUN_SCRIPT');
+  parentPort.postMessage({ type: 'error', code, message, output });
+}
+expose('__emit', value => {
+  const text = vm.getString(value); emitted += Buffer.byteLength(text) + (output.length ? 1 : 0);
+  if (emitted > limits.outputBytes) throw Object.assign(new Error('CodeRun output byte limit exceeded.'), {code:'CODE_RUN_OUTPUT_LIMIT'});
+  const item = JSON.parse(text); output.push(item); parentPort.postMessage({type:'output',value:item});
+});
+expose('__call', (nameHandle, argsHandle) => {
+  const name = vm.getString(nameHandle), raw = vm.getString(argsHandle);
+  // Enforce before IPC too: a VM loop cannot flood the parent with queued RPCs.
+  if (++sequence > limits.calls || pending.size >= limits.concurrency) throw new Error('CodeRun tool call/concurrency limit exceeded.');
+  if (!allowedNames.has(name)) throw new Error('Tool is outside the read-only caller catalogue.');
+  if (Buffer.byteLength(raw) > limits.argumentBytes) throw new Error('CodeRun tool argument byte limit exceeded.');
+  const deferred = vm.newPromise(), id = sequence; pending.set(id, deferred);
+  parentPort.postMessage({ type: 'call', id, name, args: JSON.parse(raw) });
+  return deferred.handle;
+});
+let script;
+try {
+  // All metadata enters as JSON. Bindings expose only VM values, never native
+  // host objects or host function constructors. No module loader is installed.
+  vm.unwrapResult(enter(() => vm.evalCode(`
+    const ALL_TOOLS = Object.freeze(${JSON.stringify(catalogue)}.map(t => Object.freeze(t)));
+    const __allowed = new Set(ALL_TOOLS.map(t => t.name));
+    const tools = Object.freeze({...Object.fromEntries(ALL_TOOLS.map(t => [t.name, args => __call(t.name, JSON.stringify(args ?? {})).then(JSON.parse)])), call: (name,args) => __call(String(name),JSON.stringify(args ?? {})).then(JSON.parse)});
+    function text(value) { const encoded = JSON.stringify(value); __emit(encoded === undefined ? 'null' : encoded); }
+    function searchTools(query = '') { return ALL_TOOLS.filter(t => (t.name+' '+t.description).toLowerCase().includes(String(query).toLowerCase())).map(t => ({name:t.name,description:t.description})); }
+    function describeTool(name) { return ALL_TOOLS.find(t => t.name === name) || null; }
+    Object.freeze(tools); Object.freeze(searchTools); Object.freeze(describeTool);
+  `))).dispose();
+  script = vm.unwrapResult(enter(() => vm.evalCode(`(async () => { "use strict";\n${code}\n})().then(value => { if(value !== undefined) text(value); })`, 'comal-code-run.js')));
+  pump();
+} catch (error) { fail(error); }
+function pump() {
+  if (stopped) return;
+  try {
+    const jobs = enter(() => runtime.executePendingJobs());
+    if (jobs.error) { const error = vm.dump(jobs.error); jobs.error.dispose(); throw error; }
+    const state = vm.getPromiseState(script);
+    if (state.type === 'fulfilled') { state.value.dispose(); stopped = true; parentPort.postMessage({type:'done', output}); }
+    else if (state.type === 'rejected') { const error = vm.dump(state.error); state.error.dispose(); throw error; }
+    else if (!pending.size) throw new Error('CodeRun promise cannot make progress without an awaited tool.');
+  } catch (error) { fail(error); }
+}
+parentPort.on('message', message => {
+  if (stopped || message.type !== 'result') return;
+  const deferred = pending.get(message.id); if (!deferred) return; pending.delete(message.id);
+  try {
+    const handle = message.ok ? vm.newString(message.value) : jsonHandle({name:'Error', message:message.value, code:message.code || 'CODE_RUN_TOOL'});
+    if (message.ok) deferred.resolve(handle); else deferred.reject(handle);
+    handle.dispose(); deferred.dispose(); pump();
+  } catch (error) { fail(error); }
+});

package/src/code-run.mjs

@@ -0,0 +1,97 @@
+import { Worker } from 'node:worker_threads';
+import { randomUUID } from 'node:crypto';
+import { digest } from './operations.mjs';
+import { chromeLabObservation } from './read-only-check.mjs';
+
+export const CODE_RUN_LIMITS = Object.freeze({ sourceBytes: 32768, outputBytes: 16384, resultBytes: 1048576, argumentBytes: 65536, calls: 32, concurrency: 4, wallMs: 30000, cpuMs: 2000, memoryBytes: 33554432, stackBytes: 262144, cleanupMs: 2000 });
+const ceiling = { ...CODE_RUN_LIMITS, wallMs: 60000, cpuMs: 5000, memoryBytes: 67108864 };
+const failure = (code, message) => Object.assign(new Error(message), { code });
+const activeRuns = new Set();
+export const CODE_RUN_MAX_WORKERS = 2;
+export const codeRunEligible = row => Boolean(row && row.name !== 'CodeRun' && row.permission === row.name && !row.steps && row.audience !== 'human' && ['none', 'read'].includes(row.effects?.workspace) && ['none', 'read'].includes(row.effects?.external) && (row.effects?.process === 'none' || row.effects?.process === 'spawn' && row.origin?.plugin === 'chrome-lab' && chromeLabObservation(row.name)) && row.effects?.authority === 'none');
+export const codeRunDefinition = Object.freeze({
+  name: 'CodeRun', description: 'Experimental read-only JavaScript composition in an isolated QuickJS VM. Use searchTools/describeTool for the currently visible tool catalogue, tools.call(name,args) or tools[name](args) to call tools and text(value) or return value to emit selected observations. No filesystem, network, Node APIs, timers, persistence or nested CodeRun. Every tool call retains its own House judgment and receipt. Effects completed before an error remain recorded; never automatically replay the script.',
+  input_schema: { type: 'object', properties: { code: { type: 'string', minLength: 1, maxLength: 32768 } }, required: ['code'], additionalProperties: false },
+  effects: { workspace: 'read', external: 'read', process: 'spawn', authority: 'none' }, steps: true, permission: 'CodeRun', run: runCode,
+});
+
+// Caller supplies a captured, actor-scoped catalogue AND its matching House invoke.
+// No tool code, host objects, credentials or runtime resources cross the VM boundary.
+export async function runCode({ code }, options = {}) {
+  const { invoke, recordWork, signal } = options;
+  if (typeof invoke !== 'function' || typeof recordWork !== 'function' || !Array.isArray(options.catalogue)) throw failure('CODE_RUN_HOST', 'CodeRun requires the caller catalogue, governed invoke and durable recorder.');
+  const limits = { ...CODE_RUN_LIMITS };
+  for (const [key, value] of Object.entries(options.limits || {})) {
+    if (!(key in limits) || !Number.isSafeInteger(value) || value < 1 || value > ceiling[key]) throw failure('CODE_RUN_LIMIT', `Invalid CodeRun limit: ${key}.`);
+    limits[key] = value;
+  }
+  if (typeof code !== 'string' || !code.trim() || Buffer.byteLength(code) > limits.sourceBytes) throw failure('CODE_RUN_SOURCE_LIMIT', 'CodeRun source exceeds its byte limit or is empty.');
+  signal?.throwIfAborted();
+  const catalogue = options.catalogue.filter(codeRunEligible).map(row => ({ name: row.name, description: row.description, input_schema: row.input_schema, effects: row.effects, contract_digest: row.contract_digest }));
+  const visible = new Map(catalogue.map(row => [row.name, row]));
+  const runId = randomUUID(), sourceRef = digest(code), controller = new AbortController();
+  const pending = new Map(), calls = []; let total = 0, closed = false, worker, timer;
+  if (activeRuns.size >= CODE_RUN_MAX_WORKERS) throw failure('CODE_RUN_BUSY', 'Two CodeRun runtimes are already active; wait for completion before proposing another run.');
+  activeRuns.add(runId);
+  try { await recordWork({ type: 'code_run_source', run_id: runId, source_ref: sourceRef, source: code, limits, max_workers: CODE_RUN_MAX_WORKERS, catalogue: catalogue.map(({name,contract_digest}) => ({name,contract_digest})) }); }
+  catch(error) { activeRuns.delete(runId); throw error; }
+  let rejectRun;
+  const abort = () => { const error = signal?.reason instanceof Error ? signal.reason : failure('CODE_RUN_ABORTED', 'CodeRun was cancelled.'); controller.abort(error); rejectRun?.(error); };
+  signal?.addEventListener('abort', abort, { once: true });
+  let selected = [], runError;
+  try {
+    signal?.throwIfAborted();
+    worker = new Worker(new URL('./code-run-worker.mjs', import.meta.url), { workerData: { code, catalogue, limits }, resourceLimits: { maxOldGenerationSizeMb: 96, stackSizeMb: 4 }, execArgv: [] });
+    selected = await new Promise((resolve, reject) => {
+      rejectRun = reject;
+      timer = setTimeout(() => { const e = failure('CODE_RUN_TIMEOUT', 'CodeRun wall deadline exceeded.'); controller.abort(e); reject(e); }, limits.wallMs);
+      worker.on('error', reject);
+      worker.on('exit', exit => { if (!closed && exit !== 0) reject(failure('CODE_RUN_WORKER', `CodeRun worker exited (${exit}).`)); });
+      worker.on('message', message => {
+        if (closed) return;
+        if (message.type === 'output') { selected.push(message.value); return; }
+        if (message.type === 'done') { resolve(message.output); return; }
+        if (message.type === 'error') { selected = message.output || []; reject(failure(message.code || 'CODE_RUN_SCRIPT', message.message)); return; }
+        if (message.type !== 'call') return;
+        const { id, name, args } = message;
+        const answer = (ok, value, errorCode) => { if (!closed) worker.postMessage({ type: 'result', id, ok, value, code: errorCode }); };
+        if (controller.signal.aborted) { answer(false, 'CodeRun is stopping.', 'CODE_RUN_ABORTED'); return; }
+        if (!visible.has(name)) { answer(false, 'Tool is outside the read-only caller catalogue.', 'CODE_RUN_TOOL_UNAVAILABLE'); return; }
+        if (++total > limits.calls || pending.size >= limits.concurrency) { answer(false, 'CodeRun tool call/concurrency limit exceeded.', 'CODE_RUN_CALL_LIMIT'); return; }
+        if (Buffer.byteLength(JSON.stringify(args) ?? '') > limits.argumentBytes) { answer(false, 'CodeRun tool arguments exceed their byte limit.', 'CODE_RUN_ARGUMENT_LIMIT'); return; }
+        const callId = `${runId}:${id}`, row = { call_id: callId, operation: name, contract_digest: visible.get(name).contract_digest, arguments_digest: digest(args), status: 'started' }; calls.push(row);
+        const work = (async () => {
+          try {
+            // This callback runs in the parent operation's async context; House
+            // revalidates contracts, visibility and authority at the effect frontier.
+            const result = await invoke(name, args, { signal: controller.signal, callId, modelProposed: true });
+            row.status = 'returned'; row.output_ref = digest(result);
+            const encoded = JSON.stringify(result);
+            if (Buffer.byteLength(encoded ?? '') > limits.resultBytes) throw failure('CODE_RUN_RESULT_LIMIT', 'Tool observation exceeds the VM transfer limit; the complete House receipt remains recorded.');
+            answer(true, encoded ?? 'null');
+          } catch (error) { row.status = row.status === 'returned' ? 'returned_untransferred' : 'failed_or_refused'; row.code = error.code; answer(false, error.message, error.code); }
+        })();
+        pending.set(id, work); work.finally(() => pending.delete(id));
+      });
+    });
+  } catch (error) { runError = error; }
+  finally {
+    closed = true; clearTimeout(timer); signal?.removeEventListener('abort', abort);
+    controller.abort(runError || failure('CODE_RUN_FINISHED', 'CodeRun script finished; unawaited calls are cancelled.'));
+    await worker?.terminate().catch(() => {});
+    if (pending.size) {
+      let cleanupTimer;
+      const settled = await Promise.race([Promise.allSettled([...pending.values()]).then(() => true), new Promise(resolve => { cleanupTimer = setTimeout(() => resolve(false), limits.cleanupMs); })]); clearTimeout(cleanupTimer);
+      if (!settled) runError = failure('CODE_RUN_CLEANUP_PENDING', 'A host tool ignored cancellation; its outcome remains unknown/partial. Pending call IDs are recorded. Do not replay this script.');
+    }
+    activeRuns.delete(runId);
+  }
+  const outputRef = digest(selected);
+  const outcome = { run_id: runId, source_ref: sourceRef, output_ref: outputRef, output: selected, status: runError ? 'failed' : 'returned', code: runError?.code, error: runError?.message, calls: structuredClone(calls), pending_calls: [...pending.keys()].map(id => `${runId}:${id}`), replayed: false };
+  await recordWork({ type: 'code_run_result', ...outcome });
+  if (runError) {
+    const details = { ...outcome, message: runError.message, next_action: 'Inspect this run and individual House receipts using the recorded call IDs. Preserve completed observations. Do not replay the script automatically; pending host calls may still have unknown/partial outcomes.' };
+    const error = failure(runError.code || 'CODE_RUN_SCRIPT', JSON.stringify(details)); error.run_id = runId; error.details = details; throw error;
+  }
+  return JSON.stringify({ run_id: runId, output: selected, source_ref: sourceRef, output_ref: outputRef, calls: calls.length });
+}

package/src/codex-provider.mjs

@@ -0,0 +1,219 @@
+import { compileToolSchemas } from './tool-schema.mjs';
+import { normalizeUsage, bindUsageAccounting, accountingIdentity } from './usage-accounting.mjs';
+import { sseEvents, analyzeImages } from './provider.mjs';
+import { modelDeadline, modelTimingSettings } from './model-deadline.mjs';
+import { normalizeEffort } from './model-controls.mjs';
+
+const fail = (message, code = 'CODEX_RESPONSE_INVALID') => Object.assign(new Error(message), { code });
+// Catalog compatibility is independent of Comal's application version. The
+// backend returns no models for 0.1.0; 0.162.1 was verified against the installed
+// Codex CLI and a metadata-only request. Client identity remains Comal.
+export const CODEX_CATALOG_VERSION = '0.162.1';
+const id = value => typeof value === 'string' && value.length > 0 && value.length < 512 && !/[\x00-\x20\x7f]/.test(value);
+
+// Keep machine-readable rejection metadata, never the raw error body/message:
+// providers may echo request content, credentials or encrypted reasoning there.
+function responseFailure(value, httpStatus) {
+  const response = value?.response || value;
+  const upstream = response?.error || (value?.type === 'error' ? value : null);
+  const field = (value, pattern = /^[A-Za-z0-9_.:-]{1,100}$/) => typeof value === 'string' && pattern.test(value) ? value : undefined;
+  const metadata = Object.fromEntries(Object.entries({ code: field(upstream?.code), type: field(upstream?.type), param: field(upstream?.param, /^[A-Za-z0-9_.\[\]-]{1,160}$/) }).filter(([, value]) => value !== undefined));
+  const reason = field(response?.incomplete_details?.reason);
+  let code = 'CODEX_RESPONSE_INCOMPLETE', message = 'Incomplete Codex response';
+  if (reason === 'max_output_tokens') code = 'OUTPUT_LENGTH';
+  else if (metadata.code === 'context_length_exceeded') code = 'CONTEXT_LENGTH';
+  else if (metadata.code === 'invalid_function_parameters') { code = 'CODEX_TOOL_SCHEMA_INVALID'; message = 'Codex rejected the tool schema'; }
+  else if (metadata.type === 'invalid_request_error' || metadata.code === 'invalid_request_error') { code = 'CODEX_REQUEST_REJECTED'; message = 'Codex rejected the request'; }
+  else if (upstream) { code = 'CODEX_RESPONSE_FAILED'; message = 'Codex returned an error'; }
+  if (httpStatus === 401) { code = 'PROVIDER_AUTH_REQUIRED'; message = 'Codex requires login'; }
+  else if (httpStatus && code === 'CODEX_RESPONSE_INCOMPLETE') { code = 'CODEX_HTTP_ERROR'; message = `Codex HTTP ${httpStatus}`; }
+  const diagnostic = [metadata.code, metadata.param, reason].filter(Boolean).join('; ');
+  return Object.assign(fail(`${message}${diagnostic ? ` (${diagnostic})` : ''}; no tools from this response were executed.`, code), {
+    usage_accounting:normalizeUsage('codex',response?.usage),
+    details: { provider: 'codex', upstream: metadata, ...(reason ? { reason } : {}), ...(httpStatus ? { http_status: httpStatus } : {}), tools_executed: false,
+      ...(['CODEX_TOOL_SCHEMA_INVALID', 'CODEX_REQUEST_REJECTED'].includes(code) ? { retryable: false } : {}) }
+  });
+}
+
+// Some Codex responses omit Content-Type despite carrying SSE. Inspect a
+// bounded prefix, then replay every byte: framing must not depend on a header.
+async function responseFormat(body) {
+  if (!body) throw fail('Codex returned an empty body.', 'CODEX_RESPONSE_INCOMPLETE');
+  const reader=body.getReader(),chunks=[],decoder=new TextDecoder();let prefix='',size=0,format;
+  try {
+    while(!format){
+      const{done,value}=await reader.read();
+      if(done)throw fail('Codex returned an empty or incomplete body.', 'CODEX_RESPONSE_INCOMPLETE');
+      chunks.push(value);const head=value.subarray(0,Math.max(0,4096-size));size+=head.byteLength;
+      prefix+=decoder.decode(head,{stream:true});const start=prefix.trimStart();
+      if(start.startsWith('{'))format='json';
+      else if(start.startsWith(':') || /^(?:event|data|id|retry):/.test(start))format='sse';
+      else if(size>=4096 || start && !['event:','data:','id:','retry:'].some(field=>field.startsWith(start)))throw fail('Unknown Codex response format; no tools were executed.');
+    }
+  }catch(error){await reader.cancel().catch(()=>{});reader.releaseLock();throw error;}
+  return{format,body:{async *[Symbol.asyncIterator](){
+    try{for(const chunk of chunks)yield chunk;for(;;){const{value,done}=await reader.read();if(done)break;yield value;}}
+    finally{await reader.cancel().catch(()=>{});reader.releaseLock();}
+  }}};
+}
+
+async function responseJSON(body, maxBytes = 8 * 1024 * 1024) {
+  const decoder=new TextDecoder();let text='',size=0;
+  for await(const chunk of body){size+=chunk.byteLength;if(size>maxBytes)throw fail('The Codex response exceeded its byte limit.');text+=decoder.decode(chunk,{stream:true});}
+  try{return JSON.parse(text+decoder.decode());}catch{throw fail('Codex returned invalid JSON; no tools were executed.');}
+}
+
+export function toCodexInput(messages) {
+  const input = [];
+  for (const message of messages) {
+    const blocks = typeof message.content === 'string' ? [{ type: 'text', text: message.content }] : message.content || [];
+    if (message.role === 'assistant') {
+      for (const block of blocks) {
+        if (block.type === 'openai_reasoning' && block.codex_item) input.push(structuredClone(block.codex_item));
+        else if (block.type === 'tool_use') input.push({ type: 'function_call', call_id: block.id, name: block.name, arguments: JSON.stringify(block.input) });
+        else if (block.type === 'text' && block.text) input.push({ role: 'assistant', content: [{ type: 'output_text', text: block.text }] });
+      }
+    } else if (message.role === 'user') {
+      for (const block of blocks) if (block.type === 'tool_result') input.push({ type: 'function_call_output', call_id: block.tool_use_id,
+        output: (block.is_error ? 'Tool error: ' : '') + (typeof block.content === 'string' ? block.content : JSON.stringify(block.content)) });
+      const content = blocks.flatMap(block => {
+        if (block.type === 'text') return [{ type: 'input_text', text: block.text }];
+        if (block.type === 'image' && block.source?.type === 'base64') return [{ type: 'input_image', image_url: `data:${block.source.media_type};base64,${block.source.data}` }];
+        if (['video', 'media', 'image_reference'].includes(block.type)) throw fail('Unsupported media or unresolved reference.', 'PROVIDER_CAPABILITY_UNAVAILABLE');
+        return [];
+      });
+      if (content.length) input.push({ role: 'user', content });
+    }
+  }
+  return input;
+}
+function normalized(response) {
+  if (response?.status !== 'completed' || !Array.isArray(response.output)) throw responseFailure(response);
+  const content = [], ids = new Set();
+  for (const item of response.output) {
+    if (item.type === 'message') {
+      if (item.status && item.status !== 'completed') throw fail('Mensaje Codex incompleto.');
+      for (const block of item.content || []) {
+        if (block.type === 'output_text') content.push({ type: 'text', text: block.text });
+        else if (block.type === 'refusal') content.push({ type: 'text', text: block.refusal });
+      }
+    } else if (item.type === 'function_call') {
+      if (!id(item.call_id) || ids.has(item.call_id) || !id(item.name) || typeof item.arguments !== 'string') throw fail('Invalid Codex tool call.');
+      let args; try { args = JSON.parse(item.arguments); } catch { throw fail('Argumentos Codex incompletos.', 'TOOL_ARGUMENTS_INVALID'); }
+      if (!args || typeof args !== 'object' || Array.isArray(args)) throw fail('Argumentos Codex deben ser objeto.', 'TOOL_ARGUMENTS_INVALID');
+      ids.add(item.call_id); content.push({ type: 'tool_use', id: item.call_id, name: item.name, input: args });
+    } else if (item.type === 'reasoning') content.push({ type: 'openai_reasoning', text: (item.summary || []).map(block => block.text || '').join('\n'), codex_item: structuredClone(item) });
+  }
+  if (!content.length) throw fail('Codex returned an empty response.');
+  return { role: 'assistant', content, stop_reason: ids.size ? 'tool_use' : 'end_turn', usage_accounting:normalizeUsage('codex',response.usage), usage: {
+    input_tokens: response.usage?.input_tokens || 0, output_tokens: response.usage?.output_tokens || 0,
+    ...(response.usage?.input_tokens_details?.cached_tokens ? { cache_read_input_tokens: response.usage.input_tokens_details.cached_tokens } : {}) } };
+}
+
+// Subscription bearer tokens go only to the fixed Codex backend, never api.openai.com.
+export class CodexProvider {
+  constructor({ authManager, authProvider = 'codex', model, maxTokens = 4096, effort = 'auto', fetchImpl = globalThis.fetch, timeoutMs, idleTimeoutMs, vision, capabilitiesConfigured, profile, ...options } = {}) {
+    if (!authManager || authProvider !== 'codex') throw new Error('CodexProvider requires AuthManager and authProvider codex.');
+    this.authManager = authManager; this.authProvider = authProvider; this.protocol = 'openai'; this.model = model;
+    this.baseURL = 'https://chatgpt.com/backend-api/codex'; this.fetch = fetchImpl; this.maxTokens = maxTokens;
+    this.capabilitiesConfigured = { ...profile?.capabilitiesConfigured, ...capabilitiesConfigured };
+    for (const [name, enabled] of Object.entries(this.capabilitiesConfigured)) if (!['text', 'tools', 'thinking', 'vision', 'video', 'web_search'].includes(name) || typeof enabled !== 'boolean') throw fail('Invalid Codex capability configuration.', 'PROVIDER_CAPABILITY_UNAVAILABLE');
+    if (this.capabilitiesConfigured.text === false || this.capabilitiesConfigured.video === true || this.capabilitiesConfigured.web_search === true) throw fail('The Codex adapter requires text and does not implement native video/web_search.', 'PROVIDER_CAPABILITY_UNAVAILABLE');
+    this.effort = normalizeEffort(effort); this.vision = vision || (Object.hasOwn(this.capabilitiesConfigured, 'vision') ? this.capabilitiesConfigured.vision ? 'on' : 'off' : 'auto'); this.imageTokens = options.imageTokens || 4096;
+    if (!['auto', 'on', 'off'].includes(this.vision)) throw fail('Invalid Codex vision setting.');
+    this.configuredCapabilities = this.capabilitiesConfigured;
+    if (profile?.name) this.profileName = profile.name;
+    Object.assign(this, modelTimingSettings({ timeoutMs, idleTimeoutMs }));
+  }
+  async _fetch(endpoint, options = {}) {
+    const credentials = await this.authManager.resolve('codex', { signal: options.signal });
+    const response = await this.fetch(`${this.baseURL}/${endpoint}`, { ...options, redirect: 'error', headers: {
+      'content-type': 'application/json', Authorization: `Bearer ${credentials.apiKey}`, ...credentials.headers, ...options.headers } });
+    if (!response.ok) {
+      let error; try { error = await responseJSON(response.body, 65536); } catch { /* Never echo an unstructured error body. */ }
+      finally { await response.body?.cancel().catch(() => {}); }
+      throw responseFailure(error, response.status);
+    }
+    return response;
+  }
+  async listModels({ signal } = {}) {
+    const timeout = AbortSignal.timeout(15000), response = await this._fetch(`models?client_version=${CODEX_CATALOG_VERSION}`, { signal: signal ? AbortSignal.any([signal, timeout]) : timeout });
+    const text = await response.text();
+    if (text.length > 1024 * 1024) throw fail('Codex catalog is too large.');
+    let data; try { data = JSON.parse(text); } catch { throw fail('Invalid Codex catalog.'); }
+    const models = data.models || data.data;
+    if (!Array.isArray(models)) throw fail('Codex did not advertise models.', 'MODEL_DISCOVERY_UNAVAILABLE');
+    this.discoveredModels = models.filter(item => id(item.slug || item.id)).slice(0, 1024);
+    return this.discoveredModels.filter(item => item.visibility !== 'hide').map(item => ({ id: item.slug || item.id,
+      ...(typeof item.display_name === 'string' ? { display_name: item.display_name.slice(0, 256) } : {}),
+      ...(Number.isSafeInteger(item.context_window) && item.context_window > 0 ? { context_window: item.context_window } : {}),
+      ...(Array.isArray(item.input_modalities) ? { input_modalities: item.input_modalities.filter(value => ['text', 'image', 'video', 'audio'].includes(value)) } : {}),
+      ...(Array.isArray(item.supported_reasoning_levels) ? { supported_reasoning_levels: item.supported_reasoning_levels.map(level => typeof level === 'string' ? level : level.effort).filter(level => ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'].includes(level)) } : {}) }));
+  }
+  async discoverModel({ signal } = {}) {
+    if (!this.model) { const models = await this.listModels({ signal }); this.model = models[0]?.id; }
+    if (!this.model) throw fail(`The Codex catalog did not advertise models for compatibility ${CODEX_CATALOG_VERSION}. Check access and adapter version; an empty list does not prove your plan has no models.`, 'MODEL_DISCOVERY_UNAVAILABLE');
+    return this.model;
+  }
+  async discoverModelCapabilities({ signal, force = false } = {}) {
+    await this.discoverModel({ signal });
+    if (force || !this.discoveredModels) await this.listModels({ signal });
+    const metadata = this.discoveredModels.find(item => (item.slug || item.id) === this.model);
+    const modalities = metadata?.input_modalities, announcedEffort = Array.isArray(metadata?.supported_reasoning_levels),
+      rawLevels = (announcedEffort ? metadata.supported_reasoning_levels : []).map(item => typeof item === 'string' ? item : item?.effort),
+      levels = rawLevels.map(value => value === 'none' ? 'off' : value).filter(value => ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'].includes(value));
+    const capabilities = { text: true, tools: true, thinking: announcedEffort ? rawLevels.some(level => typeof level === 'string' && !['none', 'off'].includes(level)) : null,
+      vision: this.vision !== 'auto' ? this.vision === 'on' : Array.isArray(modalities) ? modalities.includes('image') : null, video: false, web_search: false };
+    for (const [name, enabled] of Object.entries(this.capabilitiesConfigured)) if (name !== 'vision') capabilities[name] = enabled;
+    const effectiveLevels = this.capabilitiesConfigured.thinking === false ? [] : levels;
+    this.modelCapabilities = { model: this.model, capabilities, provenance: Object.fromEntries(Object.keys(capabilities).map(key => [key, { source: ['video', 'web_search', 'tools', 'text'].includes(key) ? 'codex_adapter' : 'codex_models', kind: 'detected' }])),
+      effort: { supported: this.capabilitiesConfigured.thinking === false ? false : announcedEffort ? !!levels.length : null, levels: ['auto', ...new Set(effectiveLevels)], selected: this.effort, source: this.capabilitiesConfigured.thinking === false ? 'explicit_profile_configuration' : announcedEffort ? 'codex_models' : 'unknown' },
+      ...(Number.isSafeInteger(metadata?.context_window) && metadata.context_window > 0 ? { contextWindow: metadata.context_window, contextWindowProvenance: { source: 'codex_models', field: 'context_window', scope: 'context', kind: 'detected' } } : {}), source: ['codex_models'] };
+    for (const name of Object.keys(this.capabilitiesConfigured)) this.modelCapabilities.provenance[name] = { source: 'explicit_profile_configuration', kind: 'configured' };
+    if (this.vision !== 'auto') this.modelCapabilities.provenance.vision = { source: 'explicit_user_configuration', kind: 'configured' };
+    return structuredClone(this.modelCapabilities);
+  }
+  async getVisionCapability({ signal } = {}) { const state = await this.discoverModelCapabilities({ signal }); return { supported: state.capabilities.vision === true, source: this.vision !== 'auto' ? 'explicit_user_configuration' : 'codex_models', model: this.model, imageTokens: this.imageTokens }; }
+  getCapabilities() { return this.modelCapabilities?.model === this.model ? { ...this.modelCapabilities.capabilities, vision: this.modelCapabilities.capabilities.vision === true } : { text: true, tools: true, ...this.capabilitiesConfigured, vision: this.vision === 'on', video: false, web_search: false }; }
+  analyzeMedia(request) { return analyzeImages(this, request); }
+  async complete({ system, messages, tools = [], schemaCatalog = [], contextIdentity, signal, onText = () => {}, onProgress = () => {}, purpose = 'worker', maxTokens = this.maxTokens }) {
+    if (this.capabilitiesConfigured.tools === false && tools.length) throw fail('The Codex profile does not enable tools; the request was not sent.', 'PROVIDER_CAPABILITY_UNAVAILABLE');
+    await this.discoverModel({ signal });
+    const accountingRequest={system,messages,tools,maxTokens},identity={...accountingIdentity(this),projection_epoch:contextIdentity?.projection_epoch ?? null};
+    const schemaFrame=compileToolSchemas(tools,{provider:this.protocol,capabilities:{...(this.getCapabilities?.() || {}),...(this.toolSchemaCapabilities?{tool_schema:this.toolSchemaCapabilities}:{})},catalogue:schemaCatalog}); tools=schemaFrame.tools;
+    if (messages.some(message => Array.isArray(message.content) && message.content.some(block => block.type === 'image')) && !(await this.getVisionCapability({ signal })).supported) throw fail('The Codex catalog does not advertise vision for this model.', 'PROVIDER_CAPABILITY_UNAVAILABLE');
+    let reasoning;
+    if (this.effort !== 'auto') {
+      const state = await this.discoverModelCapabilities({ signal });
+      if (!state.effort.levels.includes(this.effort)) throw fail(`The model does not advertise effort ${this.effort}.`, 'MODEL_EFFORT_UNAVAILABLE');
+      reasoning = { effort: this.effort === 'off' ? 'none' : this.effort };
+    }
+    // Follow the upstream Codex request shape, which omits max_output_tokens.
+    // maxTokens remains a host accounting estimate, not a wire-enforced cap.
+    const body = JSON.stringify({ model: this.model, instructions: system || 'You are Comal, a coding assistant.', input: toCodexInput(messages), stream: true, store: false,
+      include: ['reasoning.encrypted_content'], ...(reasoning ? { reasoning } : {}),
+      ...(tools.length ? { tools: tools.map(tool => ({ type: 'function', name: tool.name, description: tool.description, parameters: tool.input_schema })), tool_choice: 'auto', parallel_tool_calls: true } : {}) });
+    const account=result=>{result.usage_accounting=bindUsageAccounting(result.usage_accounting,accountingRequest,identity,body); result.schema_diagnostics=schemaFrame.diagnostics;result.schema_manifest=schemaFrame.manifest;return result;};
+    if (Buffer.byteLength(body) > 8 * 1024 * 1024) throw fail('The Codex context exceeds 8 MiB.');
+    const deadline = modelDeadline({ signal, timeoutMs: this.timeoutMs, idleTimeoutMs: this.idleTimeoutMs, purpose });
+    try {
+      const response = await this._fetch('responses', { method: 'POST', body, signal: deadline.signal });
+      const framed=await responseFormat(response.body);
+      if (framed.format === 'json') {
+        const result = normalized(await responseJSON(framed.body)); for (const block of result.content) if (block.type === 'text') onText(block.text); return account(result);
+      }
+      let result, textChars = 0, reasoningChars = 0, argumentChars = 0;
+      for await (const event of sseEvents(framed.body)) {
+        if (event.type === 'response.output_text.delta') { onText(event.delta || ''); textChars += (event.delta || '').length; deadline.touch(); }
+        else if (event.type === 'response.reasoning_summary_text.delta') { reasoningChars += (event.delta || '').length; deadline.touch(); }
+        else if (event.type === 'response.function_call_arguments.delta') { argumentChars += (event.delta || '').length; deadline.touch(); }
+        else if (event.type === 'response.completed') result = normalized(event.response);
+        else if (['response.failed', 'response.incomplete', 'error'].includes(event.type)) throw responseFailure(event);
+        onProgress({ text_chars: textChars, reasoning_chars: reasoningChars, tool_argument_chars: argumentChars, elapsed_ms: deadline.elapsedMs(), purpose });
+      }
+      deadline.signal.throwIfAborted();
+      if (!result) throw fail('Codex streaming was interrupted; no tools were executed.', 'CODEX_RESPONSE_INCOMPLETE');
+      return account(result);
+    } catch (error) { if(error.usage_accounting)error.usage_accounting=bindUsageAccounting(error.usage_accounting,accountingRequest,identity,body);throw deadline.error(error); } finally { deadline.close(); }
+  }
+}