@visual-z/xeno 0.8.4 → 0.9.1

package/src/runtime/output-schema.ts

@@ -1,26 +0,0 @@
-/** Ajv owns JSON Schema semantics; validation never repairs model output (D11/D13). */
-import { Ajv } from "ajv";
-import { Ajv2020 } from "ajv/dist/2020.js";
-import { Ajv2019 } from "ajv/dist/2019.js";
-import { addFormats } from "@modelcontextprotocol/client/validators/ajv";
-
-export type OutputValidation = { ok: true; value: unknown } | { ok: false; error: string };
-export function outputValidator(schema: unknown): (text: string) => OutputValidation {
-  if (typeof schema !== "boolean" && (schema === null || typeof schema !== "object" || Array.isArray(schema))) throw Error("output schema must be a JSON Schema object or boolean");
-  const dialect = typeof schema === "object" && schema !== null && "$schema" in schema ? String(schema.$schema) : "";
-  const options = { allErrors: true, strictSchema: true, strictTypes: false, strictTuples: false, strictRequired: false, validateFormats: true,
-    coerceTypes: false, useDefaults: false, removeAdditional: false, logger: false as const };
-  const ajv = dialect === "https://json-schema.org/draft/2020-12/schema" ? new Ajv2020(options)
-    : dialect === "https://json-schema.org/draft/2019-09/schema" ? new Ajv2019(options)
-    : dialect === "" || dialect === "http://json-schema.org/draft-07/schema#" || dialect === "http://json-schema.org/draft-07/schema" ? new Ajv(options) : undefined;
-  if (!ajv) throw Error("unsupported output schema dialect");
-  // The approved MCP client exposes Ajv's standard formats; share them rather than silently ignoring formats.
-  addFormats(ajv);
-  const validate = ajv.compile(schema);
-  return text => {
-    let value: unknown;
-    try { value = JSON.parse(text); } catch { return { ok: false, error: "final output is not JSON" }; }
-    if (!validate(value)) return { ok: false, error: ajv.errorsText(validate.errors, { separator: "; " }).slice(0, 2048) };
-    return { ok: true, value };
-  };
-}

package/src/runtime/package-manager.ts

