@code-yeongyu/senpi 2026.8.25 → 2026.8.26

package/node_modules/@anthropic-ai/sdk/src/lib/sessions/accumulate.ts

@@ -0,0 +1,130 @@
+import { AnthropicError } from '../../core/error';
+import type {
+  BetaManagedAgentsAgentMessageEvent,
+  BetaManagedAgentsStreamSessionEvents,
+} from '../../resources/beta/sessions/events';
+
+export type AccumulatedEvent = BetaManagedAgentsAgentMessageEvent;
+
+/**
+ * Fold one preview event into an `agent.message` snapshot. Returns a fresh
+ * snapshot — the `msg` argument is never mutated.
+ *
+ * - `event_start` opens the preview: a new snapshot with empty content is
+ *   returned (so `msg` may be `undefined`). Returns `undefined` when the
+ *   previewed event is not an `agent.message` — this helper only tracks
+ *   `agent.message` previews.
+ * - `event_delta` is folded into `msg`: a new `delta.index` inserts the
+ *   fragment as a fresh content entry; an existing index returns a copy with
+ *   that entry appended to. An unrecognised fragment type on an existing
+ *   index passes the entry through unchanged — deltas are best-effort and the
+ *   buffered final event is canonical — but is a compile-time error via the
+ *   exhaustiveness guard, matching `MessageStream#accumulateMessage`.
+ * - `agent.message` is the buffered final event: a copy of it is returned,
+ *   replacing whatever the preview had accumulated.
+ */
+export function accumulateManagedAgentsEvent<T extends AccumulatedEvent>(
+  accumulated: AccumulatedEvent | undefined,
+  event: T,
+): T;
+export function accumulateManagedAgentsEvent(
+  accumulated: AccumulatedEvent | undefined,
+  event: BetaManagedAgentsStreamSessionEvents,
+): AccumulatedEvent | undefined;
+export function accumulateManagedAgentsEvent(
+  accumulated: AccumulatedEvent | undefined,
+  event: BetaManagedAgentsStreamSessionEvents,
+): AccumulatedEvent | undefined {
+  switch (event.type) {
+    case 'event_start': {
+      if (event.event.type === 'agent.message') {
+        return { id: event.event.id, type: 'agent.message', content: [], processed_at: '' };
+      }
+
+      return accumulated;
+    }
+
+    case 'agent.message': {
+      return { ...event, content: event.content.map((block) => ({ ...block })) };
+    }
+
+    case 'event_delta': {
+      if (accumulated === undefined) {
+        throw new AnthropicError(`event_delta for ${event.event_id} received before its event_start`);
+      }
+
+      const idx = event.delta.index ?? 0;
+      const fragment = event.delta.content;
+
+      // Indices arrive in order — the first delta at a new index opens the slot.
+      // A gap means deltas arrived out of order or were mis-routed.
+      if (idx > accumulated.content.length) {
+        throw new AnthropicError(
+          `event_delta index ${idx} is beyond the end of content (length ${accumulated.content.length})`,
+        );
+      }
+
+      const existing = accumulated.content[idx];
+      if (existing === undefined) {
+        // New index: pass the fragment through as a fresh block.
+        return { ...accumulated, content: [...accumulated.content, { ...fragment }] };
+      }
+
+      let updated = existing;
+      switch (fragment.type) {
+        case 'text':
+          if (existing.type === 'text') {
+            updated = { ...existing, text: existing.text + fragment.text };
+          }
+          break;
+        default:
+          checkNever(fragment.type);
+      }
+
+      const content = accumulated.content.slice();
+      content[idx] = updated;
+      return { ...accumulated, content };
+    }
+    case 'user.message':
+    case 'user.interrupt':
+    case 'user.tool_confirmation':
+    case 'user.tool_result':
+    case 'user.custom_tool_result':
+    case 'user.define_outcome':
+    case 'agent.thinking':
+    case 'agent.tool_use':
+    case 'agent.tool_result':
+    case 'agent.custom_tool_use':
+    case 'agent.mcp_tool_use':
+    case 'agent.mcp_tool_result':
+    case 'agent.thread_message_received':
+    case 'agent.thread_message_sent':
+    case 'agent.thread_context_compacted':
+    case 'session.error':
+    case 'session.updated':
+    case 'session.deleted':
+    case 'session.usage':
+    case 'session.status_running':
+    case 'session.status_idle':
+    case 'session.status_rescheduled':
+    case 'session.status_terminated':
+    case 'session.thread_created':
+    case 'session.thread_status_running':
+    case 'session.thread_status_idle':
+    case 'session.thread_status_rescheduled':
+    case 'session.thread_status_terminated':
+    case 'span.model_request_start':
+    case 'span.model_request_end':
+    case 'span.outcome_evaluation_start':
+    case 'span.outcome_evaluation_ongoing':
+    case 'span.outcome_evaluation_end':
+    case 'system.message':
+      return accumulated;
+    default:
+      checkNever(event);
+      return accumulated;
+  }
+}
+
+// Compile-time exhaustiveness guard.
+function checkNever(_x: never): void {}

package/node_modules/@anthropic-ai/sdk/src/lib/tools/BetaRunnableTool.ts

@@ -11,15 +11,18 @@ import {
   BetaToolTextEditor20250124,
   BetaToolTextEditor20250429,
   BetaToolTextEditor20250728,
+  BetaToolUnion,
   BetaToolUseBlock,
 } from '../../resources/beta';
+import type {
+  BetaManagedAgentsAgentCustomToolUseEvent,
+  BetaManagedAgentsAgentToolUseEvent,
+} from '../../resources/beta/sessions/events';
+import { ToolError } from './ToolError';
 
 export type Promisable<T> = T | Promise<T>;
 
-/**
- * Tool types that can be implemented on the client.
- * Excludes server-side tools like code execution, web search, and MCP toolsets.
- */
+/** Tools that run on the client. Server-side tools (code execution, web search, MCP toolsets) are not included. */
 export type BetaClientRunnableToolType =
   | BetaTool
   | BetaMemoryTool20250818
@@ -33,17 +36,78 @@ export type BetaClientRunnableToolType =
   | BetaToolTextEditor20250429
   | BetaToolTextEditor20250728;
 
+/**
+ * The tool call being served: a Messages `tool_use` block, or a session
+ * `agent.tool_use` / `agent.custom_tool_use` event. All three carry `id`,
+ * `name` and `input`.
+ */
+export type BetaToolUse =
+  | BetaToolUseBlock
+  | BetaManagedAgentsAgentToolUseEvent
+  | BetaManagedAgentsAgentCustomToolUseEvent;
+
 export type BetaToolRunContext = {
-  toolUseBlock: BetaToolUseBlock;
+  toolUse: BetaToolUse;
+  /** @deprecated Use `toolUse`. */
+  toolUseBlock: BetaToolUse;
+  /**
+   * Aborted when the runner is aborted or, in the session runner, when the
+   * per-tool timeout fires. The runner still waits for `run` to return, so
+   * check it in long-running work.
+   */
   signal?: AbortSignal | null | undefined;
 };
 
-// this type is just an extension of BetaTool with a run and parse method
-// that will be called by `toolRunner()` helpers
+/** A tool definition plus the `run` and `parse` the tool runners call. */
 export type BetaRunnableTool<Input = any> = BetaClientRunnableToolType & {
+  /**
+   * Runs on the event loop: a body that blocks synchronously stalls the runner
+   * and, in an `EnvironmentWorker`, the lease heartbeat. Await async work or
+   * move it to a worker thread.
+   */
   run: (
     args: Input,
     context?: BetaToolRunContext,
   ) => Promisable<string | Array<BetaToolResultContentBlockParam>>;
   parse: (content: unknown) => Input;
+  /** Called once by the session runner when it stops. Release held resources here (e.g. a shell). */
+  close?: () => Promisable<void>;
 };
+
+/**
+ * The name the model calls a tool by: `mcp_server_name` for MCP toolsets, `type` for nameless server
+ * toolsets (browser/computer), `name` for everything else.
+ */
+export function toolName(tool: BetaToolUnion | BetaRunnableTool): string {
+  return (
+    'name' in tool ? tool.name
+    : 'mcp_server_name' in tool ? tool.mcp_server_name
+    : tool.type
+  );
+}
+
+/** Tool-result content for a thrown value: a {@link ToolError}'s own content, otherwise `Error: <message>`. */
+export function toolErrorContent(e: unknown): string | Array<BetaToolResultContentBlockParam> {
+  return e instanceof ToolError ? e.content : `Error: ${e instanceof Error ? e.message : String(e)}`;
+}
+
+/** What a tool run produced, and whether it failed. */
+export interface RunnableToolOutcome {
+  content: string | Array<BetaToolResultContentBlockParam>;
+  isError: boolean;
+}
+
+/** Parse the input, run the tool, and turn anything thrown into an error result. */
+export async function runRunnableTool(
+  tool: BetaRunnableTool,
+  rawInput: unknown,
+  context: BetaToolRunContext,
+): Promise<RunnableToolOutcome> {
+  try {
+    const input = tool.parse ? tool.parse(rawInput) : rawInput;
+    const content = await tool.run(input, context);
+    return { content, isError: false };
+  } catch (e) {
+    return { content: toolErrorContent(e), isError: true };
+  }
+}

package/node_modules/@anthropic-ai/sdk/src/lib/tools/BetaToolRunner.ts

@@ -2,29 +2,28 @@ import { BetaRunnableTool } from './BetaRunnableTool';
 import { ToolError } from './ToolError';
 import { Anthropic } from '../..';
 import { AnthropicError } from '../../core/error';
-import { BetaMessage, BetaMessageParam, BetaToolUnion, MessageCreateParams } from '../../resources/beta';
+import {
+  BetaContentBlockParam,
+  BetaMessage,
+  BetaMessageParam,
+  BetaRequestToolAdditionBlock,
+  BetaRequestToolRemovalBlock,
+  BetaToolChangeMCPToolReference,
+  BetaToolChangeMCPToolsetReference,
+  BetaToolChangeToolReference,
+  BetaToolUnion,
+  MessageCreateParams,
+} from '../../resources/beta';
 import { BetaMessageStream } from '../BetaMessageStream';
 import { RequestOptions } from '../../internal/request-options';
 import { buildHeaders } from '../../internal/headers';
+import { promiseWithResolvers } from '../../internal/utils/promise';
 import { CompactionControl, DEFAULT_SUMMARY_PROMPT, DEFAULT_TOKEN_THRESHOLD } from './CompactionControl';
-import { collectStainlessHelpers } from '../stainless-helper-header';
-
-/**
- * Just Promise.withResolvers(), which is not available in all environments.
- */
-function promiseWithResolvers<T>(): {
-  promise: Promise<T>;
-  resolve: (value: T) => void;
-  reject: (reason?: any) => void;
-} {
-  let resolve: (value: T) => void;
-  let reject: (reason?: any) => void;
-  const promise = new Promise<T>((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return { promise, resolve: resolve!, reject: reject! };
-}
+import {
+  collectStainlessHelpers,
+  helperHeader,
+  STAINLESS_HELPER_HEADER,
+} from '../../internal/stainless-helper-header';
 
 /**
  * A ToolRunner handles the automatic conversation loop between the assistant and tools.
@@ -68,12 +67,17 @@ export class BetaToolRunner<Stream extends boolean> {
       },
     };
 
-    const helpers = collectStainlessHelpers(params.tools, params.messages);
-    const helperValue = ['BetaToolRunner', ...helpers].join(', ');
-
+    // structuredClone drops symbol-keyed properties, so collect helper marks
+    // from the original params here — the create()-side collector won't see
+    // them on the cloned messages.
+    const collected = collectStainlessHelpers(params.tools, params.messages);
     this.#options = {
       ...options,
-      headers: buildHeaders([{ 'x-stainless-helper': helperValue }, options?.headers]),
+      headers: buildHeaders([
+        helperHeader('BetaToolRunner'),
+        collected.length ? { [STAINLESS_HELPER_HEADER]: collected.join(', ') } : undefined,
+        options?.headers,
+      ]),
     };
     this.#completion = promiseWithResolvers();
 
@@ -153,7 +157,7 @@ export class BetaToolRunner<Stream extends boolean> {
       },
       {
         signal: this.#options.signal,
-        headers: buildHeaders([this.#options.headers, { 'x-stainless-helper': 'compaction' }]),
+        headers: buildHeaders([this.#options.headers, helperHeader('compaction')]),
       },
     );
 
@@ -215,8 +219,28 @@ export class BetaToolRunner<Stream extends boolean> {
           const isCompacted = await this.#checkAndCompact();
           if (!isCompacted) {
             if (!this.#mutated) {
-              const { role, content } = await this.#message;
-              this.#state.params.messages.push({ role, content });
+              const message = await this.#message;
+              this.#state.params.messages.push({ role: message.role, content: message.content });
+
+              // Container-bound server tools reject a follow-up request that omits the container the
+              // previous turn ran in, so carry its id forward unless the caller pinned one themselves.
+              const { container } = this.#state.params;
+              if (message.container) {
+                if (container == null) {
+                  this.#state.params.container = message.container.id;
+                } else if (typeof container === 'object' && container.id == null) {
+                  this.#state.params.container = { ...container, id: message.container.id };
+                }
+              }
+
+              // Refusal-terminated turns are terminal: the refusal may have cut a tool_use off
+              // with partial input, so executing this turn's tools would fire side effects the
+              // model never confirmed — and once middleware strips the refusal turn, their
+              // tool_results could never be replayed coherently. Surface the refusal as the
+              // final message instead.
+              if (message.stop_reason === 'refusal') {
+                break;
+              }
             }
 
             const toolMessage = await this.#generateToolResponse(this.#state.params.messages.at(-1)!);
@@ -465,16 +489,19 @@ async function generateToolResponse(
     return null;
   }
 
+  const available = availableToolNames(params);
   const toolResults = await Promise.all(
     toolUseBlocks.map(async (toolUse) => {
-      const tool = params.tools.find((t) => ('name' in t ? t.name : t.mcp_server_name) === toolUse.name);
-      if (!tool || !('run' in tool)) {
-        return {
-          type: 'tool_result' as const,
-          tool_use_id: toolUse.id,
-          content: `Error: Tool '${toolUse.name}' not found`,
-          is_error: true,
-        };
+      const tool = params.tools.find(
+        (t) =>
+          ('name' in t ? t.name
+          : 'mcp_server_name' in t ? t.mcp_server_name
+          : t.type) === toolUse.name,
+      );
+      // A `tool_removal` is only a hint to the model, which may still emit a tool_use for a
+      // withdrawn tool — treat those exactly like a tool that was never defined.
+      if (!tool || !('run' in tool) || !available.has(toolUse.name)) {
+        return toolNotFoundResult(toolUse);
       }
 
       try {
@@ -484,6 +511,7 @@ async function generateToolResponse(
         }
 
         const result = await tool.run(input, {
+          toolUse: toolUse,
           toolUseBlock: toolUse,
           signal: requestOptions?.signal,
         });
@@ -512,6 +540,78 @@ async function generateToolResponse(
   };
 }
 
+function toolNotFoundResult(toolUse: { id: string; name: string }) {
+  return {
+    type: 'tool_result' as const,
+    tool_use_id: toolUse.id,
+    content: `Error: Tool '${toolUse.name}' not found`,
+    is_error: true,
+  };
+}
+
+/**
+ * Computes the names of locally runnable tools that are still available for the assistant
+ * turn being answered, by folding `tool_removal` / `tool_addition` blocks from the
+ * `role: "system"` messages over the runnable tools. The assistant turn being answered is
+ * terminal-or-absent and only `system` messages are inspected, so folding the whole current
+ * history is exactly folding the messages preceding that turn — call this before appending
+ * anything after it. MCP references are ignored — those tools are executed server-side and
+ * never dispatched by this runner.
+ */
+function availableToolNames(params: BetaToolRunnerParams): Set<string> {
+  const available = new Set<string>();
+  for (const tool of params.tools) {
+    if ('run' in tool) {
+      available.add(tool.name);
+    }
+  }
+
+  for (const message of params.messages) {
+    if (message.role !== 'system' || typeof message.content === 'string') {
+      continue;
+    }
+    for (const block of message.content) {
+      applyToolChange(block, available);
+    }
+  }
+  return available;
+}
+
+function applyToolChange(block: BetaContentBlockParam, available: Set<string>): void {
+  switch (block.type) {
+    case 'tool_removal':
+    case 'tool_addition':
+      applyToolReference(block, available);
+      break;
+  }
+}
+
+function applyToolReference(
+  block: BetaRequestToolAdditionBlock | BetaRequestToolRemovalBlock,
+  available: Set<string>,
+): void {
+  const name = referencedToolName(block.tool);
+  if (name === undefined) return;
+  if (block.type === 'tool_removal') {
+    available.delete(name);
+  } else {
+    available.add(name);
+  }
+}
+
+function referencedToolName(
+  ref: BetaToolChangeToolReference | BetaToolChangeMCPToolReference | BetaToolChangeMCPToolsetReference,
+): string | undefined {
+  switch (ref.type) {
+    case 'tool_reference':
+      return ref.name;
+    default:
+      // mcp_tool_reference / mcp_toolset_reference run server-side; unknown reference
+      // types are ignored rather than rejected.
+      return undefined;
+  }
+}
+
 // vendored from typefest just to make things look a bit nicer on hover
 type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
 
@@ -536,4 +636,4 @@ export type BetaToolRunnerParams = Simplify<
   }
 >;
 
-export type BetaToolRunnerRequestOptions = Pick<RequestOptions, 'headers' | 'signal'>;
+export type BetaToolRunnerRequestOptions = Pick<RequestOptions, 'headers' | 'signal' | 'fallbackState'>;