@visual-z/xeno 0.1.4 → 0.2.0

package/src/runtime/openai-responses.ts

@@ -19,6 +19,7 @@
  */
 import type { AssistantBlock } from "../core/events.ts";
 import type { ContentBlock, FrozenPrefix, Message } from "../core/project.ts";
+import { imageData } from "./images.ts";
 import { assertNever } from "../core/exhaustive.ts";
 import type { OnDelta, Provider, ProviderConfig, ToolSchema, Turn } from "./provider.ts";
 import { pushSse, HttpError, StreamError } from "./openai.ts";
@@ -69,6 +70,7 @@ function inputItems(messages: readonly Message[]): InputItem[] {
             break;
           }
           case "tool_result":
+          case "image":
             break;
           default:
             return assertNever(block, "responses assistant input");
@@ -77,14 +79,16 @@ function inputItems(messages: readonly Message[]): InputItem[] {
       flushText();
     } else {
       const text: string[] = [];
+      const images: unknown[] = [];
       for (const block of message.content as readonly ContentBlock[]) {
         if (block.type === "text") text.push(block.text);
+        else if (block.type === "image") images.push({ type: "input_image", image_url: `data:${block.image.mimeType};base64,${imageData(block)}`, detail: "auto" });
         else if (block.type === "tool_result") {
           out.push({ type: "function_call_output", call_id: block.tool_use_id,
             output: block.is_error ? `[error] ${block.content}` : block.content });
         }
       }
-      if (text.length > 0) out.push({ type: "message", role: "user", content: [{ type: "input_text", text: text.join("\n") }] });
+      if (text.length > 0 || images.length) out.push({ type: "message", role: "user", content: [...(text.length ? [{ type: "input_text", text: text.join("\n") }] : []), ...images] });
     }
   }
   return out;
@@ -108,9 +112,11 @@ export function buildResponsesRequest(config: ProviderConfig, frozen: FrozenPref
   if (frozen.tools.length > 0) request["tools"] = responsesTools(frozen.tools);
   if (spec.reasoning) {
     // Accepted but no longer required by current models; older ones need it.
-    request["include"] = ["reasoning.encrypted_content"];
+    if (config.effort !== "off" || spec.provider === "xai") request["include"] = ["reasoning.encrypted_content"];
     const mapped = spec.thinkingLevelMap?.[config.effort];
-    if (mapped !== null) request["reasoning"] = { effort: mapped ?? config.effort, summary: "auto" };
+    if (mapped !== null && !(config.effort === "off" && spec.provider === "github-copilot")) {
+      request["reasoning"] = { effort: mapped ?? (config.effort === "off" ? "none" : config.effort), ...(config.effort === "off" ? {} : { summary: "auto" }) };
+    }
   }
   return request;
 }