@@ -1,125 +0,0 @@
-/** Explicit package operations, isolated from agent sessions and provider credentials. */
-import { mkdir, mkdtemp, readdir, rm, stat } from "node:fs/promises";
-import { join, relative, resolve } from "node:path";
-import { packageConfig, type PackageDeclaration } from "../core/packages.ts";
-import { configDir, readJsonFile } from "../store/config.ts";
-import { serialized } from "../store/serial.ts";
-import { projectTrust } from "../store/trust.ts";
-import { packageSource, packageHome, packageKey, packageRecords, installedPackage, configuredPackages, savePackageDeclaration, savePackageRecord, removePackageRecords, packageManifest, type PackageRecord } from "../store/packages.ts";
-
-export type PackageOperation = "install" | "remove" | "update" | "list";
-export interface PackageCommand { operation: PackageOperation; sources: string[]; local?: boolean }
-export type PackageExecutor = (argv: string[], options: { cwd: string; signal?: AbortSignal }) => Promise<{ code: number; stdout: string; stderr: string }>;
-export interface PackageOptions { workspace: string; userDir?: string; run?: PackageExecutor; signal?: AbortSignal; say?: (text: string) => void; trusted?: boolean }
-export interface ListedPackage { source: string; identity: string; scope: "user" | "project"; path?: string; pinned: boolean; filtered: boolean }
-
-export const executePackageCommand: PackageExecutor = async (argv, options) => {
-  if (options.signal?.aborted) throw Error("Package operation cancelled");
-  const child=Bun.spawn(argv,{cwd:options.cwd,stdin:"ignore",stdout:"pipe",stderr:"pipe"});
-  const abort=()=>{child.kill();}; options.signal?.addEventListener("abort",abort,{once:true});
-  try {
-    const [stdout,stderr,code]=await Promise.all([new Response(child.stdout).text(),new Response(child.stderr).text(),child.exited]);
-    if(options.signal?.aborted)throw Error("Package operation cancelled"); return {stdout,stderr,code};
-  } finally { options.signal?.removeEventListener("abort",abort); }
-};
-
-export class PackageManager {
-  readonly options: PackageOptions;
-  constructor(options: PackageOptions) { this.options={...options,workspace:resolve(options.workspace)}; }
-  private base(local=false):string { return local?join(this.options.workspace,".xeno"):this.options.userDir??configDir(); }
-  private async command(argv:string[],cwd:string):Promise<string> {
-    const result=await (this.options.run??executePackageCommand)(argv,{cwd,...(this.options.signal?{signal:this.options.signal}:{})});
-    if(result.code!==0)throw Error(`${argv[0]} exited ${result.code}: ${result.stderr.trim()||result.stdout.trim()}`);
-    return result.stdout.trim();
-  }
-  async list():Promise<ListedPackage[]> {
-    const entries:ListedPackage[]=[];
-    for(const scope of ["user","project"] as const){const base=this.base(scope==="project");for(const declaration of await configuredPackages(base)){
-      const config=packageConfig(declaration),source=packageSource(config.source,base),path=await installedPackage(source,base);
-      entries.push({source:config.source,identity:source.id,scope,...(path?{path}:{}),pinned:source.pinned,filtered:typeof declaration!=="string"});
-    }}
-    return entries;
-  }
-  async install(raw:string,options:{local?:boolean;persist?:boolean;base?:string;declaration?:PackageDeclaration}={}):Promise<string> {
-    if(this.options.signal?.aborted)throw Error("Package operation cancelled");
-    const base=options.base??this.base(options.local),source=packageSource(raw,this.options.workspace);
-    return serialized(join(packageHome(base),"operation"),async()=>{
-      // Parse existing metadata before any network/installation side effect.
-      await configuredPackages(base); const records=await packageRecords(base),previous=records[packageKey(source)];
-      const declaration=options.declaration??(source.kind==="local"?relative(base,source.path)||".":source.source);
-      if(source.kind==="local") {
-        if(!await stat(source.path).then(()=>true,()=>false))throw Error(`Package path does not exist: ${source.path}`);
-        await packageManifest(source.path);
-        if(options.persist!==false)await savePackageDeclaration(base,source,declaration);
-        return source.path;
-      }
-      const versions=join(packageHome(base),"versions"); await mkdir(versions,{recursive:true});
-      const staging=await mkdtemp(join(versions,packageKey(source)+"-")); let published=false;
-      try {
-        let root:string,revision:string|undefined;
-        if(source.kind==="npm") {
-          await Bun.write(join(staging,"package.json"),JSON.stringify({name:"xeno-package-install",private:true}));
-          await this.command([process.execPath,"add","--exact","--production","--omit","peer",source.spec],staging);
-          root=join(staging,"node_modules",source.name);
-        } else {
-          root=join(staging,"repo"); await this.command(["git","clone","--",source.repo,root],staging);
-          if(source.ref)await this.command(["git","checkout","--detach",source.ref],root);
-          revision=await this.command(["git","rev-parse","HEAD"],root);
-          if(await Bun.file(join(root,"package.json")).exists()) await this.command([process.execPath,"install","--production","--omit","peer"],root);
-        }
-        if(!await stat(root).then(s=>s.isDirectory(),()=>false))throw Error("Package installation produced no package directory");
-        await packageManifest(root);
-        const manifest=await readJsonFile<{version?:string}>(join(root,"package.json"));if(manifest.error)throw Error(manifest.error);
-        const record:PackageRecord={source:source.source,identity:source.id,path:relative(packageHome(base),root),...(manifest.value?.version?{version:manifest.value.version}:{}),...(revision?{revision}:{})};
-        await savePackageRecord(base,source,record);
-        try { if(options.persist!==false)await savePackageDeclaration(base,source,declaration); }
-        catch(error){await savePackageRecord(base,source,previous);throw error;}
-        // Old versions remain available to already-running extension generations.
-        published=true; return root;
-      } finally { if(!published)await rm(staging,{recursive:true,force:true}); }
-    });
-  }
-  async remove(raw:string,local=false):Promise<boolean> {
-    const base=this.base(local),requested=packageSource(raw,this.options.workspace);
-    return serialized(join(packageHome(base),"operation"),async()=>{
-      const declarations=await configuredPackages(base),match=declarations.find(entry=>{const source=packageSource(packageConfig(entry).source,base);return source.id===requested.id||source.source===raw||source.kind==="npm"&&source.name===raw;});
-      if(!match)return false;
-      const source=packageSource(packageConfig(match).source,base);
-      await packageRecords(base);
-      await savePackageDeclaration(base,source,undefined);const keys=await removePackageRecords(base,source.id);
-      if(source.kind!=="local") {
-        const versions=join(packageHome(base),"versions"),names=await readdir(versions).catch(()=>[]);
-        for(const name of names)if(keys.some(key=>name.startsWith(key+"-")))await rm(join(versions,name),{recursive:true,force:true});
-      }
-      return true;
-    });
-  }
-  async update(raw?:string,local?:boolean):Promise<number> {
-    let count=0;
-    const trusted=this.options.trusted??(await projectTrust(this.options.workspace)).trusted;
-    for(const scope of [false,true]) {
-      if(local!==undefined&&scope!==local)continue;
-      if(scope&&local!==true&&!trusted)continue;
-      const base=this.base(scope);
-      for(const declaration of await configuredPackages(base)) {
-        const source=packageSource(packageConfig(declaration).source,base);
-        if(raw&&source.source!==raw&&source.id!==packageSource(raw,this.options.workspace).id&&!(source.kind==="npm"&&source.name===raw))continue;
-        if(source.kind==="local")continue;
-        await this.install(source.source,{base,persist:false,declaration});count++;
-      }
-    }
-    if(raw&&count===0)throw Error(`No installed remote package matches ${raw}`);return count;
-  }
-  async temporary(raw:string):Promise<string> { return this.install(raw,{base:join(this.base(),"temporary"),persist:false}); }
-}
-
-export async function runPackageCommand(command:PackageCommand,options:PackageOptions):Promise<void> {
-  const manager=new PackageManager(options),say=options.say??console.log;
-  if(!await stat(manager.options.workspace).then(s=>s.isDirectory(),()=>false))throw Error(`Workspace does not exist: ${options.workspace}`);
-  if(command.operation==="list"&&command.sources.length||command.operation==="update"&&command.sources.length>1)throw Error(`Unexpected sources for ${command.operation}`);
-  if(command.operation==="list") { for(const entry of await manager.list())say(`${entry.scope} ${entry.source}${entry.pinned?" (pinned)":""} · ${entry.path??"not installed"}`); return; }
-  if(command.operation==="update") { say(`Updated ${await manager.update(command.sources[0],command.local)} package(s)`); return; }
-  if(command.sources.length===0)throw Error(`${command.operation} requires a package source`);
-  for(const source of command.sources) if(command.operation==="install") say(`Installed ${source} · ${await manager.install(source,{...(command.local===undefined?{}:{local:command.local})})}`);
-  else say(await manager.remove(source,command.local)?`Removed ${source}`:`Package not configured: ${source}`);
-}

