@springbrand/agent-runtime 0.3.0-alpha.1 → 0.3.0-alpha.11

package/src/harness/session-harness.ts

@@ -4,6 +4,7 @@ import {
   type AgentHarness as PiAgentHarness,
   type AgentHarnessOptions,
   type AgentLane,
+  type AgentToolResult,
   type DriveOutcome,
   type DriveOptions,
   type OpenOperation,
@@ -17,6 +18,7 @@ import {
   isRecoverableAssistantError,
 } from "../models";
 import { projectToolOutputForModel } from "../context/memory/budget/gate";
+import type { ArtifactRef } from "../lib/artifacts";
 
 export interface SessionHarnessLimits {
   /** Complete model turns committed before one Worker instance releases. */
@@ -34,6 +36,22 @@ export interface SessionHarnessOptions<TContext extends object | undefined>
   modelToolResultExemptions?: readonly string[];
   /** Base provider Session identity, retained except after a server Tool timeout. */
   modelSessionId?: string;
+  /**
+   * Compiled tools omitted from the initial active set. A later successful
+   * result may add them through {@link SessionHarnessOptions.toolsToActivate}.
+   */
+  onDemandToolNames?: readonly string[];
+  /**
+   * Names to add with `setActiveTools` from `after_tool`. That hook runs
+   * before the next generation snapshots `activeToolNames`; Pi then writes
+   * the difference as transcript `toolsAdded`. Do not call `setActiveTools`
+   * from `tool_end`: event delivery is serialized and would deadlock.
+   */
+  toolsToActivate?: (
+    toolName: string,
+    result: AgentToolResult<unknown>,
+    isError: boolean,
+  ) => readonly string[];
 }
 
 export type SessionHarnessRunResult = DriveOutcome | {
@@ -54,6 +72,7 @@ const TOOL_FAILURE_WRAP_UP_INSTRUCTION =
   "This turn reached its tool failure limit. Stop calling tools now. Reply with a final message that explains what failed and the exact next step the user should take. Do not start new work.";
 const MAX_TOOL_RETRIES = 3;
 const TURN_FAILURE_CEILING = 8;
+const ARTIFACT_MANIFEST_MAX_CHARS = 12 * 1024;
 
 function canonicalJson(value: unknown): string {
   if (Array.isArray(value)) {
@@ -73,6 +92,10 @@ function toolCallKey(toolName: string, args: unknown): string {
   return `${toolName}\0${canonicalJson(args)}`;
 }
 
+function uniqueToolNames(names: readonly string[]): string[] {
+  return [...new Set(names)];
+}
+
 function projectToolResultsForModel(
   messages: readonly AgentMessage[],
   exemptions: ReadonlySet<string>,
@@ -92,6 +115,66 @@ function projectToolResultsForModel(
   return changed ? projected : [...messages];
 }
 
+function artifactRefFromMessage(message: AgentMessage): ArtifactRef | undefined {
+  if (message.role !== "toolResult" || message.details === null ||
+    typeof message.details !== "object" ||
+    (message.details as { kind?: unknown }).kind !== "artifact_ref") {
+    return undefined;
+  }
+  const ref = message.details as Partial<ArtifactRef>;
+  if (typeof ref.path !== "string" || typeof ref.hash !== "string" ||
+    typeof ref.bytes !== "number" || typeof ref.preview !== "string" ||
+    typeof ref.note !== "string") return undefined;
+  return {
+    kind: "artifact_ref",
+    artifactId: typeof ref.artifactId === "string"
+      ? ref.artifactId
+      : `artifact_${ref.hash.slice(0, 24)}`,
+    path: ref.path,
+    bytes: ref.bytes,
+    hash: ref.hash,
+    workspaceRevision: typeof ref.workspaceRevision === "string"
+      ? ref.workspaceRevision
+      : "unknown",
+    availability: ref.availability === "unavailable"
+      ? "unavailable"
+      : "available",
+    preview: ref.preview,
+    note: ref.note,
+  };
+}
+
+function artifactManifestMessage(
+  refs: ReadonlyMap<string, ArtifactRef>,
+): AgentMessage | undefined {
+  if (refs.size === 0) return undefined;
+  const lines = [
+    "<workspace_artifact_manifest>",
+    "These are lightweight references to prior Tool output. Do not treat previews as complete. Read an available artifact with the Workspace readFile/readFilePage tool only when the current request needs its evidence.",
+  ];
+  let omitted = 0;
+  for (const ref of refs.values()) {
+    const preview = ref.preview.replace(/[\r\n]+/g, " ").slice(0, 160);
+    const line = [
+      `path=${ref.path}`,
+      ...(ref.availability === "unavailable" ? ["unavailable"] : []),
+      `preview=${preview}`,
+    ].join(" ");
+    if ([...lines, line, "</workspace_artifact_manifest>"].join("\n").length > ARTIFACT_MANIFEST_MAX_CHARS) {
+      omitted += 1;
+      continue;
+    }
+    lines.push(line);
+  }
+  if (omitted > 0) lines.push(`omitted=${omitted} additional artifact references due to manifest budget`);
+  lines.push("</workspace_artifact_manifest>");
+  return {
+    role: "user",
+    content: lines.join("\n"),
+    timestamp: 1,
+  };
+}
+
 function deferred<T>(): {
   promise: Promise<T>;
   resolve(value: T): void;
@@ -126,6 +209,15 @@ export class SessionHarness<TContext extends object | undefined> {
   private readonly modelSessionId: string | undefined;
   private readonly wrapUpInstruction: string;
   private readonly configuredToolNames: string[];
+  private readonly compiledToolNames: ReadonlySet<string>;
+  private readonly onDemandToolNames: ReadonlySet<string>;
+  private readonly toolsToActivate:
+    | ((
+      toolName: string,
+      result: AgentToolResult<unknown>,
+      isError: boolean,
+    ) => readonly string[])
+    | undefined;
   private readonly modelToolResultExemptions: ReadonlySet<string>;
   private readonly toolFailures = new Map<string, number>();
   private totalToolFailures = 0;
@@ -144,6 +236,7 @@ export class SessionHarness<TContext extends object | undefined> {
   private readonly releaseRequest = deferred<"approval" | "interaction">();
   private readonly activeTools = new Set<string>();
   private readonly toolsIdle = new Set<() => void>();
+  private readonly artifactRefs = new Map<string, ArtifactRef>();
 
   private constructor(
     readonly harness: PiAgentHarness<TContext>,
@@ -169,18 +262,22 @@ export class SessionHarness<TContext extends object | undefined> {
       DEFAULT_WRAP_UP_INSTRUCTION;
     this.configuredToolNames = options.activeToolNames ??
       (options.tools ?? []).map(({ name }) => name);
+    this.compiledToolNames = new Set((options.tools ?? []).map(({ name }) => name));
+    this.onDemandToolNames = new Set(options.onDemandToolNames ?? []);
+    this.toolsToActivate = options.toolsToActivate;
     this.modelToolResultExemptions = new Set(
       options.modelToolResultExemptions ?? [],
     );
   }
 
   private async operationEntries(context: Context): Promise<Entry[]> {
+    // Stop boundaries follow traversal order; walk back from the current tip.
     const entries = await this.lane.findEntries({
       ...(this.operationStartTip === null ? {} : { stopAtId: this.operationStartTip }),
       type: "message",
-      order: "oldestFirst",
+      order: "newestFirst",
     }, context);
-    return entries.filter(({ id }) => id !== this.operationStartTip);
+    return entries.filter(({ id }) => id !== this.operationStartTip).reverse();
   }
 
   private async restoreToolGovernance(context: Context): Promise<void> {
@@ -255,6 +352,8 @@ export class SessionHarness<TContext extends object | undefined> {
       limits: _limits,
       modelToolResultExemptions: _modelToolResultExemptions,
       modelSessionId: _modelSessionId,
+      onDemandToolNames: _onDemandToolNames,
+      toolsToActivate: _toolsToActivate,
       ...harnessOptions
     } = options;
     let runtime!: SessionHarness<TContext>;
@@ -288,6 +387,12 @@ export class SessionHarness<TContext extends object | undefined> {
   }
 
   private async install(context: Context): Promise<void> {
+    for (const entry of await this.lane.findEntries({ type: "message", order: "oldestFirst" }, context)) {
+      if (entry.type === "message") {
+        const ref = artifactRefFromMessage(entry.message);
+        if (ref) this.artifactRefs.set(ref.artifactId, ref);
+      }
+    }
     if (this._openOperation) {
       const watch = await this.lane.watch(context);
       this.operationStartTip = watch.snapshot.operation?.fromTipId ?? null;
@@ -316,19 +421,21 @@ export class SessionHarness<TContext extends object | undefined> {
         event.messages,
         this.modelToolResultExemptions,
       );
+      const manifest = artifactManifestMessage(this.artifactRefs);
       const instruction = this.toolFailureWrapUp
         ? TOOL_FAILURE_WRAP_UP_INSTRUCTION
         : this.wrappingUp
           ? this.wrapUpInstruction
           : undefined;
+      const contextMessages = manifest ? [...messages, manifest] : messages;
       return {
         messages: instruction
-          ? [...messages, {
+          ? [...contextMessages, {
               role: "user" as const,
               content: instruction,
               timestamp: 1,
             }]
-          : messages,
+          : contextMessages,
       };
     });
     this.harness.hooks.on("before_tool", (event) => {
@@ -353,7 +460,12 @@ export class SessionHarness<TContext extends object | undefined> {
       };
     });
     this.harness.events.on("entry_added", (event) => {
-      if (event.lane === this.lane.name) this.recordCanonicalToolOutcome(event.entry);
+      if (event.lane !== this.lane.name) return;
+      this.recordCanonicalToolOutcome(event.entry);
+      if (event.entry.type === "message") {
+        const ref = artifactRefFromMessage(event.entry.message);
+        if (ref) this.artifactRefs.set(ref.artifactId, ref);
+      }
     });
     this.harness.events.on("turn_end", async (_event, eventContext) => {
       const total = await this.completedModelTurns(eventContext);
@@ -371,6 +483,17 @@ export class SessionHarness<TContext extends object | undefined> {
       }
       await this.harness.close(eventContext);
     });
+    this.harness.hooks.on("after_tool", async (event, eventContext) => {
+      await this.activateToolsFromResult({
+        toolName: event.toolName,
+        result: {
+          content: event.content,
+          details: event.details,
+        },
+        isError: event.isError,
+      }, eventContext);
+      return undefined;
+    });
     this.harness.events.on("tool_start", (event) => {
       this.activeTools.add(event.toolCallId);
     });
@@ -393,6 +516,34 @@ export class SessionHarness<TContext extends object | undefined> {
     await new Promise<void>((resolve) => this.toolsIdle.add(resolve));
   }
 
+  private async activeToolsForNewOperation(context: Context): Promise<string[]> {
+    const previous = await this.lane.getActiveTools(context);
+    const keepOnDemand = previous.filter((name) =>
+      this.onDemandToolNames.has(name) && this.compiledToolNames.has(name)
+    );
+    return uniqueToolNames([...this.configuredToolNames, ...keepOnDemand]);
+  }
+
+  private async activateToolsFromResult(
+    event: {
+      toolName: string;
+      result: AgentToolResult<unknown>;
+      isError: boolean;
+    },
+    context: Context,
+  ): Promise<void> {
+    const requested = this.toolsToActivate?.(
+      event.toolName,
+      event.result,
+      event.isError,
+    ) ?? [];
+    const allowed = requested.filter((name) => this.compiledToolNames.has(name));
+    if (allowed.length === 0) return;
+    const current = await this.lane.getActiveTools(context);
+    if (allowed.every((name) => current.includes(name))) return;
+    await this.lane.setActiveTools(uniqueToolNames([...current, ...allowed]), context);
+  }
+
   private async completedModelTurns(context: Context): Promise<number> {
     return (await this.operationEntries(context)).filter((entry) =>
       entry.type === "message" && entry.message.role === "assistant"
@@ -417,7 +568,10 @@ export class SessionHarness<TContext extends object | undefined> {
       this.toolFailureWrapUp = false;
       this.toolFailureWrapUpAt = undefined;
       this.releaseReason = undefined;
-      await this.lane.setActiveTools(this.configuredToolNames, context);
+      await this.lane.setActiveTools(
+        await this.activeToolsForNewOperation(context),
+        context,
+      );
       const admission = await this.lane.accept(request, context);
       if (!admission.ok) throw admission.error;
       operationId = admission.value.operationId;

package/src/index.ts

@@ -51,7 +51,7 @@ export type { RuntimeAssemblyView } from "./config/assembly-view";
 export * from "./adapter/cloudflare/define-agent";
 export type { ToolInteractionResponsePreparation } from "./adapter/cloudflare/agent";
 export * from "./conversation/state";
-export * from "./tools/workspace-versioning";
+export * from "./tools/workspace/versioning";
 export * from "./lib/execution-level";
 export type {
   RuntimeAssemblyInput,
@@ -84,16 +84,17 @@ export type {
 } from "./lib/host-actions";
 export {
   AGENT_TYPES,
-} from "./tools/subagent-types/registry";
+} from "./tools/subagent/types/registry";
 export type {
   AgentType,
-} from "./tools/subagent-types/contract";
+} from "./tools/subagent/types/contract";
 export type {
   PiToolCandidate,
   ToolExposureMode,
 } from "./tools";
 export { basePiToolCandidates } from "./tools";
 export { createPiDeclaredToolCandidate } from "./tools";
+export { harnessToolActivation } from "./tools";
 export type {
   PiDeclaredTool,
   PiDeclaredToolCallContext,
@@ -129,15 +130,15 @@ export type {
   TemporaryAgentLaunch,
   TemporaryAgentRequest,
   TemporaryAgentRunContext,
-} from "./tools/temporary-agent/core";
-export { TEMPORARY_AGENT_LAUNCH_KEY } from "./tools/temporary-agent/core";
+} from "./tools/subagent/temporary/core";
+export { TEMPORARY_AGENT_LAUNCH_KEY } from "./tools/subagent/temporary/core";
 export {
   temporaryAgentExtensionIsSafe,
   temporaryAgentToolAllowed,
-} from "./tools/temporary-agent/runner";
+} from "./tools/subagent/temporary/runner";
 export {
   createTemporaryAgentWorkspace,
-} from "./tools/temporary-agent/workspace";
+} from "./tools/subagent/temporary/workspace";
 export {
   createPiModels,
   modelRequestUrl,

package/src/lib/artifacts.ts

@@ -4,9 +4,12 @@
 /** Stable narrow reference shared by messages, RPC responses and the UI. */
 export interface ArtifactRef {
   kind: "artifact_ref";
+  artifactId: string;
   path: string;
   bytes: number;
   hash: string;
+  workspaceRevision: string;
+  availability: "available" | "unavailable";
   preview: string;
   note: string;
 }
@@ -14,6 +17,15 @@ export interface ArtifactRef {
 export interface SpillWorkspace {
   /** 把溢出的 Artifact 内容写入指定 Workspace 路径。 */
   writeFile(path: string, content: string, mimeType?: string): Promise<void>;
+  /** 写入后验证物理文件，防止只持久化了一个不存在或被截断的引用。 */
+  stat?(path: string): Promise<{
+    type: "file" | "directory" | "symlink";
+    size: number;
+    updatedAt: number;
+    contentVersion?: string;
+  } | null>;
+  /** 写入后验证内容摘要；Artifact 全部是 UTF-8 文本。 */
+  readFileBytes?(path: string): Promise<Uint8Array | null>;
 }
 
 /**
@@ -33,6 +45,10 @@ export async function sha256Hex(text: string): Promise<string> {
   return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 
+function artifactId(hash: string): string {
+  return `artifact_${hash.slice(0, 24)}`;
+}
+
 /**
  * 把 Tool 结果转成可存储的文本，并选择 `.txt` 或 `.json` 扩展名。
  *
@@ -52,3 +68,5 @@ export function serializeOutput(output: unknown): { text: string; ext: "txt" | "
     return { text: String(output), ext: "txt" };
   }
 }
+
+export { artifactId };

package/src/lib/execution-level.ts

@@ -25,3 +25,16 @@ export function maxExecutionLevel(
     )
   ]!;
 }
+
+/** The most permissive level shared by an Agent and a Scheduled Task ceiling. */
+export function minExecutionLevel(
+  left: ExecutionLevel,
+  right: ExecutionLevel,
+): ExecutionLevel {
+  return EXECUTION_LEVELS[
+    Math.min(
+      EXECUTION_LEVELS.indexOf(left),
+      EXECUTION_LEVELS.indexOf(right),
+    )
+  ]!;
+}

package/src/lib/prompt.ts

@@ -17,9 +17,8 @@ export const PERSONA =
 // Names the stable runtime environment.
 export const RUNTIME =
   "Runtime: this agent runs on Cloudflare Workers. When execute is present, its Code Mode Dynamic Worker is your " +
-  "instrument — code there runs with outbound network access (fetch), your " +
-  "workspace filesystem (state.*), and the tools.* methods listed in its own description. Use it for raw or customized HTTP " +
-  "requests, parsing a payload, hitting several known endpoints, or computing over a file. Write plain " +
+  "instrument — code there runs with your workspace filesystem (state.*) and the tools.* methods listed in its own description. " +
+  "Use it for tool composition, parsing a payload, or computing over a file. Write plain " +
   "JavaScript — the sandbox evaluates " +
   "it directly, so TypeScript type annotations (`: number`, `as Type`) are a syntax error, and there " +
   "is no Python interpreter or package manager to invoke. Use the JS/Workers equivalent of what you " +
@@ -58,8 +57,7 @@ export const TOOLS =
   "use state.* for workspace file operations, tools.* for other host capabilities, and sequential calls for repeated or durable operations. " +
   "Top-level-only Tools remain Direct even when called repeatedly. " +
   "For web tasks, use web_search for web discovery, current facts, cited research, " +
-  "and public URL analysis. For web access specifically, use execute Code Mode only for raw or customized network requests, structured " +
-  "API calls, or when web_search cannot retrieve the required content; do not use execute for ordinary web " +
+  "and public URL analysis; do not use execute for ordinary web " +
   "searches. When execute is absent, use the actually exposed Direct Tools. When sandbox_* tools are present, use that isolated Linux environment for Python/Node, " +
   "package managers, system commands, builds, tests and background processes; its filesystem is temporary, " +
   "persistent inputs are copied in automatically on first use, /userspace is read-only, and only explicitly " +
@@ -70,7 +68,10 @@ export const TOOLS =
   "prioritize verification, saving durable results, and the final response. " +
   "When related Tool calls can run independently, all are available inside execute, and execute is present, run them inside that execute rather than as parallel top-level calls; " +
   "only independent top-level-only Direct Tools should be issued together in one turn. When you reference " +
-  "code, cite it as file_path:line_number.";
+  "code, cite it as file_path:line_number. " +
+  "When schedule tools are available, prepare a standalone Requirement (at most 1000 Unicode characters), a name (at most 50), a time rule and an explicit timezone. Ask for missing information. " +
+  "Use local once/daily/weekly rules for new scheduled tasks. The Host prepares the authorization scope and the user must confirm before saving; never claim a task was created before the Tool succeeds. " +
+  "One source Chat may create multiple tasks. Before editing, list tasks and use the exact Task ID; ask when the target is ambiguous. Never attach source history or hidden context to the Requirement.";
 
 // A real browser is the only way to observe what a page actually does, and the
 // shared failure mode is a browser tool that returns nothing and looks clean.
@@ -117,10 +118,8 @@ export const INTERACTION =
   "without that answer; required defaults to false. At most one question may request attachments. Do not add an accept field or tell the user to upload through the normal chat composer; " +
   "continue the same turn when its result arrives. " +
   "Don't use it when a sensible default lets you proceed. " +
-  "After completing a substantive task (report, analysis, multi-step job), finish all work and other Tool calls, " +
-  "then call suggest_followups (2-4 directions) as the last Tool call before your final answer. " +
-  "After it returns, write your complete final answer and make no further Tool calls. Never for small talk or while a " +
-  "task is still in progress; it is non-blocking, unlike ask_user.";
+  "When a substantive task (report, analysis, or multi-step job) is complete, call suggest_followups once before the final answer. " +
+  "Never use it for small talk, quick answers, or while a task is still in progress; it is non-blocking, unlike ask_user.";
 
 // Separates short always-on memory from indexed long-tail workspace files.
 export const MEMORY =

package/src/lib/token-estimate.ts

@@ -0,0 +1,8 @@
+/** Conservative token estimate for prompt budgeting, not provider billing. */
+export function estimateStringTokens(text: string): number {
+  if (!text) return 0;
+  return Math.ceil(Math.max(
+    text.length / 4,
+    text.split(/\s+/u).filter(Boolean).length * 1.3,
+  ));
+}

package/src/models/index.ts

@@ -2,6 +2,7 @@ import type { StreamFn } from "@earendil-works/pi-agent-core";
 import {
   createModels,
   createProvider,
+  getCurrentSystemPrompt,
   isRetryableAssistantError,
   lazyStream,
   type Api,
@@ -11,6 +12,8 @@ import {
   type Model,
   type MutableModels,
   type ProviderStreams,
+  type SimpleStreamOptions,
+  type TranscriptContext,
 } from "@earendil-works/pi-ai";
 import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
 import {
@@ -38,7 +41,7 @@ import {
   openaiCodexProvider,
 } from "@earendil-works/pi-ai/providers/openai-codex";
 import {
-  cloudflareStreams,
+  resolveCloudflareModel,
 } from "@earendil-works/pi-ai/providers/cloudflare-stream";
 import {
   ChatStreamStalledError,
@@ -51,6 +54,10 @@ import type {
 } from "../config/ports";
 import { modelInputMessages } from "../conversation/message/model-input";
 import { openRouterMessagesApi } from "./openrouter/messages";
+import {
+  overlayProviderStreams,
+  remapProviderStreamModels,
+} from "./provider-streams";
 
 const CATALOGS = {
   "openai-chat": openaiProvider().getModels(),
@@ -130,6 +137,12 @@ export type PiGenerationLifecycleObserver = (
   event: PiGenerationLifecycleEvent,
 ) => void;
 
+type ProviderBoundStream = (
+  model: Model<Api>,
+  context: Context | TranscriptContext,
+  options?: SimpleStreamOptions,
+) => ReturnType<StreamFn>;
+
 export function structuredOutputStream(
   streamFn: StreamFn,
   model: Model<Api>,
@@ -490,16 +503,19 @@ export function modelRequestUrl(model: Model<Api>): string {
  * observer 的异常被隔离，不能改变模型执行结果。
  */
 export function withProviderBoundary(
-  streamFn: StreamFn,
+  streamFn: ProviderBoundStream,
   defaultSessionId?: string,
   onGeneration?: PiGenerationLifecycleObserver,
-): StreamFn {
+): ProviderBoundStream {
   return (model, context, options) =>
     lazyStream(model, async () => {
       const requestId = crypto.randomUUID();
       const startedAt = Date.now();
       const sessionId = options?.sessionId ?? defaultSessionId;
       const url = modelRequestUrl(model);
+      const systemPrompt = "systemPrompt" in context && typeof context.systemPrompt === "string"
+        ? context.systemPrompt
+        : getCurrentSystemPrompt(context.messages);
       const notify = (event: PiGenerationLifecycleEvent) => {
         try {
           onGeneration?.(event);
@@ -516,7 +532,7 @@ export function withProviderBoundary(
         model: model.id,
         url,
         input: {
-          ...(context.systemPrompt ? { systemPrompt: context.systemPrompt } : {}),
+          ...(systemPrompt ? { systemPrompt } : {}),
           messages: context.messages,
         },
       });
@@ -708,7 +724,10 @@ function piApiFor(endpoint: RuntimeModelEndpoint): ProviderStreams {
         return openAICodexResponsesApi();
     }
   })();
-  const contextFor = (model: Model<Api>, context: Context): Context => ({
+  const contextFor = (
+    model: Model<Api>,
+    context: TranscriptContext,
+  ): TranscriptContext => ({
     ...context,
     messages: modelInputMessages(
       context.messages,
@@ -716,12 +735,12 @@ function piApiFor(endpoint: RuntimeModelEndpoint): ProviderStreams {
       adapterHostedInputModalities(protocol),
     ),
   });
-  return {
+  return overlayProviderStreams(api, {
     stream: (model, context, options) =>
       api.stream(model, contextFor(model, context), options),
     streamSimple: (model, context, options) =>
       api.streamSimple(model, contextFor(model, context), options),
-  };
+  });
 }
 
 function anthropicMessagesModelForOpenRouter(
@@ -790,6 +809,7 @@ function configuredModel(
       ? {
           compat: {
             ...anthropicMessagesCompat,
+            // OpenRouter rejects Anthropic's mid-conversation effort messages and block binding.
             supportsMidConvoEffort: false,
             supportsEagerToolInputStreaming: false,
             supportsStrictTools:
@@ -865,9 +885,11 @@ export function configurePiModels(
       models: endpoint.models.map((modelId) =>
         configuredModel(endpoint, index, modelId),
       ),
-      // cloudflareStreams 在运行时把 baseURL 里的 {CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}
-      // 占位符替换成真实值；如果 baseURL 不含占位符则直接透传，不影响现有端点。
-      api: cloudflareStreams(piApiFor(endpoint)),
+      // remapProviderStreamModels 在运行时把 baseURL 里的
+      // {CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID} 占位符替换成真实值；
+      // 如果 baseURL 不含占位符则直接透传。Pi 自带的 cloudflareStreams 只保留
+      // stream / streamSimple，这里 spread 其余方法以免丢掉 deferred 入口。
+      api: remapProviderStreamModels(piApiFor(endpoint), resolveCloudflareModel),
     })
   );
   models.clearProviders();

package/src/models/openrouter/messages.ts

@@ -1,12 +1,14 @@
 import type {
-  Context,
   Model,
   ProviderStreams,
   StreamOptions,
+  TranscriptContext,
 } from "@earendil-works/pi-ai";
+import { getCurrentTools } from "@earendil-works/pi-ai";
 import {
   anthropicMessagesApi,
 } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
+import { overlayProviderStreams } from "../provider-streams";
 
 type Payload = Record<string, unknown>;
 
@@ -21,14 +23,16 @@ function record(value: unknown): Payload | undefined {
 function decoratePayload(
   payload: unknown,
   model: Model<"anthropic-messages">,
-  context: Context,
+  context: TranscriptContext,
   sessionId?: string,
 ): unknown {
   const body = record(payload);
   if (!body) throw new Error("OpenRouter Messages payload must be an object");
 
   const deferredNames = new Set(
-    context.tools?.filter((tool) => tool.deferLoading).map((tool) => tool.name),
+    getCurrentTools(context.messages)
+      .filter((tool) => tool.deferLoading)
+      .map((tool) => tool.name),
   );
   const tools = Array.isArray(body.tools) ? body.tools : [];
   const immediate: unknown[] = [];
@@ -80,7 +84,7 @@ function decoratePayload(
 
 function openRouterOptions(
   model: Model<"anthropic-messages">,
-  context: Context,
+  context: TranscriptContext,
   options: StreamOptions | undefined,
 ): StreamOptions {
   const apiKey = options?.apiKey;
@@ -107,9 +111,10 @@ function openRouterOptions(
   };
 }
 
-export function openRouterMessagesApi(): ProviderStreams {
-  const anthropic = anthropicMessagesApi();
-  return {
+export function openRouterMessagesApi(
+  anthropic: ProviderStreams = anthropicMessagesApi(),
+): ProviderStreams {
+  return overlayProviderStreams(anthropic, {
     stream: (model, context, options) =>
       anthropic.stream(
         model,
@@ -130,5 +135,5 @@ export function openRouterMessagesApi(): ProviderStreams {
           options,
         ),
       ),
-  };
+  });
 }