@arcfold/dsh 0.0.0-stage → 0.4.0

package/src/native-continuation.mjs

@@ -0,0 +1,217 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson } from './store.mjs';
+import { sourceAvailable, hash as sourceHash } from './evidence.mjs';
+
+const digest = value => createHash('sha256').update(canonicalJson(value)).digest('hex');
+const reject = message => { throw Object.assign(new Error(message), { code: 'ARCFOLD_NATIVE_CONTINUATION_INVALID' }); };
+const same = (a, b) => canonicalJson(a) === canonicalJson(b);
+const positive = value => Number.isSafeInteger(value) && value > 0;
+const text = message => (message?.content || []).filter(block => block.type === 'text').map(block => block.text).join('');
+const goalMessages = messages => messages.filter(message => message.source?.kind === 'goal' && message.source.round > 0);
+
+function ref(store, sessionId, event) {
+  const rows = store.listAll('dsh_events', { where: { sessionId, seq: event.seq } });
+  if (rows.length !== 1 || rows[0].sha256 !== digest(event) || rows[0].type !== event.type)
+    reject('Delegation needs its exact durable native event index');
+  return { id: rows[0].id, sessionId, seq: event.seq, type: event.type, sha256: digest(event) };
+}
+function commandOrigin(events, change) {
+  const matches = [];
+  for (const run of events.filter(event => event.type === 'command/run' && event.seq < change.seq &&
+      event.data.name === 'goal' && event.data.source?.kind === 'user')) {
+    const dones = events.filter(event => event.type === 'command/done' && event.data.commandId === run.data.commandId);
+    if (dones.length !== 1 || dones[0].seq < change.seq || dones[0].data.kind !== 'success') continue;
+    const changes = events.filter(event => event.type === 'goal/change' && event.seq > run.seq && event.seq < dones[0].seq);
+    if (changes.length === 1 && changes[0] === change) matches.push({ kind: 'native-command', actor: 'user',
+      command: run.data, events: [run, change, dones[0]], inputEvents: [] });
+  }
+  return matches;
+}
+function toolOrigin(events, change, actions = ['create', 'edit']) {
+  const matches = [];
+  for (const call of events.filter(event => event.type === 'tool/call' && event.seq < change.seq &&
+      ['create_goal', 'update_goal', 'arcfold_start_work', 'arcfold_revise_work', 'arcfold_decide_work'].includes(event.data.name))) {
+    let args;
+    try { args = JSON.parse(call.data.arguments); } catch { continue; }
+    const action = ['create_goal', 'arcfold_start_work'].includes(call.data.name) ? 'create'
+      : call.data.name === 'arcfold_revise_work' ? 'edit'
+      : call.data.name === 'arcfold_decide_work' && args.action === 'wait' ? 'pause'
+      : args.action === 'blocked' ? 'block' : args.action;
+    if (!actions.includes(action) || action !== change.data.operation) continue;
+    if (action === 'create' && args.objective?.trim() !== change.data.goal.objective) continue;
+    if (action !== 'create' && (args.goal_id !== change.data.goal.id || args.revision + 1 !== change.data.goal.revision)) continue;
+    if (action === 'edit' && args.objective !== undefined && args.objective.trim() !== change.data.goal.objective) continue;
+    const results = events.filter(event => event.type === 'tool/result' && event.data.message?.toolCallId === call.data.callId);
+    if (results.length !== 1 || results[0].seq <= change.seq || results[0].data.message.isError ||
+        results[0].data.error || !same(results[0].sourceEventSeqs, [call.seq])) continue;
+    let result;
+    try { result = JSON.parse(text(results[0].data.message)); } catch { continue; }
+    if (!result?.goal || !Object.entries(change.data.goal).every(([key, value]) => same(result.goal[key], value))) continue;
+    const assistants = events.filter(event => event.type === 'assistant/message' && event.seq < call.seq &&
+      event.data.turn === call.data.turn && event.data.step === call.data.step &&
+      event.data.message?.role === 'assistant' && event.data.message.source?.kind === 'model' &&
+      event.data.message.content.some(block => block.type === 'tool-call' && block.id === call.data.callId &&
+        block.name === call.data.name && block.arguments === call.data.arguments));
+    if (assistants.length !== 1) continue;
+    const competing = events.filter(event => event.type === 'goal/change' && event.seq > call.seq && event.seq < results[0].seq);
+    if (competing.length !== 1 || competing[0] !== change) continue;
+    const start = events.findLast(event => event.seq < call.seq && event.type === 'turn/start');
+    if (!start || start.data.turn !== call.data.turn) continue;
+    const inputEvents = events.filter(event => event.seq > start.seq && event.seq < call.seq && event.type === 'user/message' &&
+      event.data.role === 'user' && event.data.source?.kind === 'user' && event.data.source.principal === undefined);
+    if (['create', 'edit'].includes(action) && !inputEvents.length) continue;
+    matches.push({ kind: 'native-goal-tool', actor: 'model', callId: call.data.callId, arguments: args,
+      events: [start, ...inputEvents, assistants[0], call, change, results[0]], inputEvents });
+  }
+  return matches;
+}
+function originalSources(store, sessionId, inputEvents) {
+  return inputEvents.map(event => {
+    const sources = store.listAll('events', { where: { sessionId } })
+      .filter(source => source.message?.id === event.data.id && same(source.message, event.data));
+    if (sources.length !== 1 || !sourceAvailable(store, sources[0])) reject('Original delegation input is missing or unavailable');
+    const source = sources[0];
+    return { id: source.id, revision: source.revision, messageHash: digest(source.message),
+      occurredAt: source.occurredAt, role: source.role };
+  });
+}
+
+/** Exact original creation, reusable for business-only work indexing after native flush. */
+export function nativeGoalOrigin({ store, sessionId, events, goalId }) {
+  const creates = events.filter(e => e.type === 'goal/change' && e.data.operation === 'create' && e.data.goal?.id === goalId);
+  if (creates.length !== 1) return null;
+  const origins = [...commandOrigin(events, creates[0]), ...toolOrigin(events, creates[0], ['create'])];
+  if (origins.length !== 1) return null;
+  const origin = origins[0];
+  return { ...origin, inputs: originalSources(store, sessionId, origin.inputEvents) };
+}
+
+/** Freeze provenance, never activation or a second execution state. */
+export function freezeNativeContinuation({ store, sessionId, turn, messages, events, goal, stage = null }) {
+  const submitted = goalMessages(messages);
+  if (!submitted.length) return null;
+  if (submitted.length !== 1) reject('A native round has more than one goal message');
+  const message = submitted[0], source = message.source;
+  if (!positive(source.revision) || !positive(source.round) || message.role !== 'user' ||
+      !goal || goal.id !== source.goalId || goal.revision !== source.revision ||
+      goal.phase !== 'active' || goal.activation !== 'armed' || source.round !== goal.roundsStarted + 1)
+    reject('The native round does not own the current active and armed goal');
+  const start = events.findLast(event => event.type === 'turn/start');
+  if (!start || start.data.turn !== turn || events.some(event => event.seq > start.seq && event.type === 'turn/end'))
+    reject('A native continuation needs the current open turn');
+  const insertions = events.flatMap(event => event.type === 'agent/inbox/spliced'
+    ? (event.data.inserted || []).flatMap((input, index) => input.id === message.id ? [{ event, input, index }] : []) : []);
+  if (insertions.length !== 1 || !same(insertions[0].input, message)) reject('Native goal message has no unique durable original');
+  const chain = events.filter(event => event.type === 'goal/change' && event.data.goal?.id === source.goalId);
+  if (!chain.length || chain[0].data.operation !== 'create' || chain[0].data.goal.revision !== 1 ||
+      chain.at(-1).data.goal.revision !== source.revision ||
+      chain.some((event, index) => event.data.goal.revision !== index + 1))
+    reject('The delegated goal definition chain is missing, stale or discontinuous');
+  const origins = [...commandOrigin(events, chain[0]), ...toolOrigin(events, chain[0], ['create'])];
+  if (origins.length !== 1) reject('The goal has no unique original command or successful create_goal delegation');
+  const origin = origins[0];
+  let activeOrigin = origin;
+  if (stage) {
+    const candidates = chain.flatMap(change => toolOrigin(events, change)).filter(candidate => candidate.callId === stage.origin.callId);
+    if (candidates.length !== 1 || stage.sessionId !== sessionId || stage.nativeGoalId !== goal.id || stage.nativeRevision !== goal.revision)
+      reject('The current Arcfold stage has no exact successful native definition receipt');
+    activeOrigin = candidates[0];
+  }
+  const activeInputs = stage ? activeOrigin.inputEvents.filter(event => stage.sourceRefs.some(reference =>
+    store.get('events', reference.id)?.message?.id === event.data.id)) : activeOrigin.inputEvents;
+  if (stage && !activeInputs.length) reject('The current stage has no owner source in its successful definition call');
+  const inputs = originalSources(store, sessionId, activeInputs);
+  if (stage) for (const reference of stage.sourceRefs) {
+    const row = store.get('events', reference.id);
+    if (!sourceAvailable(store, row) || row.revision !== reference.revision || sourceHash(row.message) !== reference.messageHash)
+      reject('The current Arcfold stage source changed');
+    if (!inputs.some(input => input.id === reference.id)) inputs.push({ id: row.id, revision: row.revision,
+      messageHash: digest(row.message), occurredAt: row.occurredAt, role: row.role });
+  }
+  const initialIds = store.listAll('events', { where: { sessionId } }).filter(row =>
+    origin.inputEvents.some(event => row.message?.id === event.data.id && same(row.message, event.data))).map(row => row.id);
+  const nativeEvents = [...new Map([...origin.events, ...activeOrigin.events, ...chain, insertions[0].event, start].map(event => [event.seq, event])).values()]
+    .sort((a, b) => a.seq - b.seq).map(event => ref(store, sessionId, event));
+  const proof = { kind: 'native-goal-continuation', sessionId, turn,
+    goalId: source.goalId, revision: source.revision, round: source.round,
+    messageId: message.id, messageHash: digest(message), inboxRef: { seq: insertions[0].event.seq, index: insertions[0].index },
+    cutoff: { throughSeq: events.at(-1).seq },
+    initialDelegation: { kind: origin.kind, actor: origin.actor,
+      ...(origin.command ? { command: origin.command } : { callId: origin.callId }),
+      sourceIds: initialIds },
+    ...(stage ? { activeDelegation: { kind: 'arcfold-stage', stageId: stage.id, definitionVersion: stage.definitionVersion,
+      sourceIds: inputs.map(row => row.id), eventIds: activeOrigin.events.map(event => ref(store, sessionId, event).id) } } : {}),
+    // UI controls do not emit a command/user message. Keep native facts and say
+    // the actor was not recorded; never manufacture a fresh user authorization.
+    definitionChain: chain.map(event => ({ seq: event.seq, goalId: event.data.goal.id,
+      revision: event.data.goal.revision, operation: event.data.operation,
+      attribution: event === chain[0] ? origin.kind : 'native_control', actor: event === chain[0] ? origin.actor : 'unrecorded' })),
+    currentDefinition: { ...chain.at(-1).data.goal },
+    originalInputs: inputs, nativeEvents,
+    authority: 'historical-delegation-and-native-control-facts; not-current-user-input-or-long-term-goal-control' };
+  return { ...proof, proofHash: digest(proof) };
+}
+
+/** Historical facts stay intact even after future use of their sources is withdrawn. */
+export function assertNativeContinuationIntegrity(store, proof) {
+  const { proofHash, ...body } = proof;
+  if (proof.kind !== 'native-goal-continuation' || digest(body) !== proofHash) reject('Native continuation proof changed');
+  for (const reference of proof.nativeEvents) {
+    const row = store.get('dsh_events', reference.id);
+    if (!row || row.sessionId !== proof.sessionId || row.seq !== reference.seq || row.type !== reference.type ||
+        row.sha256 !== reference.sha256) reject('Native delegation original changed');
+  }
+  for (const input of proof.originalInputs) {
+    const source = store.get('events', input.id);
+    if (!source || source.sessionId !== proof.sessionId || source.revision !== input.revision ||
+        digest(source.message) !== input.messageHash)
+      reject('Original delegation input changed');
+  }
+  return proof;
+}
+
+/** Current reuse (including Learn) still requires all original sources to be available. */
+export function assertNativeContinuationStored(store, proof) {
+  assertNativeContinuationIntegrity(store, proof);
+  for (const reference of proof.nativeEvents) {
+    if (proof.activeDelegation && !proof.activeDelegation.eventIds.includes(reference.id)) continue;
+    const control = store.get('source_controls', reference.id);
+    if (control?.withdrawn || control?.useProhibited) reject('Native delegation original was withdrawn');
+  }
+  for (const input of proof.originalInputs)
+    if (!sourceAvailable(store, store.get('events', input.id))) reject('Original delegation input was withdrawn');
+  return proof;
+}
+
+/** A synchronous final-send check; the official driver still owns scheduling. */
+export function assertNativeContinuationCurrent({ store, proof, events, agent, goal, messages, historical = false }) {
+  if (historical) assertNativeContinuationIntegrity(store, proof);
+  else assertNativeContinuationStored(store, proof);
+  if (!agent || agent.id !== proof.sessionId || agent.status !== 'running') reject('Native continuation Agent is not current');
+  for (const reference of proof.nativeEvents) {
+    const event = events.find(row => row.seq === reference.seq);
+    if (!event || digest(event) !== reference.sha256) reject('Native delegation prefix changed');
+  }
+  const start = events.findLast(event => event.type === 'turn/start');
+  if (!start || start.data.turn !== proof.turn || events.some(event => event.seq > start.seq && event.type === 'turn/end'))
+    reject('Native continuation turn is no longer open');
+  const entered = events.filter(event => event.seq > start.seq && event.type === 'user/message' && event.data.id === proof.messageId);
+  const sent = messages.filter(message => message.id === proof.messageId);
+  if (entered.length !== 1 || sent.length !== 1 || digest(entered[0].data) !== proof.messageHash ||
+      digest(sent[0]) !== proof.messageHash) reject('Native goal message was not admitted unchanged');
+  // A new owner input or its successful Arcfold transition supersedes the old
+  // automatic admission. GoalExecution checks the new stage before every send/tool.
+  if (historical) return;
+  if (goal?.id === proof.goalId && goal.revision === proof.revision && goal.phase === 'active' &&
+      goal.activation === 'armed' && goal.roundsStarted === proof.round) return;
+  // Completing/blocking inside this same round may need a final answer step.
+  // It does not authorize any next automatic round or a definition edit.
+  const latest = events.findLast(event => event.type === 'goal/change');
+  const terminals = latest?.seq > start.seq && latest.data.goal?.id === proof.goalId &&
+    latest.data.goal.revision === proof.revision + 1 && ['complete', 'block', 'pause'].includes(latest.data.operation)
+    ? toolOrigin(events, latest, ['complete', 'block', 'pause']).filter(origin => latest.data.operation !== 'pause' ||
+      events.some(event => event.type === 'tool/call' && event.data.callId === origin.callId && event.data.name === 'arcfold_decide_work')) : [];
+  if (terminals.length === 1 && goal?.id === proof.goalId && same(goal.phase, latest.data.goal.phase) &&
+      goal.revision === latest.data.goal.revision && goal.roundsStarted === proof.round) return;
+  reject('Native goal authority changed before dispatch');
+}

