agent-accelerator 0.6.0 → 0.6.6

package/src/agent/worker.ts

@@ -246,6 +246,14 @@ export function resolveWorkerCredentials(
   return { apiKeyToUse: undefined, baseUrlToUse: undefined, attemptedProvider };
 }
 
+// Configs built by `buildDynamicWorkerConfig`: the Agent constructor checks it so SDK-built workers never take `configure()` or env defaults.
+const workerConfigs = new WeakSet<object>();
+
+/** True for a config made by `buildDynamicWorkerConfig` (a chat worker or a scheduled run), not by the developer. */
+export function isWorkerConfig(config: object): boolean {
+  return workerConfigs.has(config);
+}
+
 /** How many levels of workers may exist below an agent unless `dynamicSubagents.maxDepth` says otherwise: unlimited. */
 export const DEFAULT_MAX_DEPTH = Infinity;
 
@@ -256,7 +264,7 @@ export const DEFAULT_MAX_DEPTH = Infinity;
  * `persistent` makes a multi-turn worker that keeps its history (saved under `persistent.dir` when given, and
  * continued by `resume()` after a crash, never automatically). A persistent worker with levels left below it
  * (`maxDepth` of the parent, minus one for itself) gets its own `subagents` tool; its children can only be granted
- * the tools it was granted. One-shot workers never spawn. `dynamicSubagents.workerBudget` becomes each worker's own
+ * the tools it was granted. One-shot workers never spawn. `dynamicSubagents.workerBudget` becomes each chat worker's own
  * per-run `budget` (and is passed to its children).
  */
 export function buildDynamicWorkerConfig(
@@ -274,7 +282,7 @@ export function buildDynamicWorkerConfig(
   const { apiKeyToUse, baseUrlToUse } = resolveWorkerCredentials(parent, model);
   const dyn = parent.dynamicSubagents;
   const levelsBelow = (dyn?.maxDepth ?? DEFAULT_MAX_DEPTH) - 1;
-  return {
+  const config: AgentConfig = {
     name: worker.name,
     description: worker.role || `Sub-agent ${worker.name}`,
     instructions: worker.instructions,
@@ -284,7 +292,11 @@ export function buildDynamicWorkerConfig(
     thinkingLevel: parent.dynamicSubagents?.thinkingLevel ?? parent.thinkingConfig?.level,
     sessionId: worker.sessionId,
     tools: worker.tools,
-    ...(dyn?.workerBudget ? { budget: { ...dyn.workerBudget } } : {}),
+    // A chat worker (persistent) is capped by `workerBudget`; a one-shot scheduled run only by `scheduledActionBudget`.
+    ...(() => {
+      const cap = worker.persistent ? dyn?.workerBudget : dyn?.scheduledActionBudget;
+      return cap ? { budget: { ...cap } } : {};
+    })(),
     stateless: !worker.persistent,
     ...(worker.persistent?.dir ? { persist: { dir: worker.persistent.dir }, resume: "explicit" as const } : {}),
     ...(worker.persistent && levelsBelow >= 1
@@ -305,6 +317,8 @@ export function buildDynamicWorkerConfig(
     maxTurns: parent.maxTurns,
     ...parent.inheritableConfig(),
   };
+  workerConfigs.add(config);
+  return config;
 }
 
 // ---------------------------------------------------------------------------

package/src/agent/workers.ts

@@ -23,7 +23,7 @@ import {
   type WorkerRunResult,
 } from "./delegation.ts";
 import { finishedTurns, historyUpTo, type Turn } from "./turns.ts";
-import { modelName, readUsage, type UsageNode } from "../session/usage.ts";
+import { mergeUsage, modelName, readUsage, type UsageNode } from "../session/usage.ts";
 
 /** What `spawn` needs to start a worker. */
 export interface WorkerSpec {
@@ -157,6 +157,17 @@ function readSavedWorker(dir: string | undefined): {
   return { model: session?.session.model || "unknown", totals: readUsage(session?.session.usage), workers };
 }
 
+/** What a saved session folder and every worker saved below it spent in total (read from disk): the starting point of a chat-wide usage cap after a restart; in: Agent.beginChat, out: usage totals. */
+export function savedSpend(dir: string): ReturnType<typeof readUsage> {
+  const total = readUsage(undefined);
+  const add = (node: { totals: ReturnType<typeof readUsage>; workers: UsageNode[] }): void => {
+    mergeUsage(total, node.totals);
+    for (const w of node.workers) add(w);
+  };
+  add(readSavedWorker(dir));
+  return total;
+}
+
 /** The workers of one parent `Agent` (`agent.workers`). */
 export class WorkerRegistry {
   private readonly entries = new Map<string, Entry>();
@@ -384,6 +395,7 @@ export class WorkerRegistry {
       })
     );
     (agent as unknown as { parentSessionId?: string }).parentSessionId = this.parent.sessionId;
+    agent.chat = this.parent.chat; // the worker's turns count into the chat-wide cap and are checked against it
     // A cut-off run was already loaded by the constructor; otherwise bring back what the worker said so far.
     const saved = entry.dir && agent.context.messages.length === 0 ? loadSessionDir(entry.dir)?.session : undefined;
     if (saved) agent.importSession(saved);

package/src/architecture.md

@@ -15,6 +15,7 @@ The whole SDK. `index.ts` is the only public entry (`main`/`module`/`types`); ev
 | `tools/`            | `tool()`, schemas, the executor.                                                                                                                                            |
 | `streaming/`        | The event stream and the SSE parser.                                                                                                                                        |
 | `session/`          | Persistence (snapshot + journal), usage accounting, tool logs.                                                                                                              |
+| `prompts/`          | The SDK's own prompts as `.md` files, `DEFAULT_PROMPTS`, `AgentConfig.prompts`.                                                                                             |
 | `scheduler/`        | Scheduled actions.                                                                                                                                                          |
 | `types/`            | Shared contracts (no logic except small helpers).                                                                                                                           |
 | `utils/`            | Small shared helpers (durable writes, home, env, media, retry, safe I/O).                                                                                                   |

package/src/index.ts

@@ -31,6 +31,10 @@ export {
 } from "./tools/tool.ts";
 export type { CreateToolOptions } from "./tools/tool.ts";
 export { zodToJsonSchema, cleanJsonSchema } from "./tools/schema.ts";
+export { toolContent } from "./tools/tool-content.ts";
+export { DEFAULT_PROMPTS } from "./prompts/prompts.ts";
+export type { PromptName, PromptOverrides } from "./prompts/prompts.ts";
+export type { ToolContent, ToolContentPart } from "./tools/tool-content.ts";
 /**
  * @deprecated Internal executor surface. Prefer `Agent` runs; for direct
  * execution import from the future `/internal` entry.
@@ -60,17 +64,12 @@ export {
 export type { AgentAsToolTarget, SubAgentTrace } from "./agent/delegation.ts";
 export type { WorkerRegistry, WorkerSpec, WorkerInfo, WorkerReply, WorkerCallOptions } from "./agent/workers.ts";
 
-// Scheduled actions: dynamic sub-agents that run later and save their answer to a file
-export {
-  createScheduledAction,
-  listScheduledActions,
-  updateScheduledAction,
-  runScheduledAction,
-  skipScheduledAction,
-  deleteScheduledAction,
-} from "./scheduler/scheduler.ts";
+// Scheduled actions: dynamic sub-agents that run later and save their answer to a file (use `agent.scheduled`)
+export type { ScheduledActions } from "./scheduler/scheduler.ts";
 export { getDatetimeTool } from "./scheduler/tool.ts";
 export { setHome, resolveHome } from "./utils/home.ts";
+export { configure } from "./agent/defaults.ts";
+export type { AgentDefaults } from "./agent/defaults.ts";
 export type {
   ScheduledActionInput,
   ScheduledActionPatch,
@@ -116,7 +115,7 @@ export {
   type CatalogStatus,
   type RefreshCatalogOptions,
 } from "./models/catalog.ts";
-export { resolveEffectiveThinking } from "./agent/agent.ts";
+export { resolveEffectiveThinking } from "./agent/options.ts";
 export { withRetries, isTransientError } from "./utils/retry.ts";
 export { toConciseProviderError, assertModalitiesSupported, assertNoVideoPartsOnResponses } from "./utils/errors.ts";
 // Native provider implementations.
@@ -223,7 +222,7 @@ export {
 } from "./types/errors.ts";
 export type { AgentAccelErrorCode, AgentAccelErrorContext } from "./types/errors.ts";
 // Normalized run limits (sub-agents inherit unless overridden)
-export type { AgentRunLimits } from "./agent/agent.ts";
+export type { AgentRunLimits } from "./agent/options.ts";
 
 // Telemetry bus: warnings, anomalies and per-turn thinking traces (attach with `telemetryBus.onEvent`)
 export { telemetryBus } from "./telemetry.ts";
@@ -323,6 +322,7 @@ export type {
   ProviderContext,
   ProviderSteps,
   MediaResolution,
+  VideoProcessing,
 } from "./types/message.ts";
 
 export type {

package/src/prompts/additional-context.md

@@ -0,0 +1,2 @@
+[Additional Context]
+{{context}}

package/src/prompts/architecture.md

@@ -0,0 +1,19 @@
+# src/prompts/
+
+The prompts the SDK itself puts in front of the model, as plain `.md` files, so they can be read, copied and replaced.
+
+| File                                                                                                                        | What it is                                                                                                                                                                         |
+| :-------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `prompts.ts`                                                                                                                | `DEFAULT_PROMPTS` (the shipped text, read once at load, final newline removed), `resolvePrompts` (defaults + `AgentConfig.prompts`, validated), `fillPrompt` (`{{name}}` markers). |
+| `reasoning-directive.md`, `structured-output.md`, `additional-context.md`, `tool-bridge.md`                                 | Text added to the system prompt, a user turn or a history gap.                                                                                                                     |
+| `tool-truncated-arguments.md`, `tool-not-found.md`, `tool-schema-error.md`, `tool-repeat-blocked.md`, `tool-interrupted.md` | The refusals the executor and the loop send back as tool results.                                                                                                                  |
+| `worker-replied.md`, `worker-failed.md`                                                                                     | The header of a `subagents` answer.                                                                                                                                                |
+| `subagents-tool.md`, `scheduled-actions-tool.md`                                                                            | The manuals that are the descriptions of the `subagents` and `scheduled_actions` tools.                                                                                            |
+
+## Invariants
+
+- One file per prompt; the name in `FILES` (`prompts.ts`) is the public name. Add a prompt by adding a file, a `FILES` entry, its use, a row in `docs/guides/prompts.md` and a pinned-text assertion in `test/prompts.test.ts`.
+- The default text is pinned exactly by a test: reflowing a file (an editor or formatter) changes what the model sees and the prompt cache, so the test must fail.
+- Every user of a prompt reads it from the Agent's resolved prompts (`agent.prompts`, `loop` config `prompts`, `ProviderRequestOptions.prompts`, executor `prompts`), never from `DEFAULT_PROMPTS` directly, except as the default of an optional parameter.
+- Machine-readable parts stay in code: the `repeat_blocked` `errorCode`, the `[Structured Output]` marker line.
+- The system prompt carries no delegation text (cache-stable): tool manuals are tool descriptions.

package/src/prompts/prompts.ts

@@ -0,0 +1,81 @@
+/**
+ * The prompts the SDK itself puts in front of the model, kept as `.md` files in this folder so they can be read,
+ * copied and replaced. `DEFAULT_PROMPTS` holds the shipped text; `AgentConfig.prompts` overrides single entries per
+ * Agent. Keeping the original is recommended: it is what the SDK was tested with, and a good starting point (and the
+ * reference) for writing your own. `{{name}}` marks a value the SDK fills in at use time.
+ */
+import { readFileSync } from "node:fs";
+import { ConfigError } from "../types/errors.ts";
+
+/** One entry per prompt file: its public name and the file that holds the default text. */
+const FILES = {
+  reasoningDirective: "reasoning-directive.md",
+  structuredOutput: "structured-output.md",
+  additionalContext: "additional-context.md",
+  toolBridge: "tool-bridge.md",
+  toolTruncatedArguments: "tool-truncated-arguments.md",
+  toolNotFound: "tool-not-found.md",
+  toolSchemaError: "tool-schema-error.md",
+  toolRepeatBlocked: "tool-repeat-blocked.md",
+  toolInterrupted: "tool-interrupted.md",
+  workerReplied: "worker-replied.md",
+  workerFailed: "worker-failed.md",
+  subagentsTool: "subagents-tool.md",
+  scheduledActionsTool: "scheduled-actions-tool.md",
+} as const;
+
+/** The name of one SDK prompt (see `DEFAULT_PROMPTS`). */
+export type PromptName = keyof typeof FILES;
+
+/** The text of every prompt, by name. */
+export type Prompts = Record<PromptName, string>;
+
+/** Per-Agent replacements for single prompts (`AgentConfig.prompts`); every other prompt keeps its default. */
+export type PromptOverrides = Partial<Prompts>;
+
+// Reads one prompt file without its final newline; in: DEFAULT_PROMPTS at load, out: the default text.
+function readPrompt(file: string): string {
+  return readFileSync(new URL(`./${file}`, import.meta.url), "utf8").replace(/\n$/, "");
+}
+
+/**
+ * The prompts as shipped. Placeholders (`{{name}}`) are filled in by the SDK: `reasoningDirective` none;
+ * `structuredOutput` `{{schema}}`; `additionalContext` `{{context}}`; `toolTruncatedArguments`, `toolRepeatBlocked`
+ * `{{tool}}`; `toolNotFound` `{{tool}}`, `{{suggestion}}`; `toolSchemaError` `{{tool}}`, `{{detail}}`, `{{keys}}`,
+ * `{{expected}}`; `toolInterrupted` `{{tool}}`, `{{id}}`; `workerReplied` `{{id}}`, `{{text}}`; `workerFailed` `{{id}}`,
+ * `{{reason}}`; `subagentsTool` `{{TOOLS}}`, `{{LIMIT}}`; `scheduledActionsTool` `{{TOOLS}}`.
+ */
+export const DEFAULT_PROMPTS: Readonly<Prompts> = Object.freeze(
+  Object.fromEntries(Object.entries(FILES).map(([name, file]) => [name, readPrompt(file)])) as Prompts
+);
+
+/** Defaults with `overrides` applied. Throws a `ConfigError` for an unknown name or an empty or non-string text. */
+export function resolvePrompts(overrides?: PromptOverrides): Prompts {
+  const out: Prompts = { ...DEFAULT_PROMPTS };
+  if (overrides === undefined) return out;
+  if (!overrides || typeof overrides !== "object" || Array.isArray(overrides)) {
+    throw new ConfigError(
+      '[Agent Accelerator] Invalid prompts: expected an object like { reasoningDirective: "..." } (see DEFAULT_PROMPTS for the names).'
+    );
+  }
+  for (const [name, text] of Object.entries(overrides)) {
+    if (text === undefined) continue;
+    if (!Object.hasOwn(FILES, name)) {
+      throw new ConfigError(
+        `[Agent Accelerator] Unknown prompt "${name}". Valid names: ${Object.keys(FILES).join(", ")}.`
+      );
+    }
+    if (typeof text !== "string" || !text.trim()) {
+      throw new ConfigError(`[Agent Accelerator] Invalid prompt "${name}": expected a non-empty string.`);
+    }
+    out[name as PromptName] = text;
+  }
+  return out;
+}
+
+/** Fills `{{name}}` markers in a prompt from `values`; a marker with no value is left as written. */
+export function fillPrompt(template: string, values: Record<string, string | number>): string {
+  return template.replace(/\{\{(\w+)\}\}/g, (whole, key: string) =>
+    Object.hasOwn(values, key) ? String(values[key]) : whole
+  );
+}

package/src/prompts/reasoning-directive.md

@@ -0,0 +1,5 @@
+[Reasoning Directive]
+
+1. Use internal reasoning strictly for private planning and step-by-step thinking.
+2. Never attempt to execute tools or output final user deliverables inside reasoning.
+3. Once your reasoning is complete, output your final response or function calls directly in the standard response output.

package/src/prompts/structured-output.md

@@ -0,0 +1,2 @@
+Return ONLY valid JSON matching this JSON Schema, with no markdown fences, no commentary, no extra text.
+Schema: {{schema}}

package/src/prompts/tool-bridge.md

@@ -0,0 +1 @@
+I have processed the tool results.

package/src/prompts/tool-interrupted.md

@@ -0,0 +1 @@
+Error: tool_call '{{tool}}' ({{id}}) has no result because the run was interrupted before it completed (recovered by ensureToolPairing). It may have partially executed: check the tool trace before repeating side-effecting work.

package/src/prompts/tool-not-found.md

@@ -0,0 +1 @@
+Error: Tool '{{tool}}' not found.{{suggestion}}

package/src/prompts/tool-repeat-blocked.md

@@ -0,0 +1 @@
+repeat_blocked: Tool '{{tool}}' was called again with identical arguments. The previous result is already available; reuse it or call the tool with different arguments.

package/src/prompts/tool-schema-error.md

@@ -0,0 +1 @@
+Schema validation error for tool '{{tool}}': {{detail}} Received argument keys: [{{keys}}].{{expected}} Fix the arguments and call the tool again with corrected JSON. Do not explain the error, just retry the call.

package/src/prompts/tool-truncated-arguments.md

@@ -0,0 +1 @@
+Error: Tool '{{tool}}' arguments are truncated or incomplete and could not be parsed. Call the tool again with the complete JSON arguments. Do not explain the error, just retry the call.

package/src/prompts/worker-failed.md

@@ -0,0 +1 @@
+[worker {{id}}] failed: {{reason}}

package/src/prompts/worker-replied.md

@@ -0,0 +1,2 @@
+[worker {{id}}] replied:
+{{text}}

package/src/providers/architecture.md

@@ -2,14 +2,14 @@
 
 All HTTP and wire parsing. Canonical mappers (thinking, cache, tool choice, structured output) live in `../providers.ts`, never here.
 
-| File               | Wire                               | Notes                                                                                                                                                                                       |
-| :----------------- | :--------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `google.ts`        | Google Interactions                | Stateful chaining (TTL gate, self-heal on `not_found`), exact replay of raw `steps`, media consts at the top, Gemini 4 long decode as background interactions.                              |
-| `openai.ts`        | OpenAI Responses                   | Stateless (`store:false`), full history every turn.                                                                                                                                         |
-| `openrouter.ts`    | OpenRouter Chat Completions        | Every request streams (so it can be cancelled); `generate()` collects its own stream.                                                                                                       |
-| `openai-compat.ts` | OpenAI-compatible Chat Completions | Serves every custom prefix; strict subset of fields; no default base URL.                                                                                                                   |
-| `registry.ts`      | -                                  | Routes `provider/model` to an adapter; the registry is immutable; `ModelProvider` helpers.                                                                                                  |
-| `shared.ts`        | -                                  | Helpers every adapter uses: signals and timers, error payloads, ids, retry-after, SSE scaffold (`linkStreamAbort`, `withAbortTimer`, `readSseData`, `incompleteStreamCheck`, `failStream`). |
+| File               | Wire                               | Notes                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| :----------------- | :--------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `google.ts`        | Google Interactions                | Stateful chaining (TTL gate, self-heal on `not_found`), exact replay of raw `steps`, media consts at the top, Gemini 4 long decode as background interactions. The inline size checks (`assertGoogleInlineSizes`) exist but are not called yet. A video part's `processing` (`static`/`agentic`) is sent as the block's `processing` field.                                                                                        |
+| `openai.ts`        | OpenAI Responses                   | Stateless (`store:false`), full history every turn.                                                                                                                                                                                                                                                                                                                                                                                |
+| `openrouter.ts`    | OpenRouter Chat Completions        | Every request streams (so it can be cancelled); `generate()` collects its own stream. A turn's `reasoning_details` blocks are kept as `providerSteps` and sent back verbatim on the next request; parsed-PDF `file` annotations travel the same way, so a PDF is not parsed twice. Routing, `parallel_tool_calls`, `reasoning.exclude` and `user` come from `OPENROUTER_*` env vars (see the file header), never from AgentConfig. |
+| `openai-compat.ts` | OpenAI-compatible Chat Completions | Serves every custom prefix; strict subset of fields; no default base URL.                                                                                                                                                                                                                                                                                                                                                          |
+| `registry.ts`      | -                                  | Routes `provider/model` to an adapter; the registry is immutable; `ModelProvider` helpers.                                                                                                                                                                                                                                                                                                                                         |
+| `shared.ts`        | -                                  | Helpers every adapter uses: signals and timers, error payloads, ids, retry-after, SSE scaffold (`linkStreamAbort`, `withAbortTimer`, `readSseData`, `incompleteStreamCheck`, `failStream`).                                                                                                                                                                                                                                        |
 
 ## Contract (`Provider`, in `../types/model.ts`)
 

package/src/providers/google.ts

@@ -29,7 +29,14 @@ import type {
   ProviderGenerateResult,
   ProviderRawData,
 } from "../types/model.ts";
-import type { ProviderContext, ContentPart, ProviderSteps, ToolResultPart, MediaResolution } from "../types/message.ts";
+import type {
+  ProviderContext,
+  ContentPart,
+  ProviderSteps,
+  ToolResultPart,
+  MediaResolution,
+  VideoProcessing,
+} from "../types/message.ts";
 import type { StandardToolDeclaration, ToolCallRecord } from "../types/tool.ts";
 import type { TokenUsage } from "../types/core.ts";
 import { AssistantMessageEventStream } from "../streaming/event-stream.ts";
@@ -156,7 +163,8 @@ export const GOOGLE_INLINE_MIME_ALIASES: Readonly<Record<string, string>> = {
   "audio/wave": "audio/wav",
   "image/jpg": "image/jpeg",
 };
-// Documented size limits. Not enforced yet: oversized inputs get Google's own error.
+// Documented size limits (file-input-methods.md). `assertGoogleInlineSizes` below checks them, but it is NOT called yet:
+// the owner is not sure how Files API uploads should be handled, so oversized inputs still get Google's own error for now.
 /** Max inline payload per request (bytes). */
 export const GOOGLE_MAX_INLINE_REQUEST_BYTES = 100 * 1024 * 1024;
 /** Max inline PDF size (bytes). */
@@ -217,7 +225,8 @@ const INLINE_MIME: Record<MediaBlockType, readonly string[]> = {
   document: GOOGLE_DOCUMENT_MIME,
 };
 
-const FILES_API_PREFIX = "https://generativelanguage.googleapis.com/v1beta/files/";
+// A Google Files API link on either API version (`/v1/files/<id>` or `/v1beta/files/<id>`); the host is exact, so no other URL counts.
+const FILES_API_URL = /^https:\/\/generativelanguage\.googleapis\.com\/v1(?:beta)?\/files\/[^/\s]+/;
 const YOUTUBE_URL = /^https:\/\/(www\.|m\.)?(youtube\.com|youtu\.be)\//i;
 
 // ---------------------------------------------------------------------------
@@ -230,6 +239,7 @@ type MediaBlock = {
   data?: string;
   uri?: string;
   resolution?: MediaResolution;
+  processing?: VideoProcessing;
 };
 type InteractionContentBlock = { type: "text"; text: string } | MediaBlock;
 
@@ -499,7 +509,7 @@ function uriBlock(type: MediaBlockType, value: string, mimeType?: string): Media
   const withMime = (mime?: string): MediaBlock => ({ type, uri: value, ...(mime ? { mime_type: mime } : {}) });
   if (type === "video" && YOUTUBE_URL.test(value)) return withMime(explicit);
   const mime = explicit ?? bareMime(inferMimeType(value, ""));
-  if (value.startsWith(FILES_API_PREFIX) || value.startsWith("gs://")) return withMime(mime);
+  if (FILES_API_URL.test(value) || value.startsWith("gs://")) return withMime(mime);
   return value.startsWith("https://") && mime && (GOOGLE_URL_MIME as readonly string[]).includes(mime)
     ? withMime(mime)
     : undefined;
@@ -535,11 +545,63 @@ async function contentPartsToBlocks(parts: ContentPart[]): Promise<InteractionCo
     const block = uri ?? (await inlineBlock(type, value, part.mimeType));
     // Per-item detail level (image and video blocks only, api-ref `MediaResolution`).
     const resolution = part.type === "image" || part.type === "video" ? part.resolution : undefined;
-    blocks.push(resolution ? { ...block, resolution } : block);
+    // Per-video processing mode (`static` | `agentic`, api-ref `MediaProcessing`): the model may then add `processing_call` / `processing_result` steps, which the raw-steps replay keeps like any other step.
+    const processing = part.type === "video" ? part.processing : undefined;
+    if (processing !== undefined && processing !== "static" && processing !== "agentic")
+      throw new ValidationError(
+        `[Agent Accelerator] Invalid video processing ${JSON.stringify(processing)}: expected "static" or "agentic".`
+      );
+    blocks.push({ ...block, ...(resolution ? { resolution } : {}), ...(processing ? { processing } : {}) });
   }
   return blocks;
 }
 
+// Decoded size in bytes of a base64 string, without decoding it; in: assertGoogleInlineSizes, out: a byte count.
+function base64Bytes(b64: string): number {
+  const clean = b64.replace(/\s/g, "");
+  const padding = clean.endsWith("==") ? 2 : clean.endsWith("=") ? 1 : 0;
+  return Math.max(0, Math.floor((clean.length * 3) / 4) - padding);
+}
+
+// Every inline media block (`data` + `mime_type`) found anywhere in a request `input`, including blocks inside steps and function results; in: assertGoogleInlineSizes, out: the blocks.
+function inlineBlocks(
+  value: unknown,
+  out: Array<{ mime?: string; bytes: number }> = []
+): Array<{ mime?: string; bytes: number }> {
+  if (Array.isArray(value)) {
+    for (const v of value) inlineBlocks(v, out);
+  } else if (value && typeof value === "object") {
+    const o = value as Record<string, unknown>;
+    if (typeof o["data"] === "string" && typeof o["mime_type"] === "string")
+      out.push({ mime: bareMime(o["mime_type"]), bytes: base64Bytes(o["data"]) });
+    else for (const v of Object.values(o)) inlineBlocks(v, out);
+  }
+  return out;
+}
+
+/**
+ * Fails before the network when the inline media of one request is over Google's documented limits: 100 MB in total and
+ * 50 MB for each PDF (larger files go through the Files API). Counts decoded bytes, over the whole `input` (the full
+ * history on a reseed). NOT called by the adapter yet (see the call sites in `generate` and `stream`).
+ */
+export function assertGoogleInlineSizes(input: unknown, modelId: string): void {
+  const blocks = inlineBlocks(input);
+  const mb = (n: number): string => `${(n / (1024 * 1024)).toFixed(1)} MB`;
+  for (const b of blocks) {
+    if (b.mime === "application/pdf" && b.bytes > GOOGLE_MAX_INLINE_PDF_BYTES) {
+      throw new ValidationError(
+        `[Agent Accelerator] [google/${modelId}] A PDF of ${mb(b.bytes)} is over Google's ${mb(GOOGLE_MAX_INLINE_PDF_BYTES)} limit for inline PDFs. Upload it with the Files API and pass its link instead.`
+      );
+    }
+  }
+  const total = blocks.reduce((n, b) => n + b.bytes, 0);
+  if (total > GOOGLE_MAX_INLINE_REQUEST_BYTES) {
+    throw new ValidationError(
+      `[Agent Accelerator] [google/${modelId}] The inline media of this request is ${mb(total)}, over Google's ${mb(GOOGLE_MAX_INLINE_REQUEST_BYTES)} limit per request. Upload the large files with the Files API and pass their links instead.`
+    );
+  }
+}
+
 // Keeps a turn's model-generated steps exactly as received (input echoes and empty signatures dropped); in: REST `steps` or assembled stream steps, out: ProviderGenerateResult.providerSteps.
 function replaySteps(steps: unknown[] | undefined): ProviderSteps | undefined {
   const kept = (steps ?? [])
@@ -575,13 +637,14 @@ function resultToText(result: unknown): string {
   return safeStringify(result);
 }
 
-// Builds the documented `function_result` step (`is_error` only when the tool failed); in: a canonical tool_result part, out: chained or full-history `input`.
-function functionResultStep(part: ToolResultPart): InteractionInputStep {
+// Builds the documented `function_result` step (`is_error` only when the tool failed); text first, then the media the tool returned with `toolContent` (Gemini 3 accepts image and document blocks in `result`); in: a canonical tool_result part, out: chained or full-history `input`.
+async function functionResultStep(part: ToolResultPart): Promise<InteractionInputStep> {
+  const media = part.parts && part.parts.length > 0 ? await contentPartsToBlocks(part.parts) : [];
   return {
     type: "function_result",
     name: part.name,
     call_id: part.id,
-    result: [{ type: "text", text: resultToText(part.result) }],
+    result: [{ type: "text", text: resultToText(part.result) }, ...media],
     ...(part.isError ? { is_error: true } : {}),
   };
 }
@@ -625,7 +688,7 @@ async function latestTurnInput(
       if (!Array.isArray(m.content)) continue;
       for (const part of m.content) {
         if (part.type === "tool_result") {
-          steps.push(functionResultStep(part));
+          steps.push(await functionResultStep(part));
         }
       }
     } else if (m.role === "user") {
@@ -715,7 +778,7 @@ async function fullHistorySteps(context: ProviderContext): Promise<InteractionIn
       if (!Array.isArray(m.content)) continue;
       for (const part of m.content) {
         if (part.type === "tool_result") {
-          steps.push(functionResultStep(part));
+          steps.push(await functionResultStep(part));
         }
       }
     }
@@ -901,7 +964,11 @@ export class GoogleInteractionsProvider implements Provider {
       let effectiveSystemPrompt = context.systemPrompt;
       if (outputSpec && !modelSupportsStructuredOutput("google", modelId)) {
         outputEmulated = true;
-        effectiveSystemPrompt = augmentSystemPromptWithStructuredOutput(context.systemPrompt, outputSpec);
+        effectiveSystemPrompt = augmentSystemPromptWithStructuredOutput(
+          context.systemPrompt,
+          outputSpec,
+          options?.prompts?.structuredOutput
+        );
         emitProviderWarning({
           provider: "google",
           capability: "structured output",
@@ -1108,6 +1175,8 @@ export class GoogleInteractionsProvider implements Provider {
     const sessionId = options?.sessionId;
     const tools = options?.tools as StandardToolDeclaration[] | undefined;
     let body = await this.buildBody(clean, context, options, sessionId, tools, false);
+    // Size limits are implemented but switched off for now (the owner is unsure about Files API handling yet):
+    // assertGoogleInlineSizes(body.input, clean);
 
     const makeRawRequest = (b: InteractionRequestBody): ProviderRawData["request"] => ({
       url,
@@ -1220,6 +1289,8 @@ export class GoogleInteractionsProvider implements Provider {
         const sessionId = options?.sessionId;
         const tools = options?.tools as StandardToolDeclaration[] | undefined;
         const body = await this.buildBody(clean, context, options, sessionId, tools, true);
+        // Size limits are implemented but switched off for now (the owner is unsure about Files API handling yet):
+        // assertGoogleInlineSizes(body.input, clean);
         evictSessionId = sessionId;
         usedChain = body.previous_interaction_id !== undefined;
 
@@ -1488,8 +1559,7 @@ export class GoogleInteractionsProvider implements Provider {
         // (JSON mocks) where no SSE frames were ever seen.
         const hasTerminal = completedBody !== undefined || sawFinishReason || sawUsage;
         // Trim provider trailing blank lines from finalized thinking (live
-        // deltas already emitted raw; display collapse happens in the
-        // wrapThinking presentation layer). Stateful bodies unaffected.
+        // deltas already emitted raw). Stateful bodies unaffected.
         const cleanThinkingEarly = thinking.replace(/\n{3,}/g, "\n\n").trim();
         const ctEntry = Object.entries(responseHeaders).find(([k]) => k.toLowerCase() === "content-type");
         const isSSEPayload =

package/src/providers/openai-compat.ts

@@ -60,6 +60,7 @@ import { safeStringify } from "../utils/serialization.ts";
 import { toConciseProviderError, assertModalitiesSupported } from "../utils/errors.ts";
 import { withRetries } from "../utils/retry.ts";
 import { ConfigError, ValidationError } from "../types/errors.ts";
+import { DEFAULT_PROMPTS } from "../prompts/prompts.ts";
 import {
   parseArguments,
   normalizeThinkingParts,
@@ -96,6 +97,8 @@ import {
   normalizeStructuredOutput,
   augmentSystemPromptWithStructuredOutput,
   warnIgnoredMediaResolution,
+  warnIgnoredVideoProcessing,
+  warnIgnoredToolMedia,
 } from "../providers.ts";
 
 // ---------------------------------------------------------------------------
@@ -402,7 +405,10 @@ function resultToOutput(result: unknown): string {
  * `google` (or untagged legacy). Signatures minted by other providers never
  * leak onto this transport.
  */
-async function fullHistoryMessages(context: ProviderContext): Promise<ChatMessage[]> {
+async function fullHistoryMessages(
+  context: ProviderContext,
+  bridge = DEFAULT_PROMPTS.toolBridge
+): Promise<ChatMessage[]> {
   const pairing = new Map<string, string>();
   for (const m of context.messages) {
     if (m.role === "assistant" && Array.isArray(m.content)) {
@@ -423,7 +429,7 @@ async function fullHistoryMessages(context: ProviderContext): Promise<ChatMessag
     if (m.role === "system") continue;
     if (m.role === "user") {
       if (lastRole === "tool") {
-        messages.push({ role: "assistant", content: "I have processed the tool results." });
+        messages.push({ role: "assistant", content: bridge });
       }
       if (typeof m.content === "string") {
         if (m.content) {
@@ -725,6 +731,8 @@ export class OpenAICompatibleChatProvider implements Provider {
     // Strict endpoints reject unknown body fields: implicit caching only.
     resolveCache(this.prefix, options?.cache, ["implicit"], `${this.prefix}/${modelId}`);
     warnIgnoredMediaResolution(this.prefix, context.messages, `${this.prefix}/${modelId}`);
+    warnIgnoredVideoProcessing(this.prefix, context.messages, `${this.prefix}/${modelId}`);
+    warnIgnoredToolMedia(this.prefix, context.messages, `${this.prefix}/${modelId}`);
 
     // Structured outputs: native `response_format` when supported, else
     // emulated via system prompt (strict endpoints would 400 on json_schema
@@ -741,7 +749,11 @@ export class OpenAICompatibleChatProvider implements Provider {
       outputEmulated = true;
       effectiveContext = {
         ...context,
-        systemPrompt: augmentSystemPromptWithStructuredOutput(context.systemPrompt, outputSpec),
+        systemPrompt: augmentSystemPromptWithStructuredOutput(
+          context.systemPrompt,
+          outputSpec,
+          options?.prompts?.structuredOutput
+        ),
       };
       emitProviderWarning({
         provider: this.prefix,
@@ -752,7 +764,7 @@ export class OpenAICompatibleChatProvider implements Provider {
         fallback: "emulated JSON instruction + client validation (no response_format is sent)",
       });
     }
-    const messages = await fullHistoryMessages(effectiveContext);
+    const messages = await fullHistoryMessages(effectiveContext, options?.prompts?.toolBridge);
     const body: ChatRequestBody = {
       model: modelId,
       messages,
@@ -762,9 +774,7 @@ export class OpenAICompatibleChatProvider implements Provider {
     if (compatTools) body.tools = compatTools;
     // Standard Chat Completions generation fields, only when the caller set them.
     Object.assign(body, mapGenerationParamsToChat(options));
-    const toolChoice = mapToolChoiceToOpenAI(
-      options?.toolChoice as "auto" | "none" | "required" | { type: "function"; function: { name: string } } | undefined
-    );
+    const toolChoice = mapToolChoiceToOpenAI(options?.toolChoice, this.prefix);
     if (toolChoice !== undefined) {
       // Chat Completions nests pinned names under `function`; the canonical
       // mapper emits the flat Responses shape, so normalize here.