@agent-native/core 0.161.14 → 0.161.17

package/corpus/templates/slides/server/handlers/request-auth-context.ts

@@ -7,10 +7,36 @@ export interface SlidesRequestAuthContext {
   orgId?: string;
 }
 
+/**
+ * A session lookup that failed outright (DB blip, cookie race) — distinct
+ * from `getSession` resolving to `null`, which means "no session" and is a
+ * legitimate outcome for anonymous callers (public share/deck viewers).
+ * `getSession` only throws on a real backend failure, never merely because a
+ * request carries no session cookie, so this never fires for genuine
+ * anonymous access. Previously this was swallowed into the same
+ * `email: undefined` an anonymous visitor gets, so a transient failure
+ * presented as "unauthorized" on the upload path and as an untraceable error
+ * on deck creation — see `resolveSlidesRequestAuth` for the caller-facing
+ * shape.
+ */
+export class SlidesSessionLookupError extends Error {
+  readonly statusCode = 503;
+  constructor(cause: unknown) {
+    super("Could not verify your session. Please try again.");
+    this.name = "SlidesSessionLookupError";
+    this.cause = cause;
+  }
+}
+
 export async function resolveSlidesRequestAuthContext(
   event: H3Event,
 ): Promise<SlidesRequestAuthContext> {
-  const session = await getSession(event).catch(() => null);
+  let session: Awaited<ReturnType<typeof getSession>>;
+  try {
+    session = await getSession(event);
+  } catch (err) {
+    throw new SlidesSessionLookupError(err);
+  }
 
   // Prefer the live active org context over `session.orgId`. Better Auth's
   // session.orgId is set at sign-in and not refreshed when the user switches
@@ -39,6 +65,37 @@ export async function resolveSlidesRequestAuthContext(
   };
 }
 