package/src/native-request-authority.mjs

@@ -0,0 +1,90 @@
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
+import { canonicalJson } from './store.mjs';
+import { LearningService } from './learning.mjs';
+
+const digest = value => createHash('sha256').update(canonicalJson(value)).digest('hex');
+const treeAuthorities = new WeakMap();
+
+// Only trusted composition registers this per-business capability. Model input
+// cannot opt into it, and unrelated auxiliary sessions keep the v1 rejection.
+export function registerTreeRequestAuthority(business, authority) {
+  if (!business || typeof authority?.owns !== 'function' || typeof authority?.identity !== 'function' || typeof authority?.assertRequest !== 'function' || treeAuthorities.has(business)) throw new Error('One explicit tree request authority per business instance is required');
+  treeAuthorities.set(business, authority);
+  return () => { if (treeAuthorities.get(business) === authority) treeAuthorities.delete(business); };
+}
+
+export { ownEvidenceDirectory } from './evidence-ownership.mjs';
+
+/** The ledger persists this identity before send; it is not another job state. */
+export function nativeRequestIdentity(business, sessions, options) {
+  if (options.purpose !== undefined || typeof options.sessionId !== 'string')
+    throw new Error('Only an owned native Arcfold main or learning step may use this provider');
+  const session = sessions.get(options.sessionId);
+  if (!session) throw new Error('The request has no live native session owner');
+  const main = business.get('host_bindings', session.id)?.role === 'main';
+  const helpers = business.listAll('learning_runs', { where: { sessionId: session.id } });
+  const preparations = business.listAll('preparation_runs', { where: { sessionId: session.id } });
+  const tree = treeAuthorities.get(business);
+  if (tree?.owns(session.id)) {
+    if (main || helpers.length || preparations.length) throw new Error('Native request has both legacy and tree owners');
+    return tree.identity(options, session);
+  }
+  if (Number(main) + helpers.length + preparations.length !== 1) throw new Error('The request has no unique Arcfold business owner');
+  const helper = helpers[0], preparation = preparations[0];
+  if (preparation && preparation.state !== 'submitted') throw new Error('Preparation is not submitted');
+  if (helper && (helper.state !== 'submitted' || helper.dispatchCount !== 1))
+    throw new Error('The learning request has not passed its single-call guard');
+  const events = session.snapshotEvents();
+  const start = events.findLast(event => event.type === 'step/start');
+  if (!start || !Number.isSafeInteger(start.data.turn) || !Number.isSafeInteger(start.data.step))
+    throw new Error('The request has no native step identity');
+  const turn = events.findLast(event => event.type === 'turn/start');
+  if (!turn || turn.data.turn !== start.data.turn || turn.seq >= start.seq)
+    throw new Error('The native step does not belong to the current turn');
+  if (events.slice(start.seq + 1).some(event => ['turn/end', 'step/end', 'assistant/message', 'assistant/attempt'].includes(event.type)))
+    throw new Error('The native step already has a result or attempted result; automatic resending is forbidden');
+  if (preparation && !preparation.requests?.some(value => value.stepStartSeq === start.seq))
+    throw new Error('Preparation request has not passed its bounded native step guard');
+  const header = session.requestHeader()?.config;
+  if (!header || header.provider !== options.provider || header.model !== options.model ||
+      header.maxTokens !== options.maxTokens || header.reasoningEffort !== options.reasoningEffort)
+    throw new Error('The native request configuration and actual provider call disagree');
+  const position = { sessionId: session.id, turn: start.data.turn, step: start.data.step, stepStartSeq: start.seq };
+  return { requestId: `dsh-messages-${digest(position)}`, metadata: {
+    owner: 'arcfold-dsh-messages-v1', ...position, role: main ? 'main' : helper ? 'learning' : 'preparation',
+    nativeThroughSeq: events.at(-1).seq, nativePrefixHash: digest(events),
+    ...(helper ? { learningPendingId: helper.id, learningInputHash: helper.inputHash } : {}),
+    ...(preparation ? { preparationRunId: preparation.id, preparationInputHash: preparation.inputHash } : {}),
+  } };
+}
+
+export function assertNativeRequestCurrent(ctx, options) {
+        const tree = treeAuthorities.get(ctx.arcfoldBusiness);
+        if (tree?.owns(options.sessionId)) return tree.assertRequest(options);
+        if (ctx.arcfoldBridge.isBound(options.sessionId)) {
+          const checked = ctx.arcfoldBridge.assertMethodRequestCurrent(options);
+          // Return a mistaken async check to the transport so it fails closed;
+          // never discard it and accidentally turn a Promise into permission.
+          if (checked && typeof checked.then === 'function') return checked;
+          const goalChecked = ctx.arcfoldBridge.assertGoalRequestCurrent(options);
+          if (goalChecked && typeof goalChecked.then === 'function') return goalChecked;
+          return ctx.arcfoldBridge.assertRequestCurrent(options);
+        }
+        const preparations = ctx.arcfoldBusiness.listAll('preparation_runs', { where: { sessionId: options.sessionId } });
+        if (preparations.length) {
+          const runner = ctx.get('arcfoldPreparation');
+          if (preparations.length !== 1 || !runner) throw new Error('Preparation owner is unavailable');
+          return runner.assertRequest(options);
+        }
+        // A helper has already passed its single-call guard. Recheck only its
+        // existing frozen business input; never prepare, count or schedule again.
+        const runs = ctx.arcfoldBusiness.listAll('learning_runs', { where: { sessionId: options.sessionId } });
+        const run = runs[0], input = run && ctx.arcfoldBusiness.get('learning_inputs', run.id);
+        if (runs.length !== 1 || !input || run.inputHash !== input.inputHash)
+          throw new Error('The learning request has no matching frozen input before dispatch');
+        const learning = new LearningService({ business: ctx.arcfoldBusiness });
+        const checked = learning.assertInput(input);
+        if (checked && typeof checked.then === 'function') return checked;
+        return learning.assertVersions(input);
+}