package/src/runtime/patch-tool.ts

@@ -1,38 +0,0 @@
-/** One durable mutation owner for multi-file Patch, independent of provider syntax. */
-import { changedPaths } from "../core/checkpoints.ts";
-import { NOT_STARTED, READ_ATTEMPTED, UNKNOWN_EFFECT, failureDiagnostic, failureFromError } from "../core/tool-failure.ts";
-import { preparePatch, applyPreparedPatch } from "../store/patch.ts";
-import { presentObservation, type ToolDefinition } from "./tools.ts";
-
-export function createPatchTool(): ToolDefinition {
-  return {
-    name: "apply_patch", access: "write", execution: "exclusive", branch: "write",
-    description: "Apply a Codex-style multi-file patch containing Add File, Update File, optional Move to, and Delete File. Existing sources require a prior session read or explicit expected_sha256. All targets and exact unique hunks are preflighted before changes; add/move destinations must be absent. Uses durable file checkpoints and compensates partial application without overwriting external changes. Preserves original BOM, line endings and modes. Return contains resulting file SHA-256 versions.",
-    input_schema: { type: "object", required: ["patchText"], properties: {
-      patchText: { type: "string", description: "Full *** Begin Patch ... *** End Patch text; update hunks start with @@ and lines use space/+/- prefixes." },
-      expected_sha256: { type: "object", additionalProperties: { type: "string", pattern: "^[a-f0-9]{64}$" }, description: "Optional source path to exact SHA-256 premise; otherwise use observed session versions." },
-    } },
-    run: async (ctx, input) => {
-      if (!ctx.workspace) return { ok: false, content: "Patch requires the session's durable workspace checkpoint owner.", diagnostic: failureDiagnostic("environment_missing", "Patch requires the session's durable workspace checkpoint owner.", NOT_STARTED) };
-      let admitted = false;
-      try {
-        const expected = input["expected_sha256"];
-        if (expected !== undefined && (expected === null || typeof expected !== "object" || Array.isArray(expected))) throw new Error("expected_sha256 must be an object of source digests");
-        const prepared = await preparePatch(ctx.root, ctx.workspace.blobs, String(input["patchText"]), {
-          ...(ctx.observedFileVersion === undefined ? {} : { observedFileVersion: ctx.observedFileVersion }),
-          ...(expected === undefined ? {} : { expectedSha256: expected as Record<string, string> }),
-          ...(ctx.signal === undefined ? {} : { signal: ctx.signal }),
-        });
-        admitted = true;
-        await ctx.workspace.patch(prepared.changes, () => applyPreparedPatch(ctx.root, ctx.workspace!.blobs, prepared, ctx.signal), ctx.signal);
-        const paths = changedPaths(prepared.changes);
-        const summary = paths.map(path => `${path}: ${prepared.changes[path]!.after?.sha256 ?? "deleted"}`).join("\n");
-        const data = paths.map(path => ({ path, before: prepared.changes[path]!.before?.sha256 ?? null, after: prepared.changes[path]!.after?.sha256 ?? null }));
-        return { ...await presentObservation(ctx, `Applied patch to ${paths.length} file path(s).\n${summary}\n\n${prepared.diffs.map(diff => diff.diff).join("\n")}`), ok: true, data: { files: data } };
-      } catch (error) {
-        const diagnostic = failureFromError(error, admitted ? UNKNOWN_EFFECT : READ_ATTEMPTED);
-        return { ok: false, content: diagnostic.message, diagnostic };
-      }
-    },
-  };
-}

package/src/runtime/permission-resources.ts

@@ -1,18 +0,0 @@
-/** R13: an indirect content reader must retain the same read-resource policy. */
-import { explainDecision, type DecisionExplanation, type PermissionAction, type PermissionRule } from "../core/permissions.ts";
-import { permissionPaths } from "../store/permission-paths.ts";
-
-export async function permissionResourceAction(root: string, path: string, configured: readonly PermissionRule[],
-  remembered: readonly PermissionRule[] = [], tool = "read"): Promise<PermissionAction> {
-  return (await permissionResourceDecision(root, path, configured, remembered, tool)).action;
-}
-
-/** The same verdict, with the rule that produced it, for the durable approval record. */
-export async function permissionResourceDecision(root: string, path: string, configured: readonly PermissionRule[],
-  remembered: readonly PermissionRule[] = [], tool = "read"): Promise<DecisionExplanation> {
-  const paths = await permissionPaths(root, [path]);
-  const read = explainDecision(configured, remembered, { tool: "read", paths });
-  const specific = explainDecision(configured, remembered, { tool, paths });
-  const rank = (action: PermissionAction) => action === "deny" ? 2 : action === "ask" ? 1 : 0;
-  return rank(specific.action) > rank(read.action) ? specific : read;
-}

package/src/runtime/pi-provider.ts

