@opengeni/runtime 0.14.1 → 0.14.15

package/src/history-sanitizer.ts

@@ -36,6 +36,16 @@ import {
 /** A history item is any JSON object; we only inspect a few discriminator fields. */
 export type HistoryItem = Record<string, unknown>;
 
+/**
+ * @deprecated Model-visible history is append-only outside the explicit
+ * durable compaction transition. This compatibility identity function performs
+ * no elision and returns the exact input array with every item untouched and in
+ * its original order.
+ */
+export function elideSupersededViewImagePairs<T extends HistoryItem>(items: readonly T[]): T[] {
+  return items as T[];
+}
+
 /**
  * Tool-call item types and the result-item type that settles them. Kept in
  * sync with the SDK's `TOOL_CALL_RESULT_TYPE_BY_CALL_TYPE`; `function_call` is
@@ -103,98 +113,6 @@ function callIdOf(item: unknown): string | undefined {
   return undefined;
 }
 
-/**
- * Return the normalized local path from a sandbox `view_image` function call.
- * Invalid/partial calls are deliberately ignored: the filter below only
- * removes fully-paired calls whose replacement is known to be valid.
- */
-function viewImagePathOf(item: unknown): string | undefined {
-  if (!item || typeof item !== "object") {
-    return undefined;
-  }
-  const record = item as { type?: unknown; name?: unknown; arguments?: unknown };
-  if (
-    record.type !== "function_call" ||
-    record.name !== "view_image" ||
-    typeof record.arguments !== "string"
-  ) {
-    return undefined;
-  }
-  try {
-    const parsed = JSON.parse(record.arguments) as { path?: unknown };
-    return typeof parsed.path === "string" && parsed.path.length > 0 ? parsed.path : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * Remove superseded `view_image` call/result pairs for the SAME local path,
- * retaining the newest fully-paired observation. A `view_image` result can be
- * hundreds of kilobytes of base64. When a model re-opens the same attachment,
- * replaying every older copy on each subsequent model call grows input
- * quadratically and can trap a turn in context-compaction/requeue recovery.
- *
- * This is state-based rather than count-based: every distinct path is kept,
- * and an older observation is removed only after a newer successful pair for
- * that exact path exists. The reasoning items immediately attached to a
- * removed call are removed with it, preserving Responses API item validity.
- */
-export function elideSupersededViewImagePairs<T extends HistoryItem>(items: readonly T[]): T[] {
-  if (items.length === 0) {
-    return [];
-  }
-
-  const callIndexById = new Map<string, number>();
-  const resultIndexById = new Map<string, number>();
-  items.forEach((item, index) => {
-    const callId = callIdOf(item);
-    if (!callId) {
-      return;
-    }
-    if (itemType(item) === "function_call") {
-      callIndexById.set(callId, index);
-    } else if (
-      itemType(item) === "function_call_result" ||
-      itemType(item) === "function_call_output"
-    ) {
-      resultIndexById.set(callId, index);
-    }
-  });
-
-  const pairedByPath = new Map<string, Array<{ callIndex: number; resultIndex: number }>>();
-  for (const [callId, callIndex] of callIndexById) {
-    const path = viewImagePathOf(items[callIndex]);
-    const resultIndex = resultIndexById.get(callId);
-    if (!path || resultIndex === undefined || resultIndex <= callIndex) {
-      continue;
-    }
-    const pairs = pairedByPath.get(path) ?? [];
-    pairs.push({ callIndex, resultIndex });
-    pairedByPath.set(path, pairs);
-  }
-
-  const dropped = new Set<number>();
-  for (const pairs of pairedByPath.values()) {
-    if (pairs.length < 2) {
-      continue;
-    }
-    pairs.sort((left, right) => left.callIndex - right.callIndex);
-    for (const pair of pairs.slice(0, -1)) {
-      dropped.add(pair.callIndex);
-      dropped.add(pair.resultIndex);
-      for (let index = pair.callIndex - 1; index >= 0; index -= 1) {
-        if (itemType(items[index]) !== "reasoning") {
-          break;
-        }
-        dropped.add(index);
-      }
-    }
-  }
-
-  return dropped.size === 0 ? items.slice() : items.filter((_item, index) => !dropped.has(index));
-}
-
 /**
  * Sanitize a replayed history item list into a sequence the Responses API
  * accepts. Pure: returns a new array of the same item references in order,

package/src/index.ts

@@ -35,6 +35,7 @@ import {
   type McpServerConnectionRef,
   type Permission,
   type FirstPartyMcpToolName,
+  type LatencyMode,
   type ReasoningEffort,
   type ResourceRef,
   type SessionEventType,
@@ -148,7 +149,6 @@ import { fileURLToPath } from "node:url";
 
 import {
   computerCallNormalizingFetch,
-  elideSupersededViewImagePairs,
   normalizeComputerCallActions,
   sanitizeHistoryItemsForModel,
 } from "./history-sanitizer";
@@ -158,6 +158,8 @@ import {
   CompactionProviderResponseError,
   EmptyCompactionSummaryError,
   SUMMARY_BUFFER_TOKENS,
+  buildRemoteCompactionV2PromptInput,
+  extractRemoteCompactionV2OutputItem,
   compactionThresholdTokens,
   estimateCompleteModelInput,
   estimateSerializedValueTokens,
@@ -280,13 +282,24 @@ export {
   clampCompactionThresholdRatio,
   decideCompaction,
   buildSummaryItem,
+  buildRemoteCompactionV2PromptInput,
+  buildRemoteV2ReplacementHistory,
+  extractRemoteCompactionV2OutputItem,
   findCompactionNeededError,
   isCompactionSummary,
+  isRemoteCompactionItem,
+  isRetainedRemoteV2Message,
   latestCompactionReplacementFingerprint,
   prepareCompactionPromptInput,
   isUserMessage,
   estimateTokens,
+  estimateTokensBreakdown,
   estimateItemTokens,
+  estimateItemTokenBreakdown,
+  estimateOpaqueEncryptedModelVisibleBytes,
+  estimateOpaqueEncryptedTokens,
+  opaqueEncryptedContentLength,
+  estimateNativeImageTokens,
   estimateCompleteModelInput,
   estimateSerializedValueTokens,
   hasModelGeneratedItem,
@@ -294,15 +307,23 @@ export {
   COMPACTION_SUMMARY_MARKER,
   COMPACTION_PROMPT,
   COMPACT_USER_MESSAGE_MAX_TOKENS,
+  REMOTE_V2_RETAINED_MESSAGE_TOKEN_BUDGET,
+  REMOTE_COMPACTION_V2_IMPLEMENTATION,
+  REMOTE_COMPACTION_V2_BETA_FEATURE,
   DEFAULT_COMPACTION_THRESHOLD_RATIO,
   MIN_COMPACTION_THRESHOLD_RATIO,
   MAX_COMPACTION_THRESHOLD_RATIO,
   SUMMARY_BUFFER_TOKENS,
   SUMMARY_PREFIX,
   USER_MESSAGE_TRUNCATION_MARKER,
+  UNKNOWN_IMAGE_TOKENS,
+  MAX_NATIVE_IMAGE_TOKENS,
 } from "./context-compaction";
 export type {
   CompactionDecision,
+  ModelInputTokenBreakdown,
+  NativeImageEstimateReason,
+  NativeImageTokenEstimate,
   CompactionItem,
   PreparedCompactionPromptInput,
 } from "./context-compaction";
@@ -329,6 +350,7 @@ export type NormalizedRuntimeEvent = {
 
 export type ModelResponseUsage = {
   responseId?: string;
+  serviceTier?: string;
   usage: {
     inputTokens?: number;
     outputTokens?: number;
@@ -1005,6 +1027,67 @@ export async function summarizeForCompaction(
   return summary;
 }
 
+/**
+ * Codex remote compaction v2: send active history + `compaction_trigger`, collect
+ * exactly one `{ type: "compaction", encrypted_content }` output item.
+ * Must run inside Codex ALS with `remote_compaction_v2` beta + turn metadata.
+ */
+export async function requestRemoteCompactionV2(
+  settings: Settings,
+  input: Array<Record<string, unknown>>,
+  options: {
+    client: OpenAI;
+    model: string;
+    promptCacheKey?: string;
+    onUsage?: (usage: ModelResponseUsage) => void | Promise<void>;
+  },
+): Promise<Record<string, unknown>> {
+  const promptInput = buildRemoteCompactionV2PromptInput(input);
+  const request: ModelRequest = {
+    systemInstructions: "",
+    input: promptInput as AgentInputItem[],
+    modelSettings: {
+      // Azure rejects store:false; Codex transport enforces store:false itself.
+      ...(settings.openaiProvider === "azure" ? {} : { store: false }),
+      ...(options.promptCacheKey
+        ? { providerData: { prompt_cache_key: options.promptCacheKey } }
+        : {}),
+    },
+    tools: [],
+    toolsExplicitlyProvided: true,
+    outputType: "text",
+    handoffs: [],
+    tracing: false,
+  };
+  let response: unknown;
+  try {
+    response = await new CompactionResponsesModel(options.client, options.model).fetchResponse(
+      request,
+    );
+  } catch (error) {
+    throw new CompactionProviderResponseError(compactionProviderFailureDiagnostics(error), error);
+  }
+  const usage = modelResponseUsageFromResponse(response);
+  if (usage) {
+    await options.onUsage?.(usage);
+  }
+  if (isFailedCompactionProviderResponse(response)) {
+    throw new CompactionProviderResponseError(compactionProviderFailureDiagnostics(response));
+  }
+  try {
+    return extractRemoteCompactionV2OutputItem(response);
+  } catch (error) {
+    if (error instanceof EmptyCompactionSummaryError) {
+      throw new EmptyCompactionSummaryError({
+        ...compactionResponseDiagnostics(response, ""),
+        ...error.diagnostics,
+        stage: "remote_v2_extract",
+      });
+    }
+    throw error;
+  }
+}
+
 function isFailedCompactionProviderResponse(response: unknown): boolean {
   if (!response || typeof response !== "object") return false;
   const record = response as Record<string, unknown>;
@@ -1293,6 +1376,10 @@ export type BuildAgentOptions = {
     response: HumanInputResponse;
   };
   reasoningEffort?: ReasoningEffort;
+  /** Product latency selection frozen onto this turn. */
+  latencyMode?: LatencyMode;
+  /** Provider-specific wire value resolved by the worker (`fast` or `priority`). */
+  serviceTier?: "fast" | "priority";
   // Per-turn gating overrides for the multi-provider path. Each defaults to
   // today's settings-derived behaviour when omitted, so the legacy
   // global-client callers (no model resolution) are byte-for-byte unchanged.
@@ -1323,8 +1410,7 @@ export type BuildAgentOptions = {
   // EXPLICIT computer-use tool transport, decided where provider identity is
   // authoritative (the worker's model resolution — agent-turn.ts). Threaded into
   // buildAgentCapabilities → computerUse({toolMode}) so tool selection never rests
-  // on the SDK's constructor-name sniff. When omitted, the legacy sniff +
-  // `structuredToolTransport` neutralize path is preserved byte-for-byte.
+  // on the SDK's constructor-name sniff. Omitted means disabled/fail-closed.
   computerToolMode?: ComputerToolMode;
   /**
    * Invoked once, immediately before the first real computer action and after
@@ -1765,9 +1851,14 @@ export function buildOpenGeniAgent(
   // resolved provider's api/window/web-search instead.
   const hostedWebSearch = options.hostedWebSearch ?? settings.webSearchEnabled;
   const encryptedReasoning = options.encryptedReasoning ?? settings.openaiReasoningEncryptedContent;
+  // Wire value must be provider-mapped by the caller (OpenAI `fast`, Azure/Codex
+  // `priority`). Do not fall back to latencyMode itself — that would send
+  // invalid Azure tiers.
+  const serviceTier = options.serviceTier;
   const providerData = {
     ...(encryptedReasoning ? { include: ["reasoning.encrypted_content"] } : {}),
     ...(options.promptCacheKey ? { prompt_cache_key: options.promptCacheKey } : {}),
+    ...(serviceTier ? { service_tier: serviceTier } : {}),
   };
   // Native hosted tools attached to every constructed agent. webSearchEnabled
   // is ON by default and provider-unconditional on the built-in path (the live
@@ -2252,10 +2343,8 @@ export function buildAgentCapabilities(
     sessionSkills?: PackSkill[];
     workspaceSkillPaths?: readonly WorkspaceSkillSearchPath[];
     structuredToolTransport?: boolean;
-    // EXPLICIT computer-use transport (see BuildAgentOptions.computerToolMode). When
-    // present, computerUse() is handed the mode directly and its tools() obeys it
-    // without the constructor-name sniff. When absent, the legacy neutralize +
-    // imageFunctionResults path (driven by structuredToolTransport) is unchanged.
+    // EXPLICIT computer-use transport (see BuildAgentOptions.computerToolMode).
+    // Omitted/unproven transport fails closed with no computer tools.
     computerToolMode?: ComputerToolMode;
     onComputerUseReady?: (session: SandboxSessionLike) => Promise<void>;
     turnCancellationSignal?: AbortSignal;
@@ -2328,37 +2417,14 @@ export function buildAgentCapabilities(
     // FUNCTION `computer_*` tools on the text transport. The ChatGPT/Codex backend
     // rejects hosted tool types (only function/custom/web_search accepted).
     //
-    // HARDENING: when the caller declares an EXPLICIT `computerToolMode` (the worker
-    // does, from its authoritative model resolution), thread it straight through —
-    // tool selection then never depends on the SDK's model-instance constructor-name
-    // sniff (which a wrapped/proxied model would defeat, silently 400ing a
-    // chat-completions provider handed the hosted tool). When ABSENT, the legacy path
-    // is preserved byte-for-byte: on the codex path (structuredToolTransport === false)
-    // we set imageFunctionResults and neutralize the capability's model binding — the
-    // SAME trick used for filesystem above — so `tools()` sees no model instance and
-    // emits the function tools the backend can call, instead of suppressing the tier.
-    const explicitMode = options.computerToolMode;
+    // The worker declares an explicit mode from authoritative provider resolution.
+    // Exported/public callers that omit it are unproven and therefore disabled.
     const computerCapability = computerUse({
       dimensions: [settings.streamResolutionWidth, settings.streamResolutionHeight],
       readOnly: settings.computerUseReadOnly,
       ...(options.onComputerUseReady ? { onReady: options.onComputerUseReady } : {}),
-      ...(explicitMode
-        ? { toolMode: explicitMode }
-        : // Legacy (no explicit mode): on the codex path the function tools deliver
-          // screenshots as a real image the model can see. The ChatGPT/Codex backend
-          // rejects HOSTED tool types but DOES accept `input_image` content items inside a
-          // `function_call_output` (proven by openai/codex codex-rs, whose view_image tool
-          // ships exactly that shape) — so a structured image tool result is seen, where a
-          // text data-URL would be unreadable.
-          options.structuredToolTransport === false
-          ? { imageFunctionResults: true }
-          : {}),
+      toolMode: options.computerToolMode ?? "disabled",
     });
-    // Neutralize ONLY on the legacy sniff path. With an explicit toolMode the mode
-    // already forces the function tools, so the constructor-name override is moot.
-    if (!explicitMode && options.structuredToolTransport === false) {
-      neutralizeStructuredToolTransport(computerCapability);
-    }
     caps.push(computerCapability as unknown as ReturnType<typeof Capabilities.default>[number]);
   }
   if (toolCancellation) {
@@ -2993,9 +3059,12 @@ function parseWwwAuthenticate(header: string | null): {
 // content, erasing the failure. A JSON-RPC error survives the shim as a thrown
 // McpError, which PrefixedMcpServer.callTool converts back into an MCP-shaped
 // `{ isError: true }` output for the model.
-const MCP_AUTH_NEEDED_ERROR_CODE = -32001;
-const MCP_AUTH_NEEDED_MESSAGE =
-  "Authentication required - a connection link was posted to the session.";
+const MCP_AUTH_NEEDED_ERROR = {
+  // OpenGeni application-defined JSON-RPC code. Keep this positive so it cannot
+  // collide with MCP SDK transport errors such as RequestTimeout (-32001).
+  code: 40_101,
+  message: "Authentication required - a connection link was posted to the session.",
+} as const;
 
 function mcpToolAuthNeededResponse(id: string | number | null | undefined): Response {
   return new Response(
@@ -3003,8 +3072,8 @@ function mcpToolAuthNeededResponse(id: string | number | null | undefined): Resp
       jsonrpc: "2.0",
       id: id ?? null,
       error: {
-        code: MCP_AUTH_NEEDED_ERROR_CODE,
-        message: MCP_AUTH_NEEDED_MESSAGE,
+        code: MCP_AUTH_NEEDED_ERROR.code,
+        message: MCP_AUTH_NEEDED_ERROR.message,
       },
     }),
     {
@@ -3019,7 +3088,11 @@ function isAuthNeededMcpError(error: unknown): boolean {
     return false;
   }
   const code = (error as { code?: unknown }).code;
-  return code === MCP_AUTH_NEEDED_ERROR_CODE || error.message.includes(MCP_AUTH_NEEDED_MESSAGE);
+  return (
+    code === MCP_AUTH_NEEDED_ERROR.code &&
+    (error.message === MCP_AUTH_NEEDED_ERROR.message ||
+      error.message === `MCP error ${MCP_AUTH_NEEDED_ERROR.code}: ${MCP_AUTH_NEEDED_ERROR.message}`)
+  );
 }
 
 // Model-facing text for a best-effort server whose tool call failed for a
@@ -3053,19 +3126,59 @@ function safeMcpErrorFields(error: unknown): {
   return { errorClass, status };
 }
 
-function safeMcpTransportError(error: unknown): Error & { status?: number; code?: number } {
+type SafeMcpTransportError = Error & {
+  status?: number;
+  code?: number;
+  mcpTransportFailureKind?: "request_timeout";
+};
+
+/**
+ * Preserve the MCP SDK's exact request-timeout meaning without retaining or
+ * exposing a raw HTTP response body. The numeric code is not sufficient:
+ * Streamable HTTP also uses -32001 for "Session not found" and arbitrary
+ * AbortSignal reasons, so only the SDK's two owned timeout messages qualify.
+ */
+export function isMcpRequestTimeoutError(error: unknown, seen = new WeakSet<object>()): boolean {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  if (seen.has(error)) {
+    return false;
+  }
+  seen.add(error);
+  const record = error as Record<string, unknown>;
+  if (record.mcpTransportFailureKind === "request_timeout") {
+    return true;
+  }
+  const code = typeof record.code === "number" ? record.code : record.status;
+  const message = typeof record.message === "string" ? record.message : "";
+  const sdkTimeoutMessages = new Set([
+    "Request timed out",
+    "MCP error -32001: Request timed out",
+    "Maximum total timeout exceeded",
+    "MCP error -32001: Maximum total timeout exceeded",
+  ]);
+  if (code === -32_001 && sdkTimeoutMessages.has(message)) {
+    return true;
+  }
+  return ["error", "cause", "response", "data"].some((key) =>
+    isMcpRequestTimeoutError(record[key], seen),
+  );
+}
+
+export function safeMcpTransportError(error: unknown): SafeMcpTransportError {
   const fields = safeMcpErrorFields(error);
   const safeError = new Error(
     `MCP transport operation failed (${mcpErrorReason(fields)})`,
-  ) as Error & {
-    status?: number;
-    code?: number;
-  };
+  ) as SafeMcpTransportError;
   safeError.name = "McpTransportError";
   if (fields.status !== undefined) {
     safeError.status = fields.status;
     safeError.code = fields.status;
   }
+  if (isMcpRequestTimeoutError(error)) {
+    safeError.mcpTransportFailureKind = "request_timeout";
+  }
   return safeError;
 }
 
@@ -3162,17 +3275,33 @@ async function signFirstPartyDelegatedBearer(
   if (!settings.delegationSecret || !options.accountId || !options.workspaceId) {
     return null;
   }
+  const attemptClaims = [
+    options.sessionId,
+    options.turnId,
+    options.attemptId,
+    options.executionGeneration,
+  ];
+  const hasAnyAttemptClaim = attemptClaims.some((claim) => claim !== undefined);
+  const hasExactAttemptClaims = attemptClaims.every((claim) => claim !== undefined);
+  if (hasAnyAttemptClaim && !hasExactAttemptClaims) {
+    return null;
+  }
   return await signDelegatedAccessToken(settings.delegationSecret, {
     accountId: options.accountId,
     workspaceId: options.workspaceId,
     subjectId: options.subjectId ?? "worker:first-party-mcp",
     ...(options.subjectLabel ? { subjectLabel: options.subjectLabel } : {}),
     permissions: options.firstPartyPermissions ?? [...DEFAULT_FIRST_PARTY_MCP_PERMISSIONS],
+    principalKind: hasExactAttemptClaims ? "agent_attempt" : "service",
     firstPartyMcpTools: options.firstPartyTools ?? [...DEFAULT_FIRST_PARTY_MCP_TOOLS],
-    ...(options.sessionId ? { sessionId: options.sessionId } : {}),
-    ...(options.turnId ? { turnId: options.turnId } : {}),
-    ...(options.attemptId ? { attemptId: options.attemptId } : {}),
-    ...(options.executionGeneration ? { executionGeneration: options.executionGeneration } : {}),
+    ...(hasExactAttemptClaims
+      ? {
+          sessionId: options.sessionId!,
+          turnId: options.turnId!,
+          attemptId: options.attemptId!,
+          executionGeneration: options.executionGeneration!,
+        }
+      : {}),
     exp: Math.floor(Date.now() / 1000) + 60 * 60,
   });
 }
@@ -3469,7 +3598,7 @@ class PrefixedMcpServer implements MCPServer {
       if (isAuthNeededMcpError(error)) {
         return {
           isError: true,
-          content: [{ type: "text", text: MCP_AUTH_NEEDED_MESSAGE }],
+          content: [{ type: "text", text: MCP_AUTH_NEEDED_ERROR.message }],
         };
       }
       // Best-effort INVOCATION isolation (sibling to the listTools guard). When
@@ -3798,18 +3927,6 @@ export const normalizeComputerCallsFilter: CallModelInputFilter = ({ modelData }
   ) as unknown as AgentInputItem[],
 });
 
-/**
- * Per-call state compaction for local image inspection. Re-opening the same
- * path supersedes its prior base64 result; carrying both provides no newer
- * information and can otherwise balloon every following model request.
- */
-export const elideSupersededViewImagesFilter: CallModelInputFilter = ({ modelData }) => ({
-  ...modelData,
-  input: elideSupersededViewImagePairs(
-    modelData.input as unknown as Array<Record<string, unknown>>,
-  ) as unknown as AgentInputItem[],
-});
-
 /**
  * Canonical Codex-style tool-result bound at the final model-input seam. The
  * identical pure normalizer also runs before conversation rows are persisted,
@@ -3936,7 +4053,6 @@ export function callModelInputFilterForSettings(
 ): CallModelInputFilter | undefined {
   const filters: CallModelInputFilter[] = [
     normalizeComputerCallsFilter,
-    elideSupersededViewImagesFilter,
     boundModelToolOutputsFilterForSettings(settings),
   ];
   if (settings.openaiProviderItemIds === "strip") {
@@ -5005,6 +5121,72 @@ export function normalizeToolOutputForEvent(output: unknown): unknown {
   return output;
 }
 
+/**
+ * Hosted web_search progresses on the raw Responses stream
+ * (`response.output_item.added/done` with `web_search_call`) long before the SDK
+ * materializes a `RunToolCallItem` at `response_done`. Without this mapping the
+ * timeline only sees search cards after the whole model round finishes — or
+ * never mid-turn — while assistant prose ("Search 1/5") streams live.
+ */
+function hostedWebSearchToolCallFromResponsesEvent(raw: unknown): NormalizedRuntimeEvent | null {
+  if (!raw || typeof raw !== "object") {
+    return null;
+  }
+  const event = raw as {
+    type?: unknown;
+    item?: {
+      id?: unknown;
+      type?: unknown;
+      status?: unknown;
+      action?: unknown;
+      [key: string]: unknown;
+    };
+  };
+  const eventType = typeof event.type === "string" ? event.type : "";
+  if (
+    !(
+      (eventType === "response.output_item.added" || eventType === "response.output_item.done") &&
+      event.item?.type === "web_search_call"
+    )
+  ) {
+    // Progress-only `response.web_search_call.*` events lack the action
+    // payload; added/done are enough for a live, query-bearing card.
+    return null;
+  }
+  const item = event.item;
+  const itemId = typeof item.id === "string" ? item.id : null;
+  if (!itemId) {
+    return null;
+  }
+  const status =
+    typeof item.status === "string"
+      ? item.status
+      : eventType === "response.output_item.done"
+        ? "completed"
+        : "in_progress";
+  const action = item.action ?? null;
+  // Codex frequently emits `output_item.added` for web_search_call before the
+  // action payload exists. Persist that so the timeline can show "Searching…",
+  // then the matching `done` (same id) fills in query/queries via merge.
+  const { status: _status, ...providerData } = item;
+
+  return {
+    type: "agent.toolCall.created",
+    payload: {
+      id: itemId,
+      name: "web_search_call",
+      arguments: action,
+      raw: {
+        type: "hosted_tool_call",
+        id: itemId,
+        name: "web_search_call",
+        status,
+        providerData,
+      },
+    },
+  };
+}
+
 export function normalizeSdkEvent(event: RunStreamEvent): NormalizedRuntimeEvent[] {
   const out: NormalizedRuntimeEvent[] = [];
   if (event.type === "raw_model_stream_event") {
@@ -5022,6 +5204,10 @@ export function normalizeSdkEvent(event: RunStreamEvent): NormalizedRuntimeEvent
     if (raw?.type === "response.reasoning_summary_text.delta" && typeof raw.delta === "string") {
       out.push({ type: "agent.reasoning.delta", payload: { text: raw.delta } });
     }
+    const webSearch = hostedWebSearchToolCallFromResponsesEvent(raw);
+    if (webSearch) {
+      out.push(webSearch);
+    }
     return out;
   }
   if (event.type === "agent_updated_stream_event") {
@@ -5120,12 +5306,65 @@ export function modelResponseUsageFromResponse(response: unknown): ModelResponse
       : typeof (response as { responseId?: unknown } | null)?.responseId === "string"
         ? (response as { responseId: string }).responseId
         : undefined;
+  const serviceTier = modelResponseServiceTierFromResponse(response);
   return {
     ...(responseId ? { responseId } : {}),
+    ...(serviceTier ? { serviceTier } : {}),
     usage,
   };
 }
 
+export type ModelResponseServiceTierEvent = {
+  source: "normalized" | "provider";
+  serviceTier: string | null;
+};
+
+/**
+ * Read the provider's terminal service tier without depending on usage being
+ * present. The normalized terminal can omit provider-only fields, so callers
+ * should treat the raw provider response as the fail-closed authority.
+ */
+export function modelResponseServiceTierFromSdkEvent(
+  event: RunStreamEvent,
+): ModelResponseServiceTierEvent | null {
+  if (event.type === "raw_model_stream_event") {
+    const data = (event as any).data;
+    if (data?.type === "response_done") {
+      return {
+        source: "normalized",
+        serviceTier: modelResponseServiceTierFromResponse(data.response),
+      };
+    }
+  }
+  if (isOpenAIResponsesRawModelStreamEvent(event)) {
+    const raw = (event as any).data?.event;
+    if (raw?.type === "response.completed") {
+      return {
+        source: "provider",
+        serviceTier: modelResponseServiceTierFromResponse(raw.response),
+      };
+    }
+  }
+  return null;
+}
+
+function modelResponseServiceTierFromResponse(response: unknown): string | null {
+  if (!response || typeof response !== "object") {
+    return null;
+  }
+  const record = response as Record<string, unknown>;
+  const direct = record.service_tier ?? record.serviceTier;
+  if (typeof direct === "string" && direct.length > 0) {
+    return direct;
+  }
+  const providerData =
+    record.providerData && typeof record.providerData === "object"
+      ? (record.providerData as Record<string, unknown>)
+      : null;
+  const nested = providerData?.service_tier ?? providerData?.serviceTier;
+  return typeof nested === "string" && nested.length > 0 ? nested : null;
+}
+
 function modelResponseFromSdkEvent(event: RunStreamEvent): any {
   if (event.type === "raw_model_stream_event") {
     const data = (event as any).data;