package/src/openai-models.mjs

@@ -0,0 +1,4 @@
+// Exact model IDs implemented by the pinned official Responses translator.
+// Deployment modelPolicies may expose a subset; unknown models never fall back.
+export const OPENAI_MODELS = Object.freeze(['gpt-6-astra', 'gpt-6.1-sol']);
+export const OPENAI_REASONING_EFFORTS = Object.freeze(['low', 'medium', 'high', 'xhigh', 'max']);

package/src/openai-receipt.mjs

@@ -0,0 +1,98 @@
+import { createParser } from 'eventsource-parser';
+import { DomainError, jsonClone } from './store.mjs';
+const invalid = () => new DomainError('invalid_provider_receipt', 'The original Responses receipt is incomplete or inconsistent.', 409);
+const count = value => Number.isSafeInteger(value) && value >= 0;
+
+/** Accounting uses original input_tokens, which already includes cache hits. */
+export function responsesUsage(raw) {
+  if (!raw || !count(raw.input_tokens) || !count(raw.output_tokens) ||
+      !count(raw.input_tokens_details?.cached_tokens) ||
+      raw.input_tokens_details.cached_tokens > raw.input_tokens ||
+      raw.total_tokens !== undefined && (!count(raw.total_tokens) || raw.total_tokens !== raw.input_tokens + raw.output_tokens) ||
+      raw.output_tokens_details?.reasoning_tokens !== undefined &&
+        (!count(raw.output_tokens_details.reasoning_tokens) || raw.output_tokens_details.reasoning_tokens > raw.output_tokens))
+    throw invalid();
+  return { promptTokens: raw.input_tokens, completionTokens: raw.output_tokens,
+    cachedTokens: raw.input_tokens_details.cached_tokens };
+}
+
+/** Billing only: the pinned official SDK continues to translate content/history. */
+export class ResponsesReceipt {
+  constructor() {
+    this.decoder = new TextDecoder('utf-8', { fatal: true });
+    this.started = false; this.stopped = false; this.finalUsage = null;
+    this.messageId = null; this.model = null; this.stopReason = null;
+    this.lineParts = []; this.skipLf = false;
+    this.parser = createParser({ onError: () => { throw invalid(); }, onEvent: event => this.event(event) });
+  }
+  event(event) {
+    let value;
+    try { value = JSON.parse(event.data); } catch { throw invalid(); }
+    if (!value || typeof value.type !== 'string' || event.event && event.event !== value.type || this.stopped)
+      throw invalid();
+    if (value.type === 'response.created') {
+      if (this.started || typeof value.response?.id !== 'string' || !value.response.id ||
+          typeof value.response?.model !== 'string' || !value.response.model) throw invalid();
+      this.started = true; this.messageId = value.response.id; this.model = value.response.model;
+      return;
+    }
+    if (!this.started) throw invalid();
+    if (['response.completed', 'response.incomplete'].includes(value.type)) {
+      const response = value.response;
+      if (response?.id !== this.messageId || response.model !== this.model ||
+          response.status !== (value.type === 'response.completed' ? 'completed' : 'incomplete') ||
+          value.type === 'response.incomplete' && response.incomplete_details?.reason !== 'max_output_tokens' ||
+          response.error != null) throw invalid();
+      responsesUsage(response.usage);
+      this.finalUsage = jsonClone(response.usage);
+      this.stopReason = value.type === 'response.completed' ? 'completed' : 'max_output_tokens';
+      this.stopped = true; return;
+    }
+    if (!['response.in_progress', 'response.output_item.added', 'response.output_item.done',
+      'response.content_part.added', 'response.content_part.done', 'response.output_text.delta',
+      'response.output_text.done', 'response.output_text.annotation.added',
+      'response.reasoning_summary_part.added', 'response.reasoning_summary_part.done',
+      'response.reasoning_summary_text.delta', 'response.reasoning_summary_text.done',
+      'response.reasoning_text.delta', 'response.reasoning_text.done',
+      'response.function_call_arguments.delta', 'response.function_call_arguments.done',
+      'response.refusal.delta', 'response.refusal.done'].includes(value.type)) throw invalid();
+    if (value.response && (value.response.id !== this.messageId || value.response.model !== this.model)) throw invalid();
+  }
+  // Feed complete lines to the official SSE framer so its terminal callback
+  // identifies the exact boundary, even when a network chunk has extra bytes.
+  // After that boundary our supported protocol permits whitespace only.
+  feedText(fragment) {
+    if (this.stopped) {
+      if (!/^[ \t\r\n]*$/.test(fragment)) throw invalid();
+      return;
+    }
+    let start = 0;
+    for (let index = 0; index < fragment.length; index++) {
+      const character = fragment[index];
+      if (this.skipLf) {
+        this.skipLf = false;
+        if (character === '\n') { start = index + 1; continue; }
+      }
+      if (character !== '\r' && character !== '\n') continue;
+      this.lineParts.push(fragment.slice(start, index));
+      const line = this.lineParts.join(''); this.lineParts = [];
+      this.parser.feed(line + '\n');
+      start = index + 1; this.skipLf = character === '\r';
+      if (this.stopped) {
+        if (!/^[ \t\r\n]*$/.test(fragment.slice(start))) throw invalid();
+        return;
+      }
+    }
+    if (start < fragment.length) this.lineParts.push(fragment.slice(start));
+  }
+
+  push(bytes) { this.feedText(this.decoder.decode(bytes, { stream: true })); }
+
+
+  finish() {
+    this.feedText(this.decoder.decode());
+    if (!this.started || !this.stopped || !this.finalUsage) throw invalid();
+    return { messageId: this.messageId, model: this.model, stopReason: this.stopReason,
+      rawUsage: this.finalUsage, usage: responsesUsage(this.finalUsage) };
+  }
+}

package/src/openai-transport.mjs

@@ -0,0 +1,167 @@
+import { OPENAI_MODELS, OPENAI_REASONING_EFFORTS as efforts } from './openai-models.mjs';
+import { MeteredTransport, fail, object, positive, text, keys, hash } from './metered-transport.mjs';
+import { ResponsesReceipt } from './openai-receipt.mjs';
+export const OPENAI_EVIDENCE_VERSION = 'arcfold-responses-transport-v1';
+const OFFICIAL = 'https://api.openai.com/v1/responses';
+const imageTypes = ['image/png', 'image/jpeg', 'image/webp', 'image/gif'];
+function nativeImage(block) {
+  // Validate the native durable reference, not a browser-supplied path or URL.
+  // DSH's attachment store remains responsible for verifying the stored bytes.
+  keys(block, ['type', 'attachment', 'offloaded']);
+  keys(block.attachment, ['attachmentId', 'mediaType', 'bytes', 'width', 'height', 'name', 'originalDimensions']);
+  const ref = block.attachment;
+  if (!text(ref.attachmentId) || !/^sha256:[a-f0-9]{64}$/.test(ref.attachmentId) ||
+      !imageTypes.includes(ref.mediaType) || !positive(ref.bytes) || !positive(ref.width) || !positive(ref.height) ||
+      ref.name !== undefined && !text(ref.name) || block.offloaded !== undefined && block.offloaded !== true)
+    throw fail('unsupported_model_content', 'A valid native image attachment reference is required.');
+  if (ref.originalDimensions !== undefined) {
+    keys(ref.originalDimensions, ['width', 'height']);
+    if (!positive(ref.originalDimensions.width) || !positive(ref.originalDimensions.height))
+      throw fail('unsupported_model_content', 'Original image dimensions must be positive integers.');
+  }
+}
+function wireImage(block) {
+  keys(block, ['type', 'image_url', 'detail']);
+  const prefix = text(block.image_url) && /^data:(image\/(?:png|jpeg|webp|gif));base64,/.exec(block.image_url);
+  const data = prefix && block.image_url.slice(prefix[0].length);
+  if (block.detail !== 'auto' || !data || Buffer.from(data, 'base64').toString('base64') !== data)
+    throw fail('unsupported_model_content', 'Only embedded native image bytes with automatic detail are supported.');
+}
+function functions(tools) {
+  if (!Array.isArray(tools)) throw fail('unsupported_model_content', 'Client functions must be an array.');
+  for (const tool of tools) {
+    keys(tool, ['type', 'name', 'description', 'parameters', 'strict', 'defer_loading']);
+    if (tool.type !== 'function' || !text(tool.name) || !object(tool.parameters) ||
+        tool.description !== undefined && !text(tool.description) ||
+        tool.strict !== undefined && typeof tool.strict !== 'boolean' ||
+        tool.defer_loading !== undefined && typeof tool.defer_loading !== 'boolean')
+      throw fail('unsupported_model_content', 'Only client JSON functions are supported.');
+  }
+}
+function content(blocks, types) {
+  if (!Array.isArray(blocks)) throw fail('unsupported_model_content', 'A content array is required.');
+  for (const block of blocks) {
+    if (block?.type === 'input_image' && types.includes('input_image')) { wireImage(block); continue; }
+    keys(block, ['type', 'text', 'annotations']);
+    if (!types.includes(block.type) || !text(block.text) ||
+        block.annotations !== undefined && (!Array.isArray(block.annotations) || block.annotations.length))
+      throw fail('unsupported_model_content', 'Only text content is supported.');
+  }
+}
+function inputItems(items) {
+  if (!Array.isArray(items) || !items.length) throw fail('unsupported_model_content', 'Responses input is required.');
+  for (const item of items) {
+    if (item.type === 'additional_tools') {
+      // The pinned native translator records local tool changes in transcript
+      // order. Accept its exact declaration shape; never re-encode the history.
+      keys(item, ['type', 'role', 'tools']);
+      if (item.role !== 'developer') throw fail('unsupported_model_content', 'Local tool declarations require the developer role.');
+      functions(item.tools);
+    } else if (item.type === 'configuration_update') {
+      keys(item, ['type', 'reasoning']); keys(item.reasoning, ['effort']);
+      if (!efforts.includes(item.reasoning.effort)) throw fail('unsupported_model_content', 'Invalid historical reasoning configuration.');
+    } else if (item.type === 'reasoning') {
+      keys(item, ['type', 'id', 'summary', 'encrypted_content', 'content', 'status']);
+      if (!text(item.id) || item.encrypted_content !== undefined && !text(item.encrypted_content) ||
+          !Array.isArray(item.summary)) throw fail('unsupported_model_content', 'Invalid reasoning history.');
+      content(item.summary, ['summary_text']);
+      if (item.content !== undefined) content(item.content, ['reasoning_text']);
+      if (item.status !== undefined && !['completed','incomplete','in_progress'].includes(item.status))
+        throw fail('unsupported_model_content', 'Invalid reasoning status.');
+    } else if (item.type === 'function_call') {
+      keys(item, ['type', 'id', 'call_id', 'name', 'arguments', 'status', 'namespace']);
+      if (!text(item.call_id) || !text(item.name) || !text(item.arguments) ||
+          item.id !== undefined && !text(item.id) || item.namespace !== undefined && !text(item.namespace))
+        throw fail('unsupported_model_content', 'Invalid client function history.');
+    } else if (item.type === 'function_call_output') {
+      keys(item, ['type', 'call_id', 'output']);
+      if (!text(item.call_id)) throw fail('unsupported_model_content', 'Invalid client result.');
+      if (!text(item.output)) content(item.output, ['input_text', 'input_image']);
+    } else if (item.type === 'tool_search_call' || item.type === 'tool_search_output') {
+      // Pinned pi-ai represents local incremental tool discovery with these
+      // completed client items. Remote/server tool execution is not accepted.
+      const output = item.type === 'tool_search_output';
+      keys(item, ['type', 'call_id', 'execution', 'status', output ? 'tools' : 'arguments']);
+      if (item.execution !== 'client' || item.status !== 'completed' || !text(item.call_id))
+        throw fail('unsupported_model_content', 'Only completed local tool discovery history is supported.');
+      if (output) functions(item.tools);
+      else { keys(item.arguments, ['query', 'limit']);
+        if (!text(item.arguments.query) || !positive(item.arguments.limit)) throw fail('unsupported_model_content', 'Invalid local tool history.'); }
+    } else {
+      keys(item, ['type', 'role', 'content', 'id', 'status', 'phase']);
+      if (item.type !== undefined && item.type !== 'message' ||
+          !['system','developer','user','assistant'].includes(item.role))
+        throw fail('unsupported_model_content', 'Only native messages and local function history are supported.');
+      if (typeof item.content !== 'string') content(item.content,
+        item.role === 'assistant' ? ['output_text'] : item.role === 'user' ? ['input_text', 'input_image'] : ['input_text']);
+    }
+  }
+}
+const protocol = Object.freeze({
+  version: OPENAI_EVIDENCE_VERSION, endpoint: OFFICIAL,
+  validateNativeImage: nativeImage,
+  validateEndpoint(endpoint, allowLocalTestEndpoint) {
+    const target = new URL(endpoint);
+    const local = allowLocalTestEndpoint === true && target.protocol === 'http:' &&
+      target.hostname === '127.0.0.1' && target.port && target.pathname === '/v1/responses';
+    if (endpoint !== OFFICIAL && !local || target.username || target.password || target.search || target.hash)
+      throw fail('invalid_transport_configuration', 'Only the fixed official Responses endpoint is supported.');
+  },
+  validatePolicies(policies) {
+    if (!Object.keys(policies).length || Object.keys(policies).some(model => !OPENAI_MODELS.includes(model)))
+      throw fail('invalid_transport_configuration', 'The supported OpenAI model must be explicit.');
+    for (const p of Object.values(policies)) {
+      if (!object(p) || !positive(p.contextWindow) || !positive(p.maxOutputTokens) ||
+          p.maxOutputTokens < 16 || !Array.isArray(p.reasoningEfforts) || !p.reasoningEfforts.length ||
+          p.reasoningEfforts.some(e => !efforts.includes(e)) ||
+          p.requestMaxTokens !== undefined && (!positive(p.requestMaxTokens) || p.requestMaxTokens < 16 || p.requestMaxTokens > p.maxOutputTokens))
+        throw fail('invalid_transport_configuration', 'Explicit OpenAI token and reasoning bounds are required.');
+    }
+  },
+  createReceipt: () => new ResponsesReceipt(),
+  reservationSpec: fixed => ({ maxOutputTokens: fixed.maxTokens, inputTokenCeiling: fixed.policy.contextWindow }),
+});
+export class OpenAITransport extends MeteredTransport {
+  constructor(options = {}) { super({ ...options, protocol }); }
+  validateInput(options) {
+    super.validateInput(options);
+    if (options.maxTokens < 16) throw fail('unfrozen_model_configuration', 'Responses requires at least 16 output tokens.');
+    return true;
+  }
+  createTransport(options) {
+    const local = super.createTransport(options);
+    return Object.freeze({ fetch: (url, init) => local.send(url, init) });
+  }
+  validateWire(fixed, url, init) {
+    if (url !== this.endpoint || init?.method !== 'POST' ||
+        init.redirect !== undefined && init.redirect !== 'error' || typeof init.body !== 'string')
+      throw fail('invalid_wire_request', 'Only the frozen Responses POST is permitted.');
+    if (Buffer.byteLength(init.body) > this.maxRequestBytes) throw fail('request_too_large', 'Request evidence capacity exceeded.');
+    let body;
+    try { body = JSON.parse(init.body); } catch { throw fail('invalid_wire_request', 'Responses body must be JSON.'); }
+    keys(body, ['model', 'input', 'stream', 'store', 'max_output_tokens', 'reasoning', 'include',
+      'tools', 'prompt_cache_key']);
+    if (body.model !== fixed.model || body.stream !== true || body.store !== false ||
+        body.max_output_tokens !== fixed.maxTokens)
+      throw fail('wire_configuration_changed', 'Serialized route and token bounds changed.');
+    keys(body.reasoning, ['effort','summary']);
+    const last = body.input?.at(-1);
+    if (body.reasoning.effort !== 'medium' || body.reasoning.summary !== 'auto' ||
+        last?.type !== 'configuration_update' || last.reasoning?.effort !== fixed.reasoningEffort ||
+        JSON.stringify(body.include) !== JSON.stringify(['reasoning.encrypted_content']))
+      throw fail('wire_configuration_changed', 'Pinned GPT-6 reasoning configuration changed.');
+    inputItems(body.input);
+    if (body.tools !== undefined) functions(body.tools);
+    // Fixed short retention preserves the pinned official default. Long/explicit
+    // cache modes cannot be introduced by a request or ambient environment.
+    if (body.prompt_cache_key !== undefined && (!text(body.prompt_cache_key) || body.prompt_cache_key.length > 64))
+      throw fail('wire_configuration_changed', 'Unapproved cache configuration.');
+    const headers = new Headers(init.headers);
+    if (headers.has('openai-organization') || headers.has('openai-project'))
+      throw fail('invalid_wire_request', 'An ambient account/project override is not authorized.');
+    if (!headers.get('authorization')) throw fail('missing_provider_auth', 'Provider authentication is required.');
+    if (headers.has('host') && headers.get('host') !== new URL(url).host)
+      throw fail('invalid_wire_request', 'The HTTP host cannot override the fixed endpoint.');
+    return { body, headers: Object.fromEntries(headers), serialized: init.body, bodyHash: hash(init.body) };
+  }
+}