@@ -1,423 +0,0 @@
-/** Pi owns wire protocols; xeno owns retries, durable events, projection and credential precedence. */
-import type { AssistantMessage, Context, Message as PiMessage, Model, Tool, ProviderStreams, SimpleStreamOptions } from "@earendil-works/pi-ai";
-import { normalizeContext } from "@earendil-works/pi-ai/utils/transcript";
-import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
-import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
-import { openAIResponsesApi } from "@earendil-works/pi-ai/api/openai-responses.lazy";
-import { azureOpenAIResponsesApi } from "@earendil-works/pi-ai/api/azure-openai-responses.lazy";
-import { openAICodexResponsesApi } from "@earendil-works/pi-ai/api/openai-codex-responses.lazy";
-import { googleGenerativeAIApi } from "@earendil-works/pi-ai/api/google-generative-ai.lazy";
-import { googleVertexApi } from "@earendil-works/pi-ai/api/google-vertex.lazy";
-import { bedrockConverseStreamApi } from "@earendil-works/pi-ai/api/bedrock-converse-stream.lazy";
-import { mistralConversationsApi } from "@earendil-works/pi-ai/api/mistral-conversations.lazy";
-import { piMessagesApi } from "@earendil-works/pi-ai/api/pi-messages.lazy";
-import { assertNever } from "../core/exhaustive.ts";
-import { completedToolInput } from "../core/tool-input.ts";
-import type { AssistantBlock } from "../core/events.ts";
-import { toolCallIdentityViolations, type FrozenPrefix, type Message } from "../core/project.ts";
-import type { Api, ModelSpec } from "./model.ts";
-import { providerRequest } from "./provider-request.ts";
-import { grokVersionHint } from "./oauth.ts";
-import type { ResolveEffects } from "./auth.ts";
-import { imageData } from "./images.ts";
-import { coherentTurn, FailedResponseError, type OnDelta, type Provider, type ProviderConfig, type ToolSchema, type Turn } from "./provider.ts";
-import { DEFAULT_RETRY, retryLabel, withRetry, type RetryPolicy } from "./retry.ts";
-import { ConnectionReuse } from "./connection-reuse.ts";
-import { watchIdle, type IdleWatch } from "./stream-idle.ts";
-
-import { HttpError, StreamError } from "./openai.ts";
-import type { UsageSample } from "./usage.ts";
-import { disablePayloadTools, type ProviderSendOptions } from "./provider-tool-policy.ts";
-
-const APIS: Record<Api, ProviderStreams> = {
-  "anthropic-messages": anthropicMessagesApi(), "openai-completions": openAICompletionsApi(),
-  "openai-responses": openAIResponsesApi(), "azure-openai-responses": azureOpenAIResponsesApi(),
-  "openai-codex-responses": openAICodexResponsesApi(), "google-generative-ai": googleGenerativeAIApi(),
-  "google-vertex": googleVertexApi(), "bedrock-converse-stream": bedrockConverseStreamApi(),
-  "mistral-conversations": mistralConversationsApi(), "pi-messages": piMessagesApi(),
-};
-function record(value: unknown): value is Record<string, unknown> { return value !== null && typeof value === "object" && !Array.isArray(value); }
-const EMPTY_USAGE: AssistantMessage["usage"] = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } };
-
-/** D11: SDK defaults cannot certify a receipt; native input/output counters can, including measured zeros. */
-function nativeUsageReported(api: Api, event: unknown): boolean {
-  if (!record(event)) return false;
-  let usage: unknown;
-  if (api.includes("responses")) {
-    if (event["type"] !== "response.completed" && event["type"] !== "response.incomplete") return false;
-    usage = record(event["response"]) ? event["response"]["usage"] : undefined;
-  } else if (api === "anthropic-messages") {
-    if (event["type"] === "message_start") usage = record(event["message"]) ? event["message"]["usage"] : undefined;
-    else if (event["type"] === "message_delta") usage = event["usage"];
-    else return false;
-  } else if (api === "openai-completions" || api === "mistral-conversations") usage = event["usage"];
-  else return false;
-  if (!record(usage)) return false;
-  const fields = api === "openai-completions" || api === "mistral-conversations" ? ["prompt_tokens", "completion_tokens"] : ["input_tokens", "output_tokens"];
-  return fields.some(field => typeof usage[field] === "number" && Number.isSafeInteger(usage[field]) && usage[field] >= 0);
-}
-
-/** O.3: Pi's streaming repair is presentation, never evidence that final arguments were valid JSON. */
-class OriginalToolArguments {
-  readonly values = new Map<string, string>();
-  private readonly slots = new Map<string, { id: unknown; argumentId: string | null; raw: string; position: number }>();
-  private readonly faults = new Set<string>();
-  private readonly api: Api;
-  constructor(api: Api) { this.api = api; }
-
-  private slotKey(index: unknown, id?: unknown): string | null {
-    if (typeof index === "number" && Number.isSafeInteger(index) && index >= 0) return `index:${index}`;
-    // Mistral accepts a complete call keyed by ID without an index. A fragment
-    // with neither cannot be assigned to a call without inventing its identity.
-    if (this.api === "mistral-conversations" && typeof id === "string" && id.trim() && id !== "null") return `id:${id}`;
-    this.faults.add("native tool call has no stable stream slot");
-    return null;
-  }
-
-  private slot(key: string, id: unknown, argumentId: string | null, supplied: boolean) {
-    const existing = this.slots.get(key);
-    if (existing) {
-      if (supplied && id !== existing.id) this.faults.add(`native call ID changed in stream slot ${existing.position}`);
-      if (argumentId !== null && argumentId !== existing.argumentId) this.faults.add(`native argument identity changed in stream slot ${existing.position}`);
-      return existing;
-    }
-    const slot = { id, argumentId, raw: "", position: this.slots.size };
-    this.slots.set(key, slot);
-    return slot;
-  }
-
-  private publish(slot: { argumentId: string | null; raw: string }): void {
-    if (slot.argumentId !== null) this.values.set(slot.argumentId, slot.raw);
-  }
-
-  observe(value: unknown): void {
-    if (!record(value)) return;
-    if (this.api.includes("responses")) {
-      const item = value["item"];
-      if (record(item) && (item["type"] === "function_call" || item["type"] === "custom_tool_call")) {
-        const key = this.slotKey(value["output_index"]);
-        if (key === null) return;
-        const id = item["call_id"], argumentId = typeof id === "string" ? `${id}|${String(item["id"])}` : null;
-        const slot = this.slot(key, id, argumentId, true);
-        if (item["type"] === "function_call") {
-          if (typeof item["arguments"] === "string") slot.raw = item["arguments"];
-          this.publish(slot);
-        }
-      }
-      const slot = typeof value["output_index"] === "number" ? this.slots.get(`index:${value["output_index"]}`) : undefined;
-      if (slot && value["type"] === "response.function_call_arguments.delta" && typeof value["delta"] === "string") slot.raw += value["delta"];
-      if (slot && value["type"] === "response.function_call_arguments.done" && typeof value["arguments"] === "string") slot.raw = value["arguments"];
-      if (slot && ["response.function_call_arguments.delta", "response.function_call_arguments.done"].includes(String(value["type"]))) this.publish(slot);
-      return;
-    }
-    if (this.api === "anthropic-messages") {
-      const block = value["content_block"];
-      const index = value["index"];
-      if (record(block) && block["type"] === "tool_use") {
-        const key = this.slotKey(index);
-        if (key === null) return;
-        const id = block["id"], slot = this.slot(key, id, typeof id === "string" ? id : null, true);
-        if (slot.argumentId !== null) this.values.set(slot.argumentId, JSON.stringify(block["input"] ?? {}));
-      }
-      const slot = typeof index === "number" ? this.slots.get(`index:${index}`) : undefined, delta = value["delta"];
-      if (slot && record(delta) && delta["type"] === "input_json_delta" && typeof delta["partial_json"] === "string") {
-        slot.raw += delta["partial_json"];
-        this.publish(slot);
-      }
-      return;
-    }
-    // Mistral's native adapter uses the same completions stream vocabulary.
-    if (this.api !== "openai-completions" && this.api !== "mistral-conversations") return;
-    const choice = Array.isArray(value["choices"]) ? value["choices"][0] : undefined;
-    const delta = record(choice) && record(choice["delta"]) ? choice["delta"] : undefined;
-    if (!delta || !Array.isArray(delta["tool_calls"])) return;
-    // One native delta contains one entry per slot. Continuations may reuse a
-    // slot in later chunks, but merging two entries here could execute neither
-    // original declaration's arguments under a silently collapsed identity.
-    const chunkSlots = new Set<string>();
-    for (const call of delta["tool_calls"]) {
-      if (!record(call)) continue;
-      const id = call["id"], key = this.slotKey(call["index"], id);
-      if (key === null) continue;
-      if (chunkSlots.has(key)) { this.faults.add("native stream chunk repeats a tool call slot"); continue; }
-      chunkSlots.add(key);
-      // Native continuation chunks may spell omitted IDs as null. An indexed
-      // slot retains its original identity; a first slot still needs a real ID.
-      const supplied = id !== null && id !== undefined;
-      const slot = this.slot(key, id, typeof id === "string" ? id : null, supplied);
-      if (!record(call["function"])) continue;
-      const fragment = call["function"]["arguments"];
-      if (typeof fragment === "string") slot.raw += fragment;
-      else if (this.api === "mistral-conversations" && fragment !== undefined) slot.raw += JSON.stringify(fragment);
-      this.publish(slot);
-    }
-  }
-
-  identityErrors(): string[] {
-    // D5: SDK block IDs may merge Completions calls or replace missing Mistral
-    // IDs. Only the protocol's original slots can prove one receipt per call.
-    const native = [...this.slots.values()].map(slot => slot.id);
-    const malformed = native.flatMap((id, index) => typeof id === "string" && !(this.api === "mistral-conversations" && id === "null")
-      ? [] : [`native call ID at slot ${index} must be a real string identity`]);
-    const calls: AssistantBlock[] = native.filter((id): id is string => typeof id === "string")
-      .map(call_id => ({ type: "tool_use", call_id, name: "", input: null }));
-    return [...this.faults, ...malformed, ...toolCallIdentityViolations(calls).map(violation => violation.detail)];
-  }
-}
-
-/** Complete usage survives a rejected response without making malformed calls durable conversation history. */
-export class ProviderIntegrityError extends FailedResponseError {
-  readonly code = "invalid_tool_call_identity";
-  constructor(details: readonly string[], usage?: UsageSample) {
-    super(`Invalid provider tool call identity: ${details.join("; ")}`, usage);
-    this.name = "ProviderIntegrityError";
-  }
-}
-
-/** Native envelopes keep their SDK-owned tools/system/signal when adding nested generation options. */
-function mergePayload(payload: Record<string, unknown>, patch: Record<string, unknown>): Record<string, unknown> {
-  const next = { ...payload };
-  for (const [key, value] of Object.entries(patch)) {
-    const current = next[key];
-    next[key] = record(current) && record(value) ? mergePayload(current, value) : value;
-  }
-  return next;
-}
-
-/** Google exposes structured HTTP failures as JSON in its public stream error, without a fetch hook. */
-function nativeStatus(message: string): number | undefined {
-  try {
-    const body: unknown = JSON.parse(message);
-    const code = record(body) && record(body["error"]) ? body["error"]["code"] : undefined;
-    return typeof code === "number" && Number.isInteger(code) && code >= 400 && code <= 599 ? code : undefined;
-  } catch { return undefined; }
-}
-
-function piModel(spec: ModelSpec, baseUrl: string): Model<Api> {
-  return { id: spec.wireId ?? spec.id, provider: spec.provider, name: spec.name, api: spec.api, baseUrl,
-    reasoning: spec.reasoning, input: [...(spec.input ?? ["text"])],
-    // Required SDK metadata defaults are operational only; xeno still reports absent prices as unknown.
-    contextWindow: spec.contextWindow ?? 131_072, maxTokens: spec.maxTokens ?? 16_000,
-    cost: { input: spec.price?.input ?? 0, output: spec.price?.output ?? 0, cacheRead: spec.price?.cacheRead ?? 0, cacheWrite: spec.price?.cacheWrite ?? 0 },
-    ...(spec.thinkingLevelMap ? { thinkingLevelMap: spec.thinkingLevelMap } : {}),
-    ...(spec.nativeCompat || spec.compat || spec.api === "anthropic-messages"
-      ? { compat: { ...spec.compat, ...spec.nativeCompat, ...(spec.api === "anthropic-messages" ? { allowEmptySignature: true } : {}) } } : {}),
-    ...(spec.samplingParams ? { samplingParams: spec.samplingParams } : {}) } as Model<Api>;
-}
-
-type PiBlock = AssistantMessage["content"][number];
-function thinkingOf(raw: unknown): Extract<PiBlock, { type: "thinking" }> | null {
-  if (!record(raw)) return null;
-  if (record(raw["pi"]) && raw["pi"]["type"] === "thinking" && typeof raw["pi"]["thinking"] === "string") {
-    return { ...structuredClone(raw["pi"]), type: "thinking", thinking: raw["pi"]["thinking"] };
-  }
-  if (raw["type"] === "thinking") return { type: "thinking", thinking: typeof raw["thinking"] === "string" ? raw["thinking"] : "", ...(typeof raw["signature"] === "string" ? { thinkingSignature: raw["signature"] } : {}) };
-  if (raw["type"] === "redacted_thinking" && typeof raw["data"] === "string") return { type: "thinking", thinking: "", redacted: true, thinkingSignature: raw["data"] };
-  if (record(raw["responses_item"])) return { type: "thinking", thinking: "", thinkingSignature: JSON.stringify(raw["responses_item"]) };
-  if (typeof raw["reasoning_content"] === "string") return { type: "thinking", thinking: raw["reasoning_content"], ...(raw["reasoning_details"] !== undefined ? { thinkingSignature: JSON.stringify(raw["reasoning_details"]) } : {}) };
-  return null;
-}
-
-/**
- * Reasoning never enters the visible channel. Pi turns thinking it cannot replay natively into a
- * text part, and a model shown its own reasoning as earlier visible output starts writing its
- * reasoning as visible output (an unsigned Gemini block via an Anthropic gateway snowballed into
- * monologue in every later reply). An unsigned block here was sent that way by the server --
- * interrupted streams throw and are never logged -- so anthropic-messages replays it verbatim
- * (`allowEmptySignature` in piModel, as the native adapter does). Bedrock has no unsigned
- * reasoning form, so there the block is dropped. Cross-model text conversion cannot occur: a
- * model switch cuts the node (Session.switchModel) and every replayed message names this model.
- */
-function replaysAsReasoning(api: Api, block: Extract<PiBlock, { type: "thinking" }>): boolean {
-  return api !== "bedrock-converse-stream" || block.redacted === true || !!block.thinkingSignature?.trim();
-}
-
-/** Pure conversion of an already hydrated projection; no second transcript is retained. */
-export function piContext(frozen: FrozenPrefix, messages: readonly Message[], spec: ModelSpec): Context {
-  const out: PiMessage[] = [];
-  const names = new Map<string, string>();
-  const ids = new Map<string, string>();
-  for (const message of messages) {
-    if (message.role === "assistant") {
-      const content: PiBlock[] = [];
-      for (const block of message.content) {
-        switch (block.type) {
-          case "text": {
-            const wire = record(block.wire) ? block.wire : {};
-            content.push({ type: "text", text: block.text, ...(typeof wire["textSignature"] === "string" ? { textSignature: wire["textSignature"] } : {}) }); break;
-          }
-          case "thinking": { const thinking = thinkingOf(block.raw); if (thinking && replaysAsReasoning(spec.api, thinking)) content.push(thinking); break; }
-          case "tool_use": {
-            names.set(block.id, block.name);
-            const wire = record(block.wire) ? block.wire : {};
-            const native = record(wire["pi"]) ? wire["pi"] : {};
-            const extra = record(wire["extra_content"]) && record(wire["extra_content"]["google"]) ? wire["extra_content"]["google"] : {};
-            const signature = native["thoughtSignature"] ?? extra["thought_signature"];
-            const id = typeof wire["item_id"] === "string" && spec.api.includes("responses") ? `${block.id}|${wire["item_id"]}` : block.id;
-            ids.set(block.id, id);
-            content.push({ type: "toolCall", id, name: block.name, arguments: structuredClone(block.input) as Extract<PiBlock, { type: "toolCall" }>["arguments"],
-              ...(typeof signature === "string" ? { thoughtSignature: signature } : {}), ...(typeof native["namespace"] === "string" ? { namespace: native["namespace"] } : {}) }); break;
-          }
-          case "tool_result": case "image": break;
-          default: assertNever(block, "pi assistant block");
-        }
-      }
-      out.push({ role: "assistant", content, api: spec.api, provider: spec.provider, model: spec.wireId ?? spec.id,
-        timestamp: 0, usage: structuredClone(EMPTY_USAGE), stopReason: content.some(block => block.type === "toolCall") ? "toolUse" : "stop" });
-    } else {
-      let content: Extract<PiMessage, { role: "user" }>["content"] = [];
-      let result: Extract<PiMessage, { role: "toolResult" }> | undefined;
-      const flush = () => { if (content.length) out.push({ role: "user", content, timestamp: 0 }); content = []; };
-      for (const block of message.content) {
-        if (block.type === "tool_result") {
-          flush(); result = { role: "toolResult", toolCallId: ids.get(block.tool_use_id) ?? block.tool_use_id, toolName: names.get(block.tool_use_id) ?? "tool",
-            content: [{ type: "text", text: block.content }], isError: block.is_error ?? false, timestamp: 0 };
-          out.push(result);
-        } else if (block.type === "text") { content.push({ type: "text", text: block.text }); result = undefined; }
-        else if (block.type === "image") {
-          // D5: the projection puts each image after its paired text receipt. Keep that ownership;
-          // Pi emits complete result batches before fallback user images when a protocol requires it.
-          const image = { type: "image" as const, data: imageData(block), mimeType: block.image.mimeType };
-          if (result) result.content.push(image); else content.push(image);
-        }
-      }
-      flush();
-    }
-  }
-  return { systemPrompt: frozen.system, messages: out, tools: frozen.tools.map(value => {
-    const schema = value as ToolSchema;
-    return { name: schema.name, description: schema.description, parameters: schema.input_schema as Tool["parameters"] };
-  }) };
-}
-
-export function piBlocks(message: AssistantMessage, originalArguments: ReadonlyMap<string, string> = new Map()): AssistantBlock[] {
-  return message.content.map((block): AssistantBlock => {
-    switch (block.type) {
-      case "text": return { type: "text", text: block.text, ...(block.textSignature ? { wire: { textSignature: block.textSignature } } : {}) };
-      case "thinking": {
-        let raw: unknown = { pi: structuredClone(block) };
-        if (message.api === "anthropic-messages") raw = block.redacted ? { type: "redacted_thinking", data: block.thinkingSignature }
-          : { type: "thinking", thinking: block.thinking, signature: block.thinkingSignature ?? "" };
-        else if (message.api.includes("responses") && block.thinkingSignature) { try { raw = { responses_item: JSON.parse(block.thinkingSignature) }; } catch { /* An opaque signature is still preserved by the envelope. */ } }
-        else if (message.api === "openai-completions") {
-          let details: unknown;
-          try { if (block.thinkingSignature) details = JSON.parse(block.thinkingSignature); } catch { /* The Pi envelope preserves non-JSON signatures. */ }
-          raw = { pi: structuredClone(block), reasoning_content: block.thinking, ...(details !== undefined ? { reasoning_details: details } : {}) };
-        }
-        return { type: "thinking", text: block.thinking, raw };
-      }
-      case "toolCall": return { type: "tool_use", call_id: block.id, name: block.name,
-        input: originalArguments.has(block.id) ? completedToolInput(originalArguments.get(block.id)!) : structuredClone(block.arguments),
-        ...(block.thoughtSignature || block.namespace ? { wire: { pi: { thoughtSignature: block.thoughtSignature, namespace: block.namespace } } } : {}) };
-      default: return assertNever(block, "pi response block");
-    }
-  });
-}
-
-export class PiProvider implements Provider {
-  readonly config: ProviderConfig;
-  private readonly apiKey: string;
-  private readonly connections = new ConnectionReuse();
-  private readonly options: {
-    fetch?: typeof fetch; effects?: ResolveEffects; oauth?: boolean; sessionId?: string;
-    retry?: RetryPolicy; onRetry?: (attempt: number, delayMs: number, error: unknown) => void;
-    /** Silence after which one attempt is abandoned; tests shorten it (stream-idle.ts). */
-    streamIdleMs?: number;
-  };
-  constructor(config: ProviderConfig, apiKey: string, options: PiProvider["options"] = {}) {
-    this.config = config; this.apiKey = apiKey; this.options = options;
-  }
-
-  send(frozen: FrozenPrefix, messages: readonly Message[], node: number, signal?: AbortSignal, onDelta?: OnDelta, policy?: ProviderSendOptions): Promise<Turn> {
-    // Bedrock's Pi adapter leaves retry ownership with the AWS SDK; never multiply that loop.
-    const retry = this.options.retry ?? (this.config.spec.api === "bedrock-converse-stream" ? { ...DEFAULT_RETRY, maxRetries: 0 } : DEFAULT_RETRY);
-    return withRetry(() => watchIdle(signal, this.options.streamIdleMs, idle => this.attempt(frozen, messages, node, idle, signal, onDelta, policy)).catch((error: unknown) => { this.connections.note(error); throw error; }), retry, undefined,
-      (attempt, delayMs, error) => { onDelta?.({ kind: "discard" }); onDelta?.({ kind: "retry", attempt, delayMs, max: retry.maxRetries, reason: retryLabel(error) }); this.options.onRetry?.(attempt, delayMs, error); }, signal);
-  }
-
-  private async attempt(frozen: FrozenPrefix, messages: readonly Message[], node: number, idle: IdleWatch, signal?: AbortSignal, onDelta?: OnDelta, policy?: ProviderSendOptions): Promise<Turn> {
-    signal?.throwIfAborted();
-    const started = Date.now();
-    // Wrapped innermost: providerRequest rebuilds the call as a Request and
-    // passes no init, so a keepalive set any further out would be dropped.
-    const request = providerRequest(this.config.spec, this.apiKey, this.options.effects,
-      this.connections.wrap(this.options.fetch ?? globalThis.fetch), this.options.oauth);
-    const model = piModel(this.config.spec, request.baseUrl);
-    let status: number | undefined;
-    let responseHeaders = new Headers();
-    const observedFetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
-      const response = await request.fetch(input, init);
-      status = response.status; responseHeaders = new Headers(response.headers);
-      return response;
-    }) as typeof fetch;
-    const nativeHttp = ["google-generative-ai", "google-vertex", "bedrock-converse-stream"].includes(model.api);
-    const originalArguments = new OriginalToolArguments(model.api);
-    let hasKnownUsage = false;
-    const options: SimpleStreamOptions = { ...request.options, ...(request.key ? { apiKey: request.key } : {}),
-      // Cache routing follows a root session and its forks without introducing server transcript state (D8).
-      ...(this.options.sessionId === undefined ? {} : { sessionId: this.options.sessionId }),
-      env: request.env, headers: request.headers, ...(nativeHttp ? {} : { fetch: observedFetch }), maxRetries: 0, transport: "sse",
-      maxTokens: this.config.maxTokens, ...(this.config.effort !== "off" ? { reasoning: this.config.effort } : {}),
-      signal: idle.signal, onResponse: response => { idle.touch(); status = response.status; responseHeaders = new Headers(response.headers); },
-      onProviderStreamEvent: event => {
-        idle.touch();
-        originalArguments.observe(event);
-        hasKnownUsage ||= nativeUsageReported(model.api, event);
-      },
-      onPayload: payload => {
-        if (!record(payload)) return payload;
-        const next = mergePayload(payload, request.body);
-        // Stateless Responses is required by D8: never replace the recomputable projection with server state.
-        if (model.api.includes("responses")) { next["store"] = false; delete next["previous_response_id"]; }
-        return policy?.toolUse === "disabled" ? disablePayloadTools(model.api, next) : next;
-      } };
-    let completed: AssistantMessage | undefined;
-    // Pi emits fragments; xeno's progress contract replaces the displayed argument buffer.
-    // Keep buffers per content block so interleaved calls and retries cannot share partial JSON.
-    const toolArguments = new Map<number, string>();
-    for await (const event of idle.events(APIS[model.api].streamSimple(model, normalizeContext(piContext(frozen, messages, this.config.spec)), options))) {
-      switch (event.type) {
-        case "text_delta": onDelta?.({ kind: "text", text: event.delta }); break;
-        case "thinking_delta": onDelta?.({ kind: "thinking", text: event.delta }); break;
-        case "toolcall_start": {
-          const block = event.partial.content[event.contentIndex];
-          toolArguments.set(event.contentIndex, "");
-          if (block?.type === "toolCall") onDelta?.({ kind: "tool", id: block.id, name: block.name, arguments: "" }); break;
-        }
-        case "toolcall_delta": {
-          const block = event.partial.content[event.contentIndex];
-          const argumentsText = (toolArguments.get(event.contentIndex) ?? "") + event.delta;
-          toolArguments.set(event.contentIndex, argumentsText);
-          if (block?.type === "toolCall") onDelta?.({ kind: "tool", id: block.id, name: block.name, arguments: argumentsText }); break;
-        }
-        case "toolcall_end": {
-          const block = event.toolCall;
-          onDelta?.({ kind: "tool", id: block.id, name: block.name, arguments: JSON.stringify(block.arguments) });
-          toolArguments.delete(event.contentIndex); break;
-        }
-        case "done": completed = event.message; break;
-        case "error":
-          if (event.reason === "aborted" || signal?.aborted) throw new DOMException("Request aborted", "AbortError");
-          status ??= nativeStatus(event.error.errorMessage ?? "");
-          if (status && status >= 400) {
-            // The proxy's own text says "run `grok update`", which a xeno user cannot act on.
-            const hint = grokVersionHint(status, this.config.spec.provider);
-            throw new HttpError(status, responseHeaders, (event.error.errorMessage ?? "Provider request failed") + (hint ? `\n  ${hint}` : ""));
-          }
-          throw new StreamError(event.error.errorMessage ?? "Provider stream failed");
-        case "start": case "text_start": case "text_end": case "thinking_start": case "thinking_end": break;
-        default: assertNever(event, "pi stream event");
-      }
-    }
-    signal?.throwIfAborted();
-    if (!completed || completed.stopReason === "deferred") throw new StreamError("Provider did not complete a synchronous agent turn");
-    const usage: UsageSample = { input_tokens: completed.usage.input, output_tokens: completed.usage.output,
-      cache_read_input_tokens: completed.usage.cacheRead, cache_creation_input_tokens: completed.usage.cacheWrite, node, ms: Date.now() - started };
-    const identityErrors = originalArguments.identityErrors();
-    if (identityErrors.length) throw new ProviderIntegrityError(identityErrors, hasKnownUsage ? usage : undefined);
-    // The SDK has already classified native STOP/end_turn/toolUse/length values. The loop consumes
-    // xeno's closed completion vocabulary, never a raw native spelling that could skip tool execution.
-    return coherentTurn({ blocks: piBlocks(completed, originalArguments.values), stopReason: completed.stopReason === "length" ? "max_tokens" : completed.stopReason === "toolUse" ? "tool_use" : "end_turn",
-      usage }, hasKnownUsage);
-  }
-}