@@ -152,6 +158,7 @@ async function readResponsesSse(body: ReadableStream<Uint8Array>, node: number,
       case "response.output_item.added": {
         const kind = item?.["type"] === "reasoning" ? "thinking" : item?.["type"] === "function_call" ? "call" : item?.["type"] === "message" ? "text" : null;
         if (kind !== null) slots.set(index, { kind, text: "", ...(item ? { item } : {}) });
+        if (kind === "call") onDelta?.({ kind: "tool", id: String(item?.["call_id"] ?? index), name: String(item?.["name"] ?? ""), arguments: "" });
         return;
       }
       case "response.reasoning_summary_text.delta":
@@ -165,6 +172,7 @@ async function readResponsesSse(body: ReadableStream<Uint8Array>, node: number,
         slot.text += delta;
         if (slot.kind === "thinking") onDelta?.({ kind: "thinking", text: delta });
         else if (slot.kind === "text") onDelta?.({ kind: "text", text: delta });
+        else onDelta?.({ kind: "tool", id: String(slot.item?.["call_id"] ?? index), name: String(slot.item?.["name"] ?? ""), arguments: slot.text });
         return;
       }
       case "response.output_item.done": {
@@ -260,7 +268,7 @@ export class OpenAIResponsesProvider implements Provider {
 
   send(frozen: FrozenPrefix, messages: readonly Message[], node: number, signal?: AbortSignal, onDelta?: OnDelta): Promise<Turn> {
     return withRetry(() => this.attempt(frozen, messages, node, signal, onDelta), this.retry, undefined,
-      (attempt, delayMs, error) => { onDelta?.({ kind: "discard" }); this.onRetry?.(attempt, delayMs, error); }, signal);
+      (attempt, delayMs, error) => { onDelta?.({ kind: "discard" }); onDelta?.({ kind: "retry", attempt, delayMs }); this.onRetry?.(attempt, delayMs, error); }, signal);
   }
 
   private async attempt(frozen: FrozenPrefix, messages: readonly Message[], node: number, signal?: AbortSignal, onDelta?: OnDelta): Promise<Turn> {

package/src/runtime/openai.ts

@@ -20,6 +20,7 @@
  */
 
 import type { Message, ContentBlock, FrozenPrefix } from "../core/project.ts";
+import { imageData } from "./images.ts";
 import type { AssistantBlock } from "../core/events.ts";
 import { assertNever } from "../core/exhaustive.ts";
 import type { Provider, ProviderConfig, Turn, ToolSchema, OnDelta } from "./provider.ts";
@@ -29,7 +30,7 @@ import { withRetry, DEFAULT_RETRY, type RetryPolicy } from "./retry.ts";
 /** One message as Chat Completions wants it. */
 export interface WireMessage {
   role: "system" | "developer" | "user" | "assistant" | "tool";
-  content?: string | null;
+  content?: string | null | ({ type: "text"; text: string } | { type: "image_url"; image_url: { url: string } })[];
   reasoning_content?: string;
   /** OpenRouter's structured reasoning, replayed as received. */
   reasoning_details?: unknown;
@@ -150,6 +151,7 @@ function assistantMessage(content: readonly ContentBlock[], compat: Compat, reas
         });
         break;
       case "tool_result":
+      case "image":
         // A tool_result inside an assistant turn is not a shape the projection
         // produces. Ignored rather than thrown: the request stays valid, and
         // the pairing checks that would catch it live in the core.
@@ -190,9 +192,11 @@ function assistantMessage(content: readonly ContentBlock[], compat: Compat, reas
 function userMessages(content: readonly ContentBlock[]): WireMessage[] {
   const out: WireMessage[] = [];
   const text: string[] = [];
+  const parts: NonNullable<Exclude<WireMessage["content"], string>> = [];
 
   for (const b of content) {
     switch (b.type) {
+      case "image": parts.push({ type: "image_url", image_url: { url: `data:${b.image.mimeType};base64,${imageData(b)}` } }); break;
       case "tool_result":
         out.push({
           role: "tool",
@@ -213,7 +217,8 @@ function userMessages(content: readonly ContentBlock[]): WireMessage[] {
     }
   }
 
-  if (text.length > 0) out.push({ role: "user", content: text.join("\n") });
+  if (parts.length) out.push({ role: "user", content: [...(text.length ? [{ type: "text" as const, text: text.join("\n") }] : []), ...parts] });
+  else if (text.length > 0) out.push({ role: "user", content: text.join("\n") });
   return out;
 }
 
@@ -262,10 +267,12 @@ export function buildRequest(
   if (frozen.tools.length > 0) request.tools = toWireTools(frozen.tools);
 
   if (spec.reasoning) {
-    if (compat.thinkingFormat === "deepseek") request.thinking = { type: "enabled" };
-    if (compat.supportsReasoningEffort) {
+    if (compat.thinkingFormat === "deepseek") request.thinking = { type: config.effort === "off" ? "disabled" : "enabled" };
+    if (compat.supportsReasoningEffort && config.effort !== "off") {
       const effort = wireEffort(spec, config.effort);
       if (effort !== null) request.reasoning_effort = effort;
+    } else if (config.effort === "off" && compat.thinkingFormat !== "deepseek" && typeof spec.thinkingLevelMap?.off === "string") {
+      request.reasoning_effort = spec.thinkingLevelMap.off;
     }
   }
 
@@ -436,6 +443,7 @@ export class OpenAICompletionsProvider implements Provider {
       undefined,
       (attempt, delayMs, error) => {
         onDelta?.({ kind: "discard" });
+        onDelta?.({ kind: "retry", attempt, delayMs });
         this.onRetry?.(attempt, delayMs, error);
       },
       signal,
@@ -584,6 +592,7 @@ function applyCompletionChunk(chunk: WireStreamChunk, acc: StreamAcc, onDelta?:
     if (call.id) tool.id = call.id;
     if (call.function?.name) tool.name = call.function.name;
     if (call.function?.arguments) tool.arguments += call.function.arguments;
+    onDelta?.({ kind: "tool", id: tool.id || String(index), name: tool.name, arguments: tool.arguments });
     Object.assign(tool.extra, extraFields(call as Record<string, unknown>) ?? {});
   }
 }

package/src/runtime/package-manager.ts

@@ -0,0 +1,125 @@
+/** 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/pi-provider.ts

@@ -0,0 +1,235 @@
+/** 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 type { AssistantBlock } from "../core/events.ts";
+import type { FrozenPrefix, Message } from "../core/project.ts";
+import type { Api, ModelSpec } from "./model.ts";
+import { providerRequest } from "./provider-request.ts";
+import type { ResolveEffects } from "./auth.ts";
+import { imageData } from "./images.ts";
+import type { OnDelta, Provider, ProviderConfig, ToolSchema, Turn } from "./provider.ts";
+import { DEFAULT_RETRY, withRetry, type RetryPolicy } from "./retry.ts";
+import { HttpError, StreamError } from "./openai.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 } };
+
+/** 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 ? { compat: { ...spec.compat, ...spec.nativeCompat } } : {}),
+    ...(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;
+}
+
+/** 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) 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"] = [];
+      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(); out.push({ 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 });
+        } else if (block.type === "text") content.push({ type: "text", text: block.text });
+        else if (block.type === "image") content.push({ type: "image", data: imageData(block), mimeType: block.image.mimeType });
+      }
+      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): 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: 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 options: {
+    fetch?: typeof fetch; effects?: ResolveEffects; oauth?: boolean; retry?: RetryPolicy; onRetry?: (attempt: number, delayMs: number, error: unknown) => void;
+  };
+  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): 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(() => this.attempt(frozen, messages, node, signal, onDelta), retry, undefined,
+      (attempt, delayMs, error) => { onDelta?.({ kind: "discard" }); onDelta?.({ kind: "retry", attempt, delayMs }); this.options.onRetry?.(attempt, delayMs, error); }, signal);
+  }
+
+  private async attempt(frozen: FrozenPrefix, messages: readonly Message[], node: number, signal?: AbortSignal, onDelta?: OnDelta): Promise<Turn> {
+    signal?.throwIfAborted();
+    const started = Date.now();
+    const request = providerRequest(this.config.spec, this.apiKey, this.options.effects, this.options.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 options: SimpleStreamOptions = { ...request.options, ...(request.key ? { apiKey: request.key } : {}),
+      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 ? { signal } : {}), onResponse: response => { status = response.status; responseHeaders = new Headers(response.headers); },
+      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 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 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) throw new HttpError(status, responseHeaders, event.error.errorMessage ?? "Provider request failed");
+          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");
+    // 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 { blocks: piBlocks(completed), stopReason: completed.stopReason === "length" ? "max_tokens" : completed.stopReason === "toolUse" ? "tool_use" : "end_turn",
+      usage: { 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 } };
+  }
+}

package/src/runtime/progress.ts

@@ -0,0 +1,26 @@
+/** Display updates are transient; only the completed operation may become a durable result. */
+export async function* withProgress<T, E>(start: (emit: (event: E) => void) => Promise<T>): AsyncGenerator<E, T> {
+  const queue: E[] = [];
+  let wake: (() => void) | undefined;
+  let accepting = true;
+  const box: { result?: { ok: true; value: T } | { ok: false; error: unknown } } = {};
+  const pending = start(event => { if (accepting) queue.push(event); wake?.(); }).then(
+    value => { box.result = { ok: true, value }; wake?.(); },
+    error => { box.result = { ok: false, error }; wake?.(); },
+  );
+  try {
+    while (box.result === undefined || queue.length) {
+      if (queue.length) { yield queue.shift()!; continue; }
+      await new Promise<void>(resolve => { wake = resolve; });
+      wake = undefined;
+    }
+  } finally {
+    accepting = false;
+    queue.length = 0;
+    await pending;
+  }
+  await pending;
+  if (!box.result) throw new Error("operation settled without a result");
+  if (!box.result.ok) throw box.result.error;
+  return box.result.value;
+}

package/src/runtime/provider-access.ts

@@ -0,0 +1,21 @@
+import type { ModelSpec } from "./model.ts";
+
+/** Secrets are not model metadata. Enumerating/serializing a model cannot expose config values. */
+export interface ProviderAccess {
+  apiKey?: string;
+  headers?: Record<string, string | null>;
+  env?: Record<string, string>;
+  auth?: false | "ambient";
+  authHeader?: boolean | string;
+  options?: Record<string, unknown>;
+  body?: Record<string, unknown>;
+  invalid?: string;
+}
+const access = new WeakMap<ModelSpec, ProviderAccess>();
+export function setProviderAccess(model: ModelSpec, value: ProviderAccess): void { access.set(model, value); }
+export function providerAccess(model: ModelSpec): ProviderAccess { return access.get(model) ?? {}; }
+export function hasProviderAccess(model: ModelSpec): boolean { return access.has(model); }
+export function copyProviderAccess(from: ModelSpec, to: ModelSpec): void {
+  const value = access.get(from);
+  if (value) access.set(to, value);
+}

package/src/runtime/provider-protocols.ts

@@ -0,0 +1,29 @@
+/** Protocol vocabulary is local; SDK types and IO never enter core (D13). */
+export const PROVIDER_APIS = [
+  "anthropic-messages", "openai-completions", "openai-responses", "google-generative-ai",
+  "google-vertex", "bedrock-converse-stream", "azure-openai-responses", "openai-codex-responses",
+  "mistral-conversations", "pi-messages",
+] as const;
+export type ProviderApi = typeof PROVIDER_APIS[number];
+export function isProviderApi(value: unknown): value is ProviderApi {
+  return typeof value === "string" && (PROVIDER_APIS as readonly string[]).includes(value);
+}
+
+/** SDK dispatch from OpenCode's model-level `provider.npm` before provider defaults. */
+export const SDK_APIS: Readonly<Record<string, ProviderApi>> = {
+  "@ai-sdk/anthropic": "anthropic-messages",
+  "@ai-sdk/openai": "openai-responses",
+  "@ai-sdk/openai-compatible": "openai-completions",
+  "@openrouter/ai-sdk-provider": "openai-completions",
+  "@ai-sdk/groq": "openai-completions",
+  "@ai-sdk/cerebras": "openai-completions",
+  "@ai-sdk/deepinfra": "openai-completions",
+  "@ai-sdk/togetherai": "openai-completions",
+  "@ai-sdk/xai": "openai-completions",
+  "@ai-sdk/mistral": "mistral-conversations",
+  "@ai-sdk/google": "google-generative-ai",
+  "@ai-sdk/google-vertex": "google-vertex",
+  "@ai-sdk/amazon-bedrock": "bedrock-converse-stream",
+  "@ai-sdk/azure": "azure-openai-responses",
+  "@ai-sdk/gateway": "anthropic-messages",
+};