+/** Discriminated result for route handlers that must fail closed on a
+ * session-lookup error rather than treat it as "logged out". */
+export type SlidesRequestAuthResolution =
+  | { ok: true; context: SlidesRequestAuthContext }
+  | { ok: false; statusCode: number; error: string };
+
+/**
+ * Like `resolveSlidesRequestAuthContext`, but turns a `SlidesSessionLookupError`
+ * into a response the caller can return directly instead of a 401 — so a
+ * route handler that gates on `!context.email` never mistakes "the session
+ * lookup failed" for "this visitor is signed out". A route with legitimate
+ * anonymous access (e.g. a public deck view) still gets `email: undefined`
+ * for real anonymous callers via `ok: true`; only a genuine lookup failure
+ * takes the `ok: false` branch.
+ */
+export async function resolveSlidesRequestAuth(
+  event: H3Event,
+): Promise<SlidesRequestAuthResolution> {
+  try {
+    return { ok: true, context: await resolveSlidesRequestAuthContext(event) };
+  } catch (err) {
+    return {
+      ok: false,
+      statusCode:
+        err instanceof SlidesSessionLookupError ? err.statusCode : 500,
+      error:
+        err instanceof Error ? err.message : "Failed to verify your session.",
+    };
+  }
+}
+
 export async function withSlidesRequestContext<T>(
   event: H3Event,
   fn: (session: SlidesRequestAuthContext) => Promise<T>,

package/corpus/templates/slides/server/handlers/share.ts

@@ -18,7 +18,7 @@ import { defineEventHandler, getRouterParam, setResponseStatus } from "h3";
 
 import { getDb, schema } from "../db";
 import {
-  resolveSlidesRequestAuthContext,
+  resolveSlidesRequestAuth,
   withSlidesRequestContext,
 } from "./request-auth-context.js";
 
@@ -47,7 +47,12 @@ export const shareDeck = defineEventHandler(async (event) => {
   // and pass the resolved context into `withSlidesRequestContext` so it
   // doesn't re-resolve session + org on the same request (which would
   // double the session/getOrgContext I/O per share).
-  const session = await resolveSlidesRequestAuthContext(event);
+  const auth = await resolveSlidesRequestAuth(event);
+  if (!auth.ok) {
+    setResponseStatus(event, auth.statusCode);
+    return { error: auth.error };
+  }
+  const session = auth.context;
   if (!session.email) {
     setResponseStatus(event, 401);
     return { error: "Unauthorized" };

package/corpus/templates/slides/server/handlers/uploads.ts

@@ -21,7 +21,7 @@ import {
 } from "../lib/uploaded-reference-storage.js";
 import { canSaveAsUploadedAsset, uploadImageAsset } from "./assets.js";
 import {
-  resolveSlidesRequestAuthContext,
+  resolveSlidesRequestAuth,
   withSlidesRequestContext,
 } from "./request-auth-context.js";
 
@@ -211,7 +211,12 @@ export async function saveUploadedReferenceFile(args: {
 
 // Upload one or more files
 export const uploadFiles = defineEventHandler(async (event) => {
-  const authContext = await resolveSlidesRequestAuthContext(event);
+  const auth = await resolveSlidesRequestAuth(event);
+  if (!auth.ok) {
+    setResponseStatus(event, auth.statusCode);
+    return { error: auth.error };
+  }
+  const authContext = auth.context;
   const email = authContext.email;
   if (!email) {
     setResponseStatus(event, 401);

package/dist/action.d.ts

@@ -706,6 +706,7 @@ export interface ActionDefinition<TInput, TReturn> {
  */
 export declare function defineAction<TSchema extends StandardSchemaV1, TReturn, TOutputSchema extends StandardSchemaV1 | undefined = undefined>(options: DefineActionWithSchema<TSchema, TReturn, TOutputSchema>): ActionDefinition<StandardSchemaV1.InferInput<TSchema>, TReturn>;
 export declare function defineAction<TParams extends Record<string, ParameterSchema> | undefined, TReturn>(options: DefineActionWithParams<TParams, TReturn>): ActionDefinition<InferParams<TParams>, TReturn>;
+export declare function stripUnsupportedSchemaKeywords<T>(node: T): T;
 /**
  * Compact signature of an action's parameters, e.g.
  * `{ deckId*: string, operation*: "edit"|"replace", slideId?: string }` where

package/dist/action.js

@@ -393,7 +393,7 @@ const TYPE_SUBSTITUTE_KEYS = [
     "$ref",
     "not",
 ];
-function stripUnsupportedSchemaKeywords(node) {
+export function stripUnsupportedSchemaKeywords(node) {
     if (!node || typeof node !== "object" || Array.isArray(node))
         return node;
     const obj = node;

package/dist/agent/engine/translate-anthropic.js

@@ -343,6 +343,11 @@ function enginePartToAnthropic(part, builderGateway) {
             };
         }
         case "thinking":
+            // A redacted block has no readable thinking or signature — only its
+            // encrypted payload, which Anthropic requires back unmodified.
+            if (part.redactedData) {
+                return { type: "redacted_thinking", data: part.redactedData };
+            }
             // Anthropic thinking blocks — pass through with signature for context window continuity
             return {
                 type: "thinking",
@@ -409,7 +414,20 @@ export function anthropicContentToEngine(content) {
                 signature: b.signature,
             };
         }
-        // Unknown block type — skip
+        if (block.type === "redacted_thinking") {
+            // Dropping this looked like "skip an unreadable block", but Anthropic
+            // requires the whole thinking sequence back verbatim within a tool-use
+            // turn: losing it makes the very next loop iteration send an assistant
+            // turn the API refuses, from a turn that streamed perfectly.
+            return {
+                type: "thinking",
+                text: "",
+                redactedData: block.data ?? "",
+            };
+        }
+        // Unknown block type. Skipping is the only safe replay, but a silent skip
+        // is how redacted_thinking went missing — say which type was dropped.
+        console.warn(`[anthropic-engine] dropping unrecognized content block type "${block.type}" from the assistant turn; it will not be replayed`);
         return { type: "text", text: "" };
     })
         .filter((p) => !(p.type === "text" && p.text === ""));

package/dist/agent/engine/types.d.ts

@@ -121,6 +121,13 @@ export interface EngineThinkingPart {
     text: string;
     /** Opaque signature for pass-through on next turn (Anthropic extended thinking) */
     signature?: string;
+    /**
+     * Encrypted payload of an Anthropic `redacted_thinking` block, which carries
+     * no readable `text` or `signature`. Anthropic requires the block back
+     * verbatim in the same tool-use turn, so it has to survive normalization —
+     * a part with this set replays as `redacted_thinking`, not as `thinking`.
+     */
+    redactedData?: string;
 }
 export type EngineContentPart = EngineTextPart | EngineImagePart | EngineFilePart | EngineToolCallPart | EngineToolResultPart | EngineThinkingPart;
 export type EngineMessage = {

package/dist/agent/production-agent.js

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import Ajv from "ajv";
 import { defineEventHandler, getHeader, setResponseHeader, setResponseStatus, getMethod, } from "h3";
 import { parseA2AAgentActivityPart } from "../a2a/activity.js";
-import { describeToolParameterSignature, isAgentActionStopError, } from "../action.js";
+import { describeToolParameterSignature, isAgentActionStopError, stripUnsupportedSchemaKeywords, } from "../action.js";
 import { readAppState } from "../application-state/script-helpers.js";
 import { isReadOnlyShellCommand } from "../coding-tools/index.js";
 import { getDbExec, isTransientDatabaseError } from "../db/client.js";
@@ -772,6 +772,15 @@ const RUN_BUDGET_EXHAUSTED_ERROR_CODE = "run_budget_exhausted";
 const RUN_BUDGET_EXHAUSTED_MESSAGE = "I ran out of time before finishing this step. " +
     "I stopped rather than keep retrying silently. " +
     "Check any completed tool cards above before retrying, ideally as one smaller follow-up.";
+/**
+ * Text attachments have been capped since forever; binary ones never were, so
+ * a large PDF or screenshot went to the provider as unbounded inline base64.
+ * OpenAI rejects the whole request over 1,048,576 chars in one `file_url`
+ * ("string too long", measured at 4,149,128), which kills the turn — the cap is
+ * on the encoded string, so that is what this counts rather than decoded bytes.
+ * Held under the limit to leave room for the `data:<mediaType>;base64,` prefix.
+ */
+const MAX_INLINE_ATTACHMENT_BASE64_CHARS = 1_000_000;
 const MAX_TEXT_ATTACHMENT_CHARS = 60_000;
 const MAX_TEXT_ATTACHMENTS_TOTAL_CHARS = 80_000;
 const MAX_SELECTION_CONTEXT_CHARS = 8_000;
@@ -1093,6 +1102,17 @@ export function buildUserContentWithAttachments(opts) {
                 continue;
             }
             const match = att.data.match(/^data:(image\/[^;]+);base64,(.+)$/);
+            if (match &&
+                isSupportedImageMediaType(match[1]) &&
+                match[2].length > MAX_INLINE_ATTACHMENT_BASE64_CHARS) {
+                // The upload already happened and `uploadedUrl` is the whole point of
+                // it. Inlining the bytes anyway is what made the request unsendable.
+                const label = att.name ? `"${att.name}"` : "An image";
+                textAttachments.push(uploadedUrl
+                    ? `[${label} was uploaded to ${uploadedUrl}. It was too large to send inline for vision analysis, so use the URL for embedding/reference.]`
+                    : `[${label} was too large to send inline for vision analysis and no upload URL is available. Ask the user to attach a smaller image.]`);
+                continue;
+            }
             if (match && isSupportedImageMediaType(match[1])) {
                 userContent.push({
                     type: "image",
@@ -1125,6 +1145,13 @@ export function buildUserContentWithAttachments(opts) {
         }
         const filePart = dataUrlToFilePart(att);
         if (filePart) {
+            if (filePart.data.length > MAX_INLINE_ATTACHMENT_BASE64_CHARS) {
+                const label = att.name ? `"${att.name}"` : "A file";
+                textAttachments.push(uploadedUrl
+                    ? `[${label} was uploaded to ${uploadedUrl}. It was too large to send inline, so read it from the URL if its contents are needed.]`
+                    : `[${label} was too large to send inline and no upload URL is available. Ask the user for a smaller file.]`);
+                continue;
+            }
             userContent.push(filePart);
             continue;
         }
@@ -2358,18 +2385,41 @@ function extractToolSearchResultNamesFromMessages(messages) {
     }
     return names;
 }
+/**
+ * Every tool the model is offered passes through here -- `defineAction`
+ * schemas, the hand-written ones in extensions/mcp/context tools, and whatever
+ * a third-party MCP server advertises. `defineAction` sanitizes at
+ * construction; nothing else did, so `extension-data-set` shipped a `data`
+ * property carrying a description and no `type`, and OpenAI 400'd the whole
+ * request -- every tool in the payload, not just that one. Sanitizing here is
+ * what makes that unrepresentable rather than a thing each definition site has
+ * to remember.
+ *
+ * Cloned first: the hand-written schemas are module constants, so rewriting in
+ * place would mutate shared state on first use.
+ */
 function normalizeToolInputSchema(schema) {
     if (!schema)
         return { type: "object", properties: {} };
     if (schema.type !== "object")
         return null;
+    let cloned;
+    try {
+        cloned = JSON.parse(JSON.stringify(schema));
+    }
+    catch {
+        // A schema that will not round-trip cannot be safely rewritten, and
+        // shipping it unsanitized is how this class of 400 reaches the provider.
+        return null;
+    }
+    const safe = stripUnsupportedSchemaKeywords(cloned);
     return {
-        ...schema,
+        ...safe,
         type: "object",
-        properties: schema.properties && typeof schema.properties === "object"
-            ? schema.properties
+        properties: safe.properties && typeof safe.properties === "object"
+            ? safe.properties
             : {},
-        required: Array.isArray(schema.required) ? schema.required : [],
+        required: Array.isArray(safe.required) ? safe.required : [],
     };
 }
 function stringifyToolInput(input) {
@@ -7161,6 +7211,11 @@ export function createProductionAgentHandler(options) {
                 const { threadDataToEngineMessages } = await import("./thread-data-builder.js");
                 const priorThreadData = (await getThread(effectiveThreadId))
                     ?.threadData;
+                // `threadDataToEngineMessages` takes one argument and flattens tool
+                // calls to text by design. The second argument never existed anywhere
+                // in the repo, so this failed `tsc` and broke every production build
+                // between 16:29 and now -- it reached main only because admin merges
+                // do not wait for the typecheck that would have caught it.
                 const resumed = threadDataToEngineMessages(priorThreadData);
                 if (resumed.length > 0) {
                     const actionPreparationTool = typeof backgroundRunMarker?.actionPreparationTool === "string" &&

package/dist/agent/thread-data-builder.d.ts

@@ -62,17 +62,29 @@ export declare function buildAssistantMessage(events: RunEvent[], runId?: string
  * fail with "Parent message not found".
  */
 export declare function normalizeThreadRepository(repo: any): any;
+export interface ThreadDataToEngineMessagesOptions {
+    /**
+     * Replay the tool calls and results thread_data already stores instead of
+     * flattening each turn to its prose. Required by callers that RESUME a run
+     * (chained background continuation, agent-teams continue): a turn rebuilt as
+     * text alone tells the model what it said but not what it did, so it re-runs
+     * tools it already ran and cannot see their output. Callers that only need
+     * "what was said" — recovery floors, memory compaction — leave this off.
+     */
+    includeToolCalls?: boolean;
+}
 /**
  * Rebuild a flat `EngineMessage[]` from persisted thread_data (the
- * assistant-ui ExportedMessageRepository shape). Text-only — tool calls/results
- * are flattened to their text so a continuation run gets the conversation
- * prefix as plain context (Anthropic's prompt cache makes the resume cheap).
+ * assistant-ui ExportedMessageRepository shape). Each turn collapses to its
+ * text by default, which is all a recovery floor or a memory compaction needs.
+ * Callers resuming a run pass `includeToolCalls` to replay what the turn
+ * actually DID as well as what it said.
  *
  * Used to resume a background sub-agent in a fresh function invocation (the
  * server-side analog of the browser re-POSTing history for the main chat).
  * Originally inlined in `integrations/webhook-handler.ts`.
  */
-export declare function threadDataToEngineMessages(threadData: string | Record<string, unknown> | null | undefined): EngineMessage[];
+export declare function threadDataToEngineMessages(threadData: string | Record<string, unknown> | null | undefined, options?: ThreadDataToEngineMessagesOptions): EngineMessage[];
 /**
  * The trailing window of what was actually said in a thread, for a request that
  * arrived carrying no history of its own. The client trims history against a

package/dist/agent/thread-data-builder.js

@@ -1,6 +1,7 @@
 import { formatChatErrorText, normalizeChatError, } from "../client/error-format.js";
 import { isCredentialGapCodeAgentEvent, normalizeCodeAgentTranscript, } from "../code-agents/transcript-normalizer.js";
 import { BUILDER_GATEWAY_INTERNAL_ERROR_CODE } from "./engine/error-detail.js";
+import { stringifyToolUseInputForGateway } from "./engine/translate-anthropic.js";
 const INTERRUPTED_TOOL_RESULT = "Interrupted before this tool returned a result.";
 export const ASSISTANT_RUN_DURATION_METADATA_KEY = "agentNativeRunDurationMs";
 const MAX_STORED_ATTACHMENT_CHARS = 60_000;
@@ -653,17 +654,121 @@ export function normalizeThreadRepository(repo) {
         headId && seenIds.has(headId) ? headId : (previousId ?? null);
     return normalized;
 }
+/**
+ * A replayed tool result is evidence, not the source of truth — the resumed
+ * turn can always re-read current state. Bound each one so restoring fidelity
+ * cannot itself overflow the context window, and say so in-band when it bites.
+ */
+const MAX_REPLAYED_TOOL_RESULT_CHARS = 12_000;
+/**
+ * Total budget for replayed tool payloads across the whole thread. Per-result
+ * capping alone is not a bound: a long run has hundreds of calls, so replaying
+ * every one of them would overflow the context window and break the very
+ * continuation this replay exists to serve. The newest turns keep their tool
+ * detail; older turns fall back to prose and say so.
+ */
+const MAX_REPLAYED_TOOL_PAYLOAD_CHARS = 64_000;
+const ELIDED_TOOL_DETAIL_NOTE = "[Tool calls from this turn were elided from replayed history to fit the context. Re-read the current state with tools if their detail matters.]";
+function replayedToolResultContent(result) {
+    const body = typeof result === "string"
+        ? result
+        : result === undefined || result === null
+            ? ""
+            : (() => {
+                try {
+                    return JSON.stringify(result) ?? "";
+                }
+                catch {
+                    return String(result);
+                }
+            })();
+    if (body.length <= MAX_REPLAYED_TOOL_RESULT_CHARS)
+        return body;
+    const omitted = body.length - MAX_REPLAYED_TOOL_RESULT_CHARS;
+    return `${body.slice(0, MAX_REPLAYED_TOOL_RESULT_CHARS)}\n\n[Tool result truncated after ${MAX_REPLAYED_TOOL_RESULT_CHARS.toLocaleString()} characters; ${omitted.toLocaleString()} omitted from replayed history. Re-read the current state with tools if the exact content matters.]`;
+}
+/**
+ * Integration turns (Slack and friends) deliberately replay only what the
+ * participant saw plus a compact artifact ledger — never the raw tool results.
+ * `threadMessageTextForEngine` owns that policy, so a structured replay has to
+ * defer to it rather than reach past it into `content`.
+ */
+function hasIntegrationReplayPolicy(message) {
+    const metadata = message?.metadata;
+    if (!metadata || typeof metadata !== "object")
+        return false;
+    return (metadata.integrationDelivery !== undefined ||
+        metadata.integrationDeliveryAttempted === true ||
+        Array.isArray(metadata.integrationArtifacts));
+}
+function replayableToolCalls(message) {
+    const content = Array.isArray(message?.content) ? message.content : [];
+    return content.filter((part) => part?.type === "tool-call" &&
+        typeof part.toolCallId === "string" &&
+        part.toolCallId.trim() &&
+        typeof part.toolName === "string" &&
+        part.toolName.trim());
+}
+/** What replaying this turn's tool calls with their results would actually cost. */
+function replayedToolPayloadCost(message) {
+    let cost = 0;
+    for (const part of replayableToolCalls(message)) {
+        cost += stringifyToolUseInputForGateway(part.args ?? {}).length;
+        if (part.result !== undefined) {
+            cost += replayedToolResultContent(part.result).length;
+        }
+    }
+    return cost;
+}
+/**
+ * One persisted assistant turn spans many tool rounds. Replay it as the
+ * provider protocol wants it — one assistant message carrying every `tool-call`,
+ * then one user message carrying every matching `tool-result`. The exact
+ * round-by-round interleaving is not recoverable from thread_data and does not
+ * matter; what matters is that the calls and their outputs survive at all.
+ */
+function assistantReplayContent(message, text) {
+    const assistant = [];
+    const results = [];
+    if (text.trim())
+        assistant.push({ type: "text", text });
+    const content = Array.isArray(message?.content) ? message.content : [];
+    for (const part of content) {
+        if (part?.type !== "tool-call")
+            continue;
+        const id = typeof part.toolCallId === "string" ? part.toolCallId.trim() : "";
+        const name = typeof part.toolName === "string" ? part.toolName.trim() : "";
+        if (!id || !name)
+            continue;
+        const input = part.args && typeof part.args === "object" && !Array.isArray(part.args)
+            ? part.args
+            : {};
+        assistant.push({ type: "tool-call", id, name, input });
+        if (part.result === undefined)
+            continue;
+        results.push({
+            type: "tool-result",
+            toolCallId: id,
+            toolName: name,
+            toolInput: stringifyToolUseInputForGateway(input),
+            content: replayedToolResultContent(part.result),
+            ...(part.isError === true ? { isError: true } : {}),
+        });
+    }
+    return { assistant, results };
+}
 /**
  * Rebuild a flat `EngineMessage[]` from persisted thread_data (the
- * assistant-ui ExportedMessageRepository shape). Text-only — tool calls/results
- * are flattened to their text so a continuation run gets the conversation
- * prefix as plain context (Anthropic's prompt cache makes the resume cheap).
+ * assistant-ui ExportedMessageRepository shape). Each turn collapses to its
+ * text by default, which is all a recovery floor or a memory compaction needs.
+ * Callers resuming a run pass `includeToolCalls` to replay what the turn
+ * actually DID as well as what it said.
  *
  * Used to resume a background sub-agent in a fresh function invocation (the
  * server-side analog of the browser re-POSTing history for the main chat).
  * Originally inlined in `integrations/webhook-handler.ts`.
  */
-export function threadDataToEngineMessages(threadData) {
+export function threadDataToEngineMessages(threadData, options = {}) {
     const messages = [];
     if (!threadData)
         return messages;
@@ -676,11 +781,60 @@ export function threadDataToEngineMessages(threadData) {
     }
     if (!Array.isArray(data?.messages))
         return messages;
-    for (const entry of data.messages) {
+    const entries = data.messages;
+    const replaysTools = (m) => options.includeToolCalls === true &&
+        m?.role === "assistant" &&
+        !hasIntegrationReplayPolicy(m);
+    // Spend the tool-payload budget on the most recent turns: those are the ones
+    // a resumed run is about to build on. Decided up front so the walk below can
+    // stay in conversation order.
+    const toolPayloadAllowed = new Set();
+    if (options.includeToolCalls) {
+        let spent = 0;
+        for (let i = entries.length - 1; i >= 0; i--) {
+            const m = entries[i]?.message ?? entries[i];
+            if (!replaysTools(m))
+                continue;
+            const cost = replayedToolPayloadCost(m);
+            if (cost === 0)
+                continue;
+            if (spent + cost > MAX_REPLAYED_TOOL_PAYLOAD_CHARS)
+                continue;
+            spent += cost;
+            toolPayloadAllowed.add(i);
+        }
+    }
+    for (const [index, entry] of entries.entries()) {
         const m = entry?.message ?? entry;
         if (!m || (m.role !== "user" && m.role !== "assistant"))
             continue;
         const text = threadMessageTextForEngine(m);
+        if (replaysTools(m)) {
+            if (toolPayloadAllowed.has(index)) {
+                const { assistant, results } = assistantReplayContent(m, text);
+                if (assistant.length === 0)
+                    continue;
+                messages.push({ role: "assistant", content: assistant });
+                if (results.length > 0) {
+                    messages.push({ role: "user", content: results });
+                }
+                continue;
+            }
+            // Over budget, or nothing to replay. Prose still travels — but a turn
+            // whose tool detail was dropped must not read like a turn that never
+            // called a tool.
+            const elided = replayableToolCalls(m).length > 0;
+            const prose = elided
+                ? `${text.trim() ? `${text.trim()}\n\n` : ""}${ELIDED_TOOL_DETAIL_NOTE}`
+                : text;
+            if (!prose.trim())
+                continue;
+            messages.push({
+                role: "assistant",
+                content: [{ type: "text", text: prose }],
+            });
+            continue;
+        }
         if (!text.trim())
             continue;
         messages.push({ role: m.role, content: [{ type: "text", text }] });

package/dist/client/agent-chat-adapter.js

@@ -66,6 +66,17 @@ const MAX_HISTORY_ATTACHMENT_CHARS = 60_000;
 // visibly (not silently) capped.
 const MAX_OUTBOUND_ATTACHMENT_CHARS = 200_000;
 const MAX_HISTORY_MESSAGES = 24;
+// Every provider prompt cache matches a byte-identical PREFIX. A window that
+// ends at the newest message and starts MAX_HISTORY_MESSAGES back moves its
+// START by one message per turn, so from the first turn past the cap onward no
+// cached prefix ever matches again and the whole conversation is re-billed at
+// full write price on every turn — the cache breakpoints the engines place
+// (system prefix, last tool, last user message) cannot save a prefix whose
+// first bytes changed. Quantizing where the window starts holds those bytes
+// identical for a stride of turns, so one turn in STRIDE pays the write and the
+// rest read. The window then holds up to MAX + STRIDE - 1 messages; the char
+// budgets below, not the message count, are what bound the payload.
+const HISTORY_WINDOW_STRIDE = 8;
 const MAX_HISTORY_TOTAL_CHARS = 64_000;
 // Budget for everything actually said in the thread — every user ask and every
 // assistant conclusion. Separate from MAX_HISTORY_TOTAL_CHARS, which bounds the
@@ -788,7 +799,8 @@ function estimateHistoryMessageCost(message) {
     return Math.max(1, cost);
 }
 function limitPriorMessagesForRequest(messages) {
-    const recent = messages.slice(-MAX_HISTORY_MESSAGES);
+    const overflow = Math.max(0, messages.length - MAX_HISTORY_MESSAGES);
+    const recent = messages.slice(Math.floor(overflow / HISTORY_WINDOW_STRIDE) * HISTORY_WINDOW_STRIDE);
     const kept = [];
     let words = 0;
     let payload = 0;

package/dist/collab/awareness.d.ts

@@ -62,11 +62,11 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
+    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
-    error?: undefined;
 }>>;
 /**
  * GET /_agent-native/collab/:docId/users
@@ -77,9 +77,9 @@ export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("
     error: string;
     users?: undefined;
 } | {
+    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
-    error?: undefined;
 }>>;

package/dist/collab/routes.d.ts

@@ -26,8 +26,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
  * Body: { update: string (base64), requestSource?: string }
  */
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/observability/routes.d.ts

@@ -41,16 +41,16 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     thumbsUpRate: number;
     avgEvalScore: number;
 } | {
-    error?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
     id?: undefined;
+    error?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     summary?: undefined;
     spans?: undefined;
     id: string;
+    error?: undefined;
     ok?: undefined;
 } | {
     summary?: undefined;
@@ -59,9 +59,9 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     error: any;
     ok?: undefined;
 } | {
-    error?: undefined;
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;

package/dist/server/agent-engine-api-key-route.d.ts

@@ -27,10 +27,10 @@ export declare function resolveAgentEngineApiKeyWriteTarget(event: H3Event, scop
 export declare function createAgentEngineApiKeyHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: any;
 } | {
-    error?: undefined;
     ok: boolean;
     key: string;
     baseUrlKey?: string;
     scope: AgentEngineApiKeyScope;
+    error?: undefined;
 }>>;
 export {};

package/dist/server/agent-teams.js

@@ -1236,7 +1236,9 @@ export async function processAgentTeamRun(opts) {
             catch {
                 priorThreadData = undefined;
             }
-            messages = threadDataToEngineMessages(priorThreadData);
+            messages = threadDataToEngineMessages(priorThreadData, {
+                includeToolCalls: true,
+            });
             if (messages.length === 0) {
                 messages = [
                     {