@oneie/claude 0.4.0 → 0.6.0

package/scripts/node_modules/@anthropic-ai/sdk/src/resources/beta/sessions/events.ts

@@ -0,0 +1,1958 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import type { Anthropic } from '../../../client';
+import { APIResource } from '../../../core/resource';
+import * as BetaAPI from '../beta';
+import * as SessionsAPI from './sessions';
+import { APIPromise } from '../../../core/api-promise';
+import { PageCursor, type PageCursorParams, PagePromise } from '../../../core/pagination';
+import { Stream } from '../../../core/streaming';
+import { buildHeaders } from '../../../internal/headers';
+import { RequestOptions } from '../../../internal/request-options';
+import { path } from '../../../internal/utils/path';
+import {
+  SessionToolRunner,
+  type SessionToolRunnerOptions as RunnerSessionToolRunnerOptions,
+} from '../../../lib/tools/SessionToolRunner';
+
+export class Events extends APIResource {
+  /**
+   * List Events
+   *
+   * @example
+   * ```ts
+   * // Automatically fetches more pages as needed.
+   * for await (const betaManagedAgentsSessionEvent of client.beta.sessions.events.list(
+   *   'sesn_011CZkZAtmR3yMPDzynEDxu7',
+   * )) {
+   *   // ...
+   * }
+   * ```
+   */
+  list(
+    sessionID: string,
+    params: EventListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): PagePromise<BetaManagedAgentsSessionEventsPageCursor, BetaManagedAgentsSessionEvent> {
+    const { betas, ...query } = params ?? {};
+    return this._client.getAPIList(
+      path`/v1/sessions/${sessionID}/events?beta=true`,
+      PageCursor<BetaManagedAgentsSessionEvent>,
+      {
+        query,
+        ...options,
+        headers: buildHeaders([
+          { 'anthropic-beta': [...(betas ?? []), 'managed-agents-2026-04-01'].toString() },
+          options?.headers,
+        ]),
+      },
+    );
+  }
+
+  /**
+   * Send Events
+   *
+   * @example
+   * ```ts
+   * const betaManagedAgentsSendSessionEvents =
+   *   await client.beta.sessions.events.send(
+   *     'sesn_011CZkZAtmR3yMPDzynEDxu7',
+   *     {
+   *       events: [
+   *         {
+   *           content: [
+   *             {
+   *               text: 'Where is my order #1234?',
+   *               type: 'text',
+   *             },
+   *           ],
+   *           type: 'user.message',
+   *         },
+   *       ],
+   *     },
+   *   );
+   * ```
+   */
+  send(
+    sessionID: string,
+    params: EventSendParams,
+    options?: RequestOptions,
+  ): APIPromise<BetaManagedAgentsSendSessionEvents> {
+    const { betas, ...body } = params;
+    return this._client.post(path`/v1/sessions/${sessionID}/events?beta=true`, {
+      body,
+      ...options,
+      headers: buildHeaders([
+        { 'anthropic-beta': [...(betas ?? []), 'managed-agents-2026-04-01'].toString() },
+        options?.headers,
+      ]),
+    });
+  }
+
+  /**
+   * Stream Events
+   *
+   * @example
+   * ```ts
+   * const betaManagedAgentsStreamSessionEvents =
+   *   await client.beta.sessions.events.stream(
+   *     'sesn_011CZkZAtmR3yMPDzynEDxu7',
+   *   );
+   * ```
+   */
+  stream(
+    sessionID: string,
+    params: EventStreamParams | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<Stream<BetaManagedAgentsStreamSessionEvents>> {
+    const { betas } = params ?? {};
+    return this._client.get(path`/v1/sessions/${sessionID}/events/stream?beta=true`, {
+      ...options,
+      headers: buildHeaders([
+        { 'anthropic-beta': [...(betas ?? []), 'managed-agents-2026-04-01'].toString() },
+        options?.headers,
+      ]),
+      stream: true,
+    }) as APIPromise<Stream<BetaManagedAgentsStreamSessionEvents>>;
+  }
+
+  /**
+   * Attach to a session and dispatch every incoming `agent.tool_use` and
+   * `agent.custom_tool_use` event to a local tool registry, sending the matching
+   * result back (`user.tool_result` / `user.custom_tool_result`). The
+   * sessions-side counterpart to `client.beta.messages.toolRunner`: yields one
+   * entry per completed tool call so callers can observe each dispatch (and
+   * `break` to abort cleanly).
+   *
+   * @example
+   * ```ts
+   * import { betaAgentToolset20260401 } from '@anthropic-ai/sdk/tools/agent-toolset/node';
+   *
+   * for await (const call of client.beta.sessions.events.toolRunner(work.data.id, {
+   *   tools: [...betaAgentToolset20260401({ workdir }), myTool],
+   * })) {
+   *   console.log(`${call.name} -> ${call.isError ? 'error' : 'ok'}`);
+   * }
+   * ```
+   */
+  toolRunner(sessionID: string, opts: Omit<RunnerSessionToolRunnerOptions, 'client'>): SessionToolRunner {
+    return new SessionToolRunner(sessionID, { ...opts, client: this._client as Anthropic });
+  }
+}
+
+export type BetaManagedAgentsSessionEventsPageCursor = PageCursor<BetaManagedAgentsSessionEvent>;
+
+/**
+ * Event emitted when the agent calls a custom tool. The session goes idle until
+ * the client sends a `user.custom_tool_result` event with the result.
+ */
+export interface BetaManagedAgentsAgentCustomToolUseEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * Input parameters for the tool call.
+   */
+  input: { [key: string]: unknown };
+
+  /**
+   * Name of the custom tool being called.
+   */
+  name: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  type: 'agent.custom_tool_use';
+
+  /**
+   * When set, this event was cross-posted from a subagent's thread to surface its
+   * custom tool use on the primary thread's stream. Empty on the thread's own
+   * events. Echo this on a `user.custom_tool_result` event to route the result back.
+   */
+  session_thread_id?: string | null;
+}
+
+/**
+ * Event representing the result of an MCP tool execution.
+ */
+export interface BetaManagedAgentsAgentMCPToolResultEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * The id of the `agent.mcp_tool_use` event this result corresponds to.
+   */
+  mcp_tool_use_id: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  type: 'agent.mcp_tool_result';
+
+  /**
+   * The result content returned by the tool.
+   */
+  content?: Array<
+    | BetaManagedAgentsTextBlock
+    | BetaManagedAgentsImageBlock
+    | BetaManagedAgentsDocumentBlock
+    | BetaManagedAgentsSearchResultBlock
+  >;
+
+  /**
+   * Whether the tool execution resulted in an error.
+   */
+  is_error?: boolean | null;
+}
+
+/**
+ * Event emitted when the agent invokes a tool provided by an MCP server.
+ */
+export interface BetaManagedAgentsAgentMCPToolUseEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * Input parameters for the tool call.
+   */
+  input: { [key: string]: unknown };
+
+  /**
+   * Name of the MCP server providing the tool.
+   */
+  mcp_server_name: string;
+
+  /**
+   * Name of the MCP tool being used.
+   */
+  name: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  type: 'agent.mcp_tool_use';
+
+  /**
+   * AgentEvaluatedPermission enum
+   */
+  evaluated_permission?: 'allow' | 'ask' | 'deny';
+
+  /**
+   * When set, this event was cross-posted from a subagent's thread to surface its
+   * permission request on the primary thread's stream. Empty on the thread's own
+   * events. Echo this on a `user.tool_confirmation` event to route the approval
+   * back.
+   */
+  session_thread_id?: string | null;
+}
+
+/**
+ * An agent response event in the session conversation.
+ */
+export interface BetaManagedAgentsAgentMessageEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * Array of text blocks comprising the agent response.
+   */
+  content: Array<BetaManagedAgentsTextBlock>;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  type: 'agent.message';
+}
+
+/**
+ * Indicates the agent is making forward progress via extended thinking. A progress
+ * signal, not a content carrier.
+ */
+export interface BetaManagedAgentsAgentThinkingEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  type: 'agent.thinking';
+}
+
+/**
+ * Indicates that context compaction (summarization) occurred during the session.
+ */
+export interface BetaManagedAgentsAgentThreadContextCompactedEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  type: 'agent.thread_context_compacted';
+}
+
+/**
+ * Delivery event written to the target thread's input stream when an
+ * agent-to-agent message arrives.
+ */
+export interface BetaManagedAgentsAgentThreadMessageReceivedEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * Message content blocks.
+   */
+  content: Array<BetaManagedAgentsTextBlock | BetaManagedAgentsImageBlock | BetaManagedAgentsDocumentBlock>;
+
+  /**
+   * Public `sthr_` ID of the thread that sent the message.
+   */
+  from_session_thread_id: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  type: 'agent.thread_message_received';
+
+  /**
+   * Name of the callable agent this message came from. Absent when received from the
+   * primary agent.
+   */
+  from_agent_name?: string | null;
+}
+
+/**
+ * Observability event emitted to the sender's output stream when an agent-to-agent
+ * message is sent.
+ */
+export interface BetaManagedAgentsAgentThreadMessageSentEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * Message content blocks.
+   */
+  content: Array<BetaManagedAgentsTextBlock | BetaManagedAgentsImageBlock | BetaManagedAgentsDocumentBlock>;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  /**
+   * Public `sthr_` ID of the thread the message was sent to.
+   */
+  to_session_thread_id: string;
+
+  type: 'agent.thread_message_sent';
+
+  /**
+   * Name of the callable agent this message was sent to. Absent when sent to the
+   * primary agent.
+   */
+  to_agent_name?: string | null;
+}
+
+/**
+ * Event representing the result of an agent tool execution.
+ */
+export interface BetaManagedAgentsAgentToolResultEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  /**
+   * The id of the `agent.tool_use` event this result corresponds to.
+   */
+  tool_use_id: string;
+
+  type: 'agent.tool_result';
+
+  /**
+   * The result content returned by the tool.
+   */
+  content?: Array<
+    | BetaManagedAgentsTextBlock
+    | BetaManagedAgentsImageBlock
+    | BetaManagedAgentsDocumentBlock
+    | BetaManagedAgentsSearchResultBlock
+  >;
+
+  /**
+   * Whether the tool execution resulted in an error.
+   */
+  is_error?: boolean | null;
+}
+
+/**
+ * Event emitted when the agent invokes a built-in agent tool.
+ */
+export interface BetaManagedAgentsAgentToolUseEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * Input parameters for the tool call.
+   */
+  input: { [key: string]: unknown };
+
+  /**
+   * Name of the agent tool being used.
+   */
+  name: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  type: 'agent.tool_use';
+
+  /**
+   * AgentEvaluatedPermission enum
+   */
+  evaluated_permission?: 'allow' | 'ask' | 'deny';
+
+  /**
+   * When set, this event was cross-posted from a subagent's thread to surface its
+   * permission request on the primary thread's stream. Empty on the thread's own
+   * events. Echo this on a `user.tool_confirmation` event to route the approval
+   * back.
+   */
+  session_thread_id?: string | null;
+}
+
+/**
+ * Base64-encoded document data.
+ */
+export interface BetaManagedAgentsBase64DocumentSource {
+  /**
+   * Base64-encoded document data.
+   */
+  data: string;
+
+  /**
+   * MIME type of the document (e.g., "application/pdf").
+   */
+  media_type: string;
+
+  type: 'base64';
+}
+
+/**
+ * Base64-encoded image data.
+ */
+export interface BetaManagedAgentsBase64ImageSource {
+  /**
+   * Base64-encoded image data.
+   */
+  data: string;
+
+  /**
+   * MIME type of the image (e.g., "image/png", "image/jpeg", "image/gif",
+   * "image/webp").
+   */
+  media_type: string;
+
+  type: 'base64';
+}
+
+/**
+ * The caller's organization or workspace cannot make model requests — out of
+ * credits or spend limit reached. Retrying with the same credentials will not
+ * succeed; the caller must resolve the billing state.
+ */
+export interface BetaManagedAgentsBillingError {
+  /**
+   * Human-readable error description.
+   */
+  message: string;
+
+  /**
+   * What the client should do next in response to this error.
+   */
+  retry_status:
+    | BetaManagedAgentsRetryStatusRetrying
+    | BetaManagedAgentsRetryStatusExhausted
+    | BetaManagedAgentsRetryStatusTerminal;
+
+  type: 'billing_error';
+}
+
+/**
+ * Document content, either specified directly as base64 data, as text, or as a
+ * reference via a URL.
+ */
+export interface BetaManagedAgentsDocumentBlock {
+  /**
+   * Union type for document source variants.
+   */
+  source:
+    | BetaManagedAgentsBase64DocumentSource
+    | BetaManagedAgentsPlainTextDocumentSource
+    | BetaManagedAgentsURLDocumentSource
+    | BetaManagedAgentsFileDocumentSource;
+
+  type: 'document';
+
+  /**
+   * Additional context about the document for the model.
+   */
+  context?: string | null;
+
+  /**
+   * The title of the document.
+   */
+  title?: string | null;
+}
+
+/**
+ * Union type for event parameters that can be sent to a session.
+ */
+export type BetaManagedAgentsEventParams =
+  | BetaManagedAgentsUserMessageEventParams
+  | BetaManagedAgentsUserInterruptEventParams
+  | BetaManagedAgentsUserToolConfirmationEventParams
+  | BetaManagedAgentsUserCustomToolResultEventParams
+  | BetaManagedAgentsUserDefineOutcomeEventParams
+  | BetaManagedAgentsUserToolResultEventParams;
+
+/**
+ * Document referenced by file ID.
+ */
+export interface BetaManagedAgentsFileDocumentSource {
+  /**
+   * ID of a previously uploaded file.
+   */
+  file_id: string;
+
+  type: 'file';
+}
+
+/**
+ * Image referenced by file ID.
+ */
+export interface BetaManagedAgentsFileImageSource {
+  /**
+   * ID of a previously uploaded file.
+   */
+  file_id: string;
+
+  type: 'file';
+}
+
+/**
+ * Rubric referenced by a file uploaded via the Files API.
+ */
+export interface BetaManagedAgentsFileRubric {
+  /**
+   * ID of the rubric file.
+   */
+  file_id: string;
+
+  type: 'file';
+}
+
+/**
+ * Rubric referenced by a file uploaded via the Files API.
+ */
+export interface BetaManagedAgentsFileRubricParams {
+  /**
+   * ID of the rubric file.
+   */
+  file_id: string;
+
+  type: 'file';
+}
+
+/**
+ * Image content specified directly as base64 data or as a reference via a URL.
+ */
+export interface BetaManagedAgentsImageBlock {
+  /**
+   * Union type for image source variants.
+   */
+  source:
+    | BetaManagedAgentsBase64ImageSource
+    | BetaManagedAgentsURLImageSource
+    | BetaManagedAgentsFileImageSource;
+
+  type: 'image';
+}
+
+/**
+ * Authentication to an MCP server failed.
+ */
+export interface BetaManagedAgentsMCPAuthenticationFailedError {
+  /**
+   * Name of the MCP server that failed authentication.
+   */
+  mcp_server_name: string;
+
+  /**
+   * Human-readable error description.
+   */
+  message: string;
+
+  /**
+   * What the client should do next in response to this error.
+   */
+  retry_status:
+    | BetaManagedAgentsRetryStatusRetrying
+    | BetaManagedAgentsRetryStatusExhausted
+    | BetaManagedAgentsRetryStatusTerminal;
+
+  type: 'mcp_authentication_failed_error';
+}
+
+/**
+ * Failed to connect to an MCP server.
+ */
+export interface BetaManagedAgentsMCPConnectionFailedError {
+  /**
+   * Name of the MCP server that failed to connect.
+   */
+  mcp_server_name: string;
+
+  /**
+   * Human-readable error description.
+   */
+  message: string;
+
+  /**
+   * What the client should do next in response to this error.
+   */
+  retry_status:
+    | BetaManagedAgentsRetryStatusRetrying
+    | BetaManagedAgentsRetryStatusExhausted
+    | BetaManagedAgentsRetryStatusTerminal;
+
+  type: 'mcp_connection_failed_error';
+}
+
+/**
+ * The model is currently overloaded. Emitted after automatic retries are
+ * exhausted.
+ */
+export interface BetaManagedAgentsModelOverloadedError {
+  /**
+   * Human-readable error description.
+   */
+  message: string;
+
+  /**
+   * What the client should do next in response to this error.
+   */
+  retry_status:
+    | BetaManagedAgentsRetryStatusRetrying
+    | BetaManagedAgentsRetryStatusExhausted
+    | BetaManagedAgentsRetryStatusTerminal;
+
+  type: 'model_overloaded_error';
+}
+
+/**
+ * The model request was rate-limited.
+ */
+export interface BetaManagedAgentsModelRateLimitedError {
+  /**
+   * Human-readable error description.
+   */
+  message: string;
+
+  /**
+   * What the client should do next in response to this error.
+   */
+  retry_status:
+    | BetaManagedAgentsRetryStatusRetrying
+    | BetaManagedAgentsRetryStatusExhausted
+    | BetaManagedAgentsRetryStatusTerminal;
+
+  type: 'model_rate_limited_error';
+}
+
+/**
+ * A model request failed for a reason other than overload or rate-limiting.
+ */
+export interface BetaManagedAgentsModelRequestFailedError {
+  /**
+   * Human-readable error description.
+   */
+  message: string;
+
+  /**
+   * What the client should do next in response to this error.
+   */
+  retry_status:
+    | BetaManagedAgentsRetryStatusRetrying
+    | BetaManagedAgentsRetryStatusExhausted
+    | BetaManagedAgentsRetryStatusTerminal;
+
+  type: 'model_request_failed_error';
+}
+
+/**
+ * Plain text document content.
+ */
+export interface BetaManagedAgentsPlainTextDocumentSource {
+  /**
+   * The plain text content.
+   */
+  data: string;
+
+  /**
+   * MIME type of the text content. Must be "text/plain".
+   */
+  media_type: 'text/plain';
+
+  type: 'text';
+}
+
+/**
+ * This turn is dead; queued inputs are flushed and the session returns to idle.
+ * Client may send a new prompt.
+ */
+export interface BetaManagedAgentsRetryStatusExhausted {
+  type: 'exhausted';
+}
+
+/**
+ * The server is retrying automatically. Client should wait; the same error type
+ * may fire again as retrying, then once as exhausted when the retry budget runs
+ * out.
+ */
+export interface BetaManagedAgentsRetryStatusRetrying {
+  type: 'retrying';
+}
+
+/**
+ * The session encountered a terminal error and will transition to `terminated`
+ * state.
+ */
+export interface BetaManagedAgentsRetryStatusTerminal {
+  type: 'terminal';
+}
+
+/**
+ * A block containing a web search result.
+ */
+export interface BetaManagedAgentsSearchResultBlock {
+  /**
+   * Citation settings for a search result.
+   */
+  citations: BetaManagedAgentsSearchResultCitations;
+
+  /**
+   * Array of text content blocks from the search result.
+   */
+  content: Array<BetaManagedAgentsSearchResultContent>;
+
+  /**
+   * The URL source of the search result.
+   */
+  source: string;
+
+  /**
+   * The title of the search result.
+   */
+  title: string;
+
+  type: 'search_result';
+}
+
+/**
+ * Citation settings for a search result.
+ */
+export interface BetaManagedAgentsSearchResultCitations {
+  /**
+   * Whether citations are enabled for this search result.
+   */
+  enabled: boolean;
+}
+
+/**
+ * Text content within a search result.
+ */
+export interface BetaManagedAgentsSearchResultContent {
+  /**
+   * The text content.
+   */
+  text: string;
+
+  type: 'text';
+}
+
+/**
+ * Events that were successfully sent to the session.
+ */
+export interface BetaManagedAgentsSendSessionEvents {
+  /**
+   * Sent events
+   */
+  data?: Array<
+    | BetaManagedAgentsUserMessageEvent
+    | BetaManagedAgentsUserInterruptEvent
+    | BetaManagedAgentsUserToolConfirmationEvent
+    | BetaManagedAgentsUserCustomToolResultEvent
+    | BetaManagedAgentsUserDefineOutcomeEvent
+    | SessionsAPI.BetaManagedAgentsUserToolResultEvent
+  >;
+}
+
+/**
+ * Emitted when a session has been deleted. Terminates any active event stream — no
+ * further events will be emitted for this session.
+ */
+export interface BetaManagedAgentsSessionDeletedEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  type: 'session.deleted';
+}
+
+/**
+ * The agent completed its turn naturally and is ready for the next user message.
+ */
+export interface BetaManagedAgentsSessionEndTurn {
+  type: 'end_turn';
+}
+
+/**
+ * An error event indicating a problem occurred during session execution.
+ */
+export interface BetaManagedAgentsSessionErrorEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * An unknown or unexpected error occurred during session execution. A fallback
+   * variant; clients that don't recognize a new error code can match on
+   * `retry_status` and `message` alone.
+   */
+  error:
+    | BetaManagedAgentsUnknownError
+    | BetaManagedAgentsModelOverloadedError
+    | BetaManagedAgentsModelRateLimitedError
+    | BetaManagedAgentsModelRequestFailedError
+    | BetaManagedAgentsMCPConnectionFailedError
+    | BetaManagedAgentsMCPAuthenticationFailedError
+    | BetaManagedAgentsBillingError;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  type: 'session.error';
+}
+
+/**
+ * Union type for all event types in a session.
+ */
+export type BetaManagedAgentsSessionEvent =
+  | BetaManagedAgentsUserMessageEvent
+  | BetaManagedAgentsUserInterruptEvent
+  | BetaManagedAgentsUserToolConfirmationEvent
+  | BetaManagedAgentsUserCustomToolResultEvent
+  | BetaManagedAgentsAgentCustomToolUseEvent
+  | BetaManagedAgentsAgentMessageEvent
+  | BetaManagedAgentsAgentThinkingEvent
+  | BetaManagedAgentsAgentMCPToolUseEvent
+  | BetaManagedAgentsAgentMCPToolResultEvent
+  | BetaManagedAgentsAgentToolUseEvent
+  | BetaManagedAgentsAgentToolResultEvent
+  | BetaManagedAgentsAgentThreadMessageReceivedEvent
+  | BetaManagedAgentsAgentThreadMessageSentEvent
+  | BetaManagedAgentsAgentThreadContextCompactedEvent
+  | BetaManagedAgentsSessionErrorEvent
+  | BetaManagedAgentsSessionStatusRescheduledEvent
+  | BetaManagedAgentsSessionStatusRunningEvent
+  | BetaManagedAgentsSessionStatusIdleEvent
+  | BetaManagedAgentsSessionStatusTerminatedEvent
+  | BetaManagedAgentsSessionThreadCreatedEvent
+  | BetaManagedAgentsSpanOutcomeEvaluationStartEvent
+  | BetaManagedAgentsSpanOutcomeEvaluationEndEvent
+  | BetaManagedAgentsSpanModelRequestStartEvent
+  | BetaManagedAgentsSpanModelRequestEndEvent
+  | BetaManagedAgentsSpanOutcomeEvaluationOngoingEvent
+  | BetaManagedAgentsUserDefineOutcomeEvent
+  | BetaManagedAgentsSessionDeletedEvent
+  | BetaManagedAgentsSessionThreadStatusRunningEvent
+  | BetaManagedAgentsSessionThreadStatusIdleEvent
+  | BetaManagedAgentsSessionThreadStatusTerminatedEvent
+  | SessionsAPI.BetaManagedAgentsUserToolResultEvent
+  | BetaManagedAgentsSessionThreadStatusRescheduledEvent
+  | SessionsAPI.BetaManagedAgentsSessionUpdatedEvent;
+
+/**
+ * The agent is idle waiting on one or more blocking user-input events (tool
+ * confirmation, custom tool result, etc.). Resolving all of them transitions the
+ * session back to running.
+ */
+export interface BetaManagedAgentsSessionRequiresAction {
+  /**
+   * The ids of events the agent is blocked on. Resolving fewer than all re-emits
+   * `session.status_idle` with the remainder.
+   */
+  event_ids: Array<string>;
+
+  type: 'requires_action';
+}
+
+/**
+ * The turn ended because the retry budget was exhausted (`max_iterations` hit or
+ * an error escalated to `retry_status: 'exhausted'`).
+ */
+export interface BetaManagedAgentsSessionRetriesExhausted {
+  type: 'retries_exhausted';
+}
+
+/**
+ * Indicates the agent has paused and is awaiting user input.
+ */
+export interface BetaManagedAgentsSessionStatusIdleEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  /**
+   * The agent completed its turn naturally and is ready for the next user message.
+   */
+  stop_reason:
+    | BetaManagedAgentsSessionEndTurn
+    | BetaManagedAgentsSessionRequiresAction
+    | BetaManagedAgentsSessionRetriesExhausted;
+
+  type: 'session.status_idle';
+}
+
+/**
+ * Indicates the session is recovering from an error state and is rescheduled for
+ * execution.
+ */
+export interface BetaManagedAgentsSessionStatusRescheduledEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  type: 'session.status_rescheduled';
+}
+
+/**
+ * Indicates the session is actively running and the agent is working.
+ */
+export interface BetaManagedAgentsSessionStatusRunningEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  type: 'session.status_running';
+}
+
+/**
+ * Indicates the session has terminated, either due to an error or completion.
+ */
+export interface BetaManagedAgentsSessionStatusTerminatedEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  type: 'session.status_terminated';
+}
+
+/**
+ * Emitted when a subagent is spawned as a new thread. Written to the parent
+ * thread's output stream so clients observing the session see child creation.
+ */
+export interface BetaManagedAgentsSessionThreadCreatedEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * Name of the callable agent the thread runs.
+   */
+  agent_name: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  /**
+   * Public `sthr_` ID of the newly created thread.
+   */
+  session_thread_id: string;
+
+  type: 'session.thread_created';
+}
+
+/**
+ * A session thread has yielded and is awaiting input. Emitted on the thread's own
+ * stream and cross-posted to the primary stream for child threads.
+ */
+export interface BetaManagedAgentsSessionThreadStatusIdleEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * Name of the agent the thread runs.
+   */
+  agent_name: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  /**
+   * Public sthr\_ ID of the thread that went idle.
+   */
+  session_thread_id: string;
+
+  /**
+   * The agent completed its turn naturally and is ready for the next user message.
+   */
+  stop_reason:
+    | BetaManagedAgentsSessionEndTurn
+    | BetaManagedAgentsSessionRequiresAction
+    | BetaManagedAgentsSessionRetriesExhausted;
+
+  type: 'session.thread_status_idle';
+}
+
+/**
+ * A session thread hit a transient error and is retrying automatically. Emitted on
+ * the thread's own stream and cross-posted to the primary stream for child
+ * threads.
+ */
+export interface BetaManagedAgentsSessionThreadStatusRescheduledEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * Name of the agent the thread runs.
+   */
+  agent_name: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  /**
+   * Public sthr\_ ID of the thread that is retrying.
+   */
+  session_thread_id: string;
+
+  type: 'session.thread_status_rescheduled';
+}
+
+/**
+ * A session thread has begun executing. Emitted on the thread's own stream and
+ * cross-posted to the primary stream for child threads.
+ */
+export interface BetaManagedAgentsSessionThreadStatusRunningEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * Name of the agent the thread runs.
+   */
+  agent_name: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  /**
+   * Public sthr\_ ID of the thread that started running.
+   */
+  session_thread_id: string;
+
+  type: 'session.thread_status_running';
+}
+
+/**
+ * A session thread has terminated and will accept no further input. Emitted on the
+ * thread's own stream and cross-posted to the primary stream for child threads.
+ */
+export interface BetaManagedAgentsSessionThreadStatusTerminatedEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * Name of the agent the thread runs.
+   */
+  agent_name: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  /**
+   * Public sthr\_ ID of the thread that terminated.
+   */
+  session_thread_id: string;
+
+  type: 'session.thread_status_terminated';
+}
+
+/**
+ * Emitted when a model request completes.
+ */
+export interface BetaManagedAgentsSpanModelRequestEndEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * Whether the model request resulted in an error.
+   */
+  is_error: boolean | null;
+
+  /**
+   * The id of the corresponding `span.model_request_start` event.
+   */
+  model_request_start_id: string;
+
+  /**
+   * Token usage for a single model request.
+   */
+  model_usage: BetaManagedAgentsSpanModelUsage;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  type: 'span.model_request_end';
+}
+
+/**
+ * Emitted when a model request is initiated by the agent.
+ */
+export interface BetaManagedAgentsSpanModelRequestStartEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  type: 'span.model_request_start';
+}
+
+/**
+ * Token usage for a single model request.
+ */
+export interface BetaManagedAgentsSpanModelUsage {
+  /**
+   * Tokens used to create prompt cache in this request.
+   */
+  cache_creation_input_tokens: number;
+
+  /**
+   * Tokens read from prompt cache in this request.
+   */
+  cache_read_input_tokens: number;
+
+  /**
+   * Input tokens consumed by this request.
+   */
+  input_tokens: number;
+
+  /**
+   * Output tokens generated by this request.
+   */
+  output_tokens: number;
+
+  /**
+   * Inference speed mode. `fast` provides significantly faster output token
+   * generation at premium pricing. Not all models support `fast`; invalid
+   * combinations are rejected at create time.
+   */
+  speed?: 'standard' | 'fast' | null;
+}
+
+/**
+ * Emitted when an outcome evaluation cycle completes. Carries the verdict and
+ * aggregate token usage. A verdict of `needs_revision` means another evaluation
+ * cycle follows; `satisfied`, `max_iterations_reached`, `failed`, or `interrupted`
+ * are terminal — no further evaluation cycles follow.
+ */
+export interface BetaManagedAgentsSpanOutcomeEvaluationEndEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * Human-readable explanation of the verdict. For `needs_revision`, describes which
+   * criteria failed and why.
+   */
+  explanation: string;
+
+  /**
+   * 0-indexed revision cycle, matching the corresponding
+   * `span.outcome_evaluation_start`.
+   */
+  iteration: number;
+
+  /**
+   * The id of the corresponding `span.outcome_evaluation_start` event.
+   */
+  outcome_evaluation_start_id: string;
+
+  /**
+   * The `outc_` ID of the outcome being evaluated.
+   */
+  outcome_id: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  /**
+   * Evaluation verdict. 'satisfied': criteria met, session goes idle.
+   * 'needs_revision': criteria not met, another revision cycle follows.
+   * 'max_iterations_reached': evaluation budget exhausted with criteria still unmet
+   * — one final acknowledgment turn follows before the session goes idle, but no
+   * further evaluation runs. 'failed': grader determined the rubric does not apply
+   * to the deliverables. 'interrupted': user sent an interrupt while evaluation was
+   * in progress.
+   */
+  result: string;
+
+  type: 'span.outcome_evaluation_end';
+
+  /**
+   * Token usage for a single model request.
+   */
+  usage: BetaManagedAgentsSpanModelUsage;
+}
+
+/**
+ * Periodic heartbeat emitted while an outcome evaluation cycle is in progress.
+ * Distinguishes 'evaluation is actively running' from 'evaluation is stuck'
+ * between the corresponding `span.outcome_evaluation_start` and
+ * `span.outcome_evaluation_end` events.
+ */
+export interface BetaManagedAgentsSpanOutcomeEvaluationOngoingEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * 0-indexed revision cycle, matching the corresponding
+   * `span.outcome_evaluation_start`.
+   */
+  iteration: number;
+
+  /**
+   * The `outc_` ID of the outcome being evaluated.
+   */
+  outcome_id: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  type: 'span.outcome_evaluation_ongoing';
+}
+
+/**
+ * Emitted when an outcome evaluation cycle begins.
+ */
+export interface BetaManagedAgentsSpanOutcomeEvaluationStartEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * 0-indexed revision cycle. 0 is the first evaluation; 1 is the re-evaluation
+   * after the first revision; etc.
+   */
+  iteration: number;
+
+  /**
+   * The `outc_` ID of the outcome being evaluated.
+   */
+  outcome_id: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  type: 'span.outcome_evaluation_start';
+}
+
+/**
+ * Server-sent event in the session stream.
+ */
+export type BetaManagedAgentsStreamSessionEvents =
+  | BetaManagedAgentsUserMessageEvent
+  | BetaManagedAgentsUserInterruptEvent
+  | BetaManagedAgentsUserToolConfirmationEvent
+  | BetaManagedAgentsUserCustomToolResultEvent
+  | BetaManagedAgentsAgentCustomToolUseEvent
+  | BetaManagedAgentsAgentMessageEvent
+  | BetaManagedAgentsAgentThinkingEvent
+  | BetaManagedAgentsAgentMCPToolUseEvent
+  | BetaManagedAgentsAgentMCPToolResultEvent
+  | BetaManagedAgentsAgentToolUseEvent
+  | BetaManagedAgentsAgentToolResultEvent
+  | BetaManagedAgentsAgentThreadMessageReceivedEvent
+  | BetaManagedAgentsAgentThreadMessageSentEvent
+  | BetaManagedAgentsAgentThreadContextCompactedEvent
+  | BetaManagedAgentsSessionErrorEvent
+  | BetaManagedAgentsSessionStatusRescheduledEvent
+  | BetaManagedAgentsSessionStatusRunningEvent
+  | BetaManagedAgentsSessionStatusIdleEvent
+  | BetaManagedAgentsSessionStatusTerminatedEvent
+  | BetaManagedAgentsSessionThreadCreatedEvent
+  | BetaManagedAgentsSpanOutcomeEvaluationStartEvent
+  | BetaManagedAgentsSpanOutcomeEvaluationEndEvent
+  | BetaManagedAgentsSpanModelRequestStartEvent
+  | BetaManagedAgentsSpanModelRequestEndEvent
+  | BetaManagedAgentsSpanOutcomeEvaluationOngoingEvent
+  | BetaManagedAgentsUserDefineOutcomeEvent
+  | BetaManagedAgentsSessionDeletedEvent
+  | BetaManagedAgentsSessionThreadStatusRunningEvent
+  | BetaManagedAgentsSessionThreadStatusIdleEvent
+  | BetaManagedAgentsSessionThreadStatusTerminatedEvent
+  | SessionsAPI.BetaManagedAgentsUserToolResultEvent
+  | BetaManagedAgentsSessionThreadStatusRescheduledEvent
+  | SessionsAPI.BetaManagedAgentsSessionUpdatedEvent;
+
+/**
+ * Regular text content.
+ */
+export interface BetaManagedAgentsTextBlock {
+  /**
+   * The text content.
+   */
+  text: string;
+
+  type: 'text';
+}
+
+/**
+ * Rubric content provided inline as text.
+ */
+export interface BetaManagedAgentsTextRubric {
+  /**
+   * Rubric content. Plain text or markdown — the grader treats it as freeform text.
+   */
+  content: string;
+
+  type: 'text';
+}
+
+/**
+ * Rubric content provided inline as text.
+ */
+export interface BetaManagedAgentsTextRubricParams {
+  /**
+   * Rubric content. Plain text or markdown — the grader treats it as freeform text.
+   * Maximum 262144 characters.
+   */
+  content: string;
+
+  type: 'text';
+}
+
+/**
+ * An unknown or unexpected error occurred during session execution. A fallback
+ * variant; clients that don't recognize a new error code can match on
+ * `retry_status` and `message` alone.
+ */
+export interface BetaManagedAgentsUnknownError {
+  /**
+   * Human-readable error description.
+   */
+  message: string;
+
+  /**
+   * What the client should do next in response to this error.
+   */
+  retry_status:
+    | BetaManagedAgentsRetryStatusRetrying
+    | BetaManagedAgentsRetryStatusExhausted
+    | BetaManagedAgentsRetryStatusTerminal;
+
+  type: 'unknown_error';
+}
+
+/**
+ * Document referenced by URL.
+ */
+export interface BetaManagedAgentsURLDocumentSource {
+  type: 'url';
+
+  /**
+   * URL of the document to fetch.
+   */
+  url: string;
+}
+
+/**
+ * Image referenced by URL.
+ */
+export interface BetaManagedAgentsURLImageSource {
+  type: 'url';
+
+  /**
+   * URL of the image to fetch.
+   */
+  url: string;
+}
+
+/**
+ * Event sent by the client providing the result of a custom tool execution.
+ */
+export interface BetaManagedAgentsUserCustomToolResultEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * The id of the `agent.custom_tool_use` event this result corresponds to, which
+   * can be found in the last `session.status_idle`
+   * [event's](https://platform.claude.com/docs/en/api/beta/sessions/events/list#beta_managed_agents_session_requires_action.event_ids)
+   * `stop_reason.event_ids` field.
+   */
+  custom_tool_use_id: string;
+
+  type: 'user.custom_tool_result';
+
+  /**
+   * The result content returned by the tool.
+   */
+  content?: Array<
+    | BetaManagedAgentsTextBlock
+    | BetaManagedAgentsImageBlock
+    | BetaManagedAgentsDocumentBlock
+    | BetaManagedAgentsSearchResultBlock
+  >;
+
+  /**
+   * Whether the tool execution resulted in an error.
+   */
+  is_error?: boolean | null;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at?: string | null;
+
+  /**
+   * Routes this result to a subagent thread. Copy from the `agent.custom_tool_use`
+   * event's `session_thread_id`.
+   */
+  session_thread_id?: string | null;
+}
+
+/**
+ * Parameters for providing the result of a custom tool execution.
+ */
+export interface BetaManagedAgentsUserCustomToolResultEventParams {
+  /**
+   * The id of the `agent.custom_tool_use` event this result corresponds to, which
+   * can be found in the last `session.status_idle`
+   * [event's](https://platform.claude.com/docs/en/api/beta/sessions/events/list#beta_managed_agents_session_requires_action.event_ids)
+   * `stop_reason.event_ids` field.
+   */
+  custom_tool_use_id: string;
+
+  type: 'user.custom_tool_result';
+
+  /**
+   * The result content returned by the tool.
+   */
+  content?: Array<
+    | BetaManagedAgentsTextBlock
+    | BetaManagedAgentsImageBlock
+    | BetaManagedAgentsDocumentBlock
+    | BetaManagedAgentsSearchResultBlock
+  >;
+
+  /**
+   * Whether the tool execution resulted in an error.
+   */
+  is_error?: boolean | null;
+}
+
+/**
+ * Echo of a `user.define_outcome` input event. Carries the server-generated
+ * `outcome_id` that subsequent `span.outcome_evaluation_*` events reference.
+ */
+export interface BetaManagedAgentsUserDefineOutcomeEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * What the agent should produce. Copied from the input event.
+   */
+  description: string;
+
+  /**
+   * Evaluate-then-revise cycles before giving up. Default 3, max 20.
+   */
+  max_iterations: number | null;
+
+  /**
+   * Server-generated `outc_` ID for this outcome. Referenced by
+   * `span.outcome_evaluation_*` events and the session's `outcome_evaluations` list.
+   */
+  outcome_id: string;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at: string;
+
+  /**
+   * Rubric for grading the quality of an outcome.
+   */
+  rubric: BetaManagedAgentsFileRubric | BetaManagedAgentsTextRubric;
+
+  type: 'user.define_outcome';
+}
+
+/**
+ * Parameters for defining an outcome the agent should work toward. The agent
+ * begins work on receipt.
+ */
+export interface BetaManagedAgentsUserDefineOutcomeEventParams {
+  /**
+   * What the agent should produce. This is the task specification.
+   */
+  description: string;
+
+  /**
+   * Rubric for grading the quality of an outcome.
+   */
+  rubric: BetaManagedAgentsFileRubricParams | BetaManagedAgentsTextRubricParams;
+
+  type: 'user.define_outcome';
+
+  /**
+   * Eval→revision cycles before giving up. Default 3, max 20.
+   */
+  max_iterations?: number | null;
+}
+
+/**
+ * An interrupt event that pauses agent execution and returns control to the user.
+ */
+export interface BetaManagedAgentsUserInterruptEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  type: 'user.interrupt';
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at?: string | null;
+
+  /**
+   * If absent, interrupts every non-archived thread in a multiagent session (or the
+   * primary alone in a single-agent session). If present, interrupts only the named
+   * thread.
+   */
+  session_thread_id?: string | null;
+}
+
+/**
+ * Parameters for sending an interrupt to pause the agent.
+ */
+export interface BetaManagedAgentsUserInterruptEventParams {
+  type: 'user.interrupt';
+
+  /**
+   * If absent, interrupts every non-archived thread in a multiagent session (or the
+   * primary alone in a single-agent session). If present, interrupts only the named
+   * thread.
+   */
+  session_thread_id?: string | null;
+}
+
+/**
+ * A user message event in the session conversation.
+ */
+export interface BetaManagedAgentsUserMessageEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * Array of content blocks comprising the user message.
+   */
+  content: Array<BetaManagedAgentsTextBlock | BetaManagedAgentsImageBlock | BetaManagedAgentsDocumentBlock>;
+
+  type: 'user.message';
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at?: string | null;
+}
+
+/**
+ * Parameters for sending a user message to the session.
+ */
+export interface BetaManagedAgentsUserMessageEventParams {
+  /**
+   * Array of content blocks for the user message.
+   */
+  content: Array<BetaManagedAgentsTextBlock | BetaManagedAgentsImageBlock | BetaManagedAgentsDocumentBlock>;
+
+  type: 'user.message';
+}
+
+/**
+ * A tool confirmation event that approves or denies a pending tool execution.
+ */
+export interface BetaManagedAgentsUserToolConfirmationEvent {
+  /**
+   * Unique identifier for this event.
+   */
+  id: string;
+
+  /**
+   * UserToolConfirmationResult enum
+   */
+  result: 'allow' | 'deny';
+
+  /**
+   * The id of the `agent.tool_use` or `agent.mcp_tool_use` event this result
+   * corresponds to, which can be found in the last `session.status_idle`
+   * [event's](https://platform.claude.com/docs/en/api/beta/sessions/events/list#beta_managed_agents_session_requires_action.event_ids)
+   * `stop_reason.event_ids` field.
+   */
+  tool_use_id: string;
+
+  type: 'user.tool_confirmation';
+
+  /**
+   * Optional message providing context for a 'deny' decision. Only allowed when
+   * result is 'deny'.
+   */
+  deny_message?: string | null;
+
+  /**
+   * A timestamp in RFC 3339 format
+   */
+  processed_at?: string | null;
+
+  /**
+   * When set, the confirmation routes to this subagent's thread rather than the
+   * primary. Echo this from the `session_thread_id` on the `agent.tool_use` or
+   * `agent.mcp_tool_use` event that prompted the approval.
+   */
+  session_thread_id?: string | null;
+}
+
+/**
+ * Parameters for confirming or denying a tool execution request.
+ */
+export interface BetaManagedAgentsUserToolConfirmationEventParams {
+  /**
+   * UserToolConfirmationResult enum
+   */
+  result: 'allow' | 'deny';
+
+  /**
+   * The id of the `agent.tool_use` or `agent.mcp_tool_use` event this result
+   * corresponds to, which can be found in the last `session.status_idle`
+   * [event's](https://platform.claude.com/docs/en/api/beta/sessions/events/list#beta_managed_agents_session_requires_action.event_ids)
+   * `stop_reason.event_ids` field.
+   */
+  tool_use_id: string;
+
+  type: 'user.tool_confirmation';
+
+  /**
+   * Optional message providing context for a 'deny' decision. Only allowed when
+   * result is 'deny'.
+   */
+  deny_message?: string | null;
+}
+
+/**
+ * Parameters for providing the result of an agent-toolset tool execution. Only
+ * valid on `self_hosted` environments, where sandbox-routed tools are executed by
+ * the client rather than the server.
+ */
+export interface BetaManagedAgentsUserToolResultEventParams {
+  /**
+   * The id of the `agent.tool_use` event this result corresponds to, which can be
+   * found in the last `session.status_idle`
+   * [event's](https://platform.claude.com/docs/en/api/beta/sessions/events/list#beta_managed_agents_session_requires_action.event_ids)
+   * `stop_reason.event_ids` field.
+   */
+  tool_use_id: string;
+
+  type: 'user.tool_result';
+
+  /**
+   * The result content returned by the tool.
+   */
+  content?: Array<
+    | BetaManagedAgentsTextBlock
+    | BetaManagedAgentsImageBlock
+    | BetaManagedAgentsDocumentBlock
+    | BetaManagedAgentsSearchResultBlock
+  >;
+
+  /**
+   * Whether the tool execution resulted in an error.
+   */
+  is_error?: boolean | null;
+}
+
+export interface EventListParams extends PageCursorParams {
+  /**
+   * Query param: Return events created after this time (exclusive).
+   */
+  'created_at[gt]'?: string;
+
+  /**
+   * Query param: Return events created at or after this time (inclusive).
+   */
+  'created_at[gte]'?: string;
+
+  /**
+   * Query param: Return events created before this time (exclusive).
+   */
+  'created_at[lt]'?: string;
+
+  /**
+   * Query param: Return events created at or before this time (inclusive).
+   */
+  'created_at[lte]'?: string;
+
+  /**
+   * Query param: Sort direction for results, ordered by created_at. Defaults to asc
+   * (chronological).
+   */
+  order?: 'asc' | 'desc';
+
+  /**
+   * Query param: Filter by event type. Values match the `type` field on returned
+   * events (for example, `user.message` or `agent.tool_use`). Omit to return all
+   * event types.
+   */
+  types?: Array<string>;
+
+  /**
+   * Header param: Optional header to specify the beta version(s) you want to use.
+   */
+  betas?: Array<BetaAPI.AnthropicBeta>;
+}
+
+export interface EventSendParams {
+  /**
+   * Body param: Events to send to the `session`.
+   */
+  events: Array<BetaManagedAgentsEventParams>;
+
+  /**
+   * Header param: Optional header to specify the beta version(s) you want to use.
+   */
+  betas?: Array<BetaAPI.AnthropicBeta>;
+}
+
+export interface EventStreamParams {
+  /**
+   * Optional header to specify the beta version(s) you want to use.
+   */
+  betas?: Array<BetaAPI.AnthropicBeta>;
+}
+
+export { SessionToolRunner, type SessionToolRunnerOptions } from '../../../lib/tools/SessionToolRunner';
+
+Events.SessionToolRunner = SessionToolRunner;
+
+export declare namespace Events {
+  export { SessionToolRunner };
+
+  export {
+    type BetaManagedAgentsAgentCustomToolUseEvent as BetaManagedAgentsAgentCustomToolUseEvent,
+    type BetaManagedAgentsAgentMCPToolResultEvent as BetaManagedAgentsAgentMCPToolResultEvent,
+    type BetaManagedAgentsAgentMCPToolUseEvent as BetaManagedAgentsAgentMCPToolUseEvent,
+    type BetaManagedAgentsAgentMessageEvent as BetaManagedAgentsAgentMessageEvent,
+    type BetaManagedAgentsAgentThinkingEvent as BetaManagedAgentsAgentThinkingEvent,
+    type BetaManagedAgentsAgentThreadContextCompactedEvent as BetaManagedAgentsAgentThreadContextCompactedEvent,
+    type BetaManagedAgentsAgentThreadMessageReceivedEvent as BetaManagedAgentsAgentThreadMessageReceivedEvent,
+    type BetaManagedAgentsAgentThreadMessageSentEvent as BetaManagedAgentsAgentThreadMessageSentEvent,
+    type BetaManagedAgentsAgentToolResultEvent as BetaManagedAgentsAgentToolResultEvent,
+    type BetaManagedAgentsAgentToolUseEvent as BetaManagedAgentsAgentToolUseEvent,
+    type BetaManagedAgentsBase64DocumentSource as BetaManagedAgentsBase64DocumentSource,
+    type BetaManagedAgentsBase64ImageSource as BetaManagedAgentsBase64ImageSource,
+    type BetaManagedAgentsBillingError as BetaManagedAgentsBillingError,
+    type BetaManagedAgentsDocumentBlock as BetaManagedAgentsDocumentBlock,
+    type BetaManagedAgentsEventParams as BetaManagedAgentsEventParams,
+    type BetaManagedAgentsFileDocumentSource as BetaManagedAgentsFileDocumentSource,
+    type BetaManagedAgentsFileImageSource as BetaManagedAgentsFileImageSource,
+    type BetaManagedAgentsFileRubric as BetaManagedAgentsFileRubric,
+    type BetaManagedAgentsFileRubricParams as BetaManagedAgentsFileRubricParams,
+    type BetaManagedAgentsImageBlock as BetaManagedAgentsImageBlock,
+    type BetaManagedAgentsMCPAuthenticationFailedError as BetaManagedAgentsMCPAuthenticationFailedError,
+    type BetaManagedAgentsMCPConnectionFailedError as BetaManagedAgentsMCPConnectionFailedError,
+    type BetaManagedAgentsModelOverloadedError as BetaManagedAgentsModelOverloadedError,
+    type BetaManagedAgentsModelRateLimitedError as BetaManagedAgentsModelRateLimitedError,
+    type BetaManagedAgentsModelRequestFailedError as BetaManagedAgentsModelRequestFailedError,
+    type BetaManagedAgentsPlainTextDocumentSource as BetaManagedAgentsPlainTextDocumentSource,
+    type BetaManagedAgentsRetryStatusExhausted as BetaManagedAgentsRetryStatusExhausted,
+    type BetaManagedAgentsRetryStatusRetrying as BetaManagedAgentsRetryStatusRetrying,
+    type BetaManagedAgentsRetryStatusTerminal as BetaManagedAgentsRetryStatusTerminal,
+    type BetaManagedAgentsSearchResultBlock as BetaManagedAgentsSearchResultBlock,
+    type BetaManagedAgentsSearchResultCitations as BetaManagedAgentsSearchResultCitations,
+    type BetaManagedAgentsSearchResultContent as BetaManagedAgentsSearchResultContent,
+    type BetaManagedAgentsSendSessionEvents as BetaManagedAgentsSendSessionEvents,
+    type BetaManagedAgentsSessionDeletedEvent as BetaManagedAgentsSessionDeletedEvent,
+    type BetaManagedAgentsSessionEndTurn as BetaManagedAgentsSessionEndTurn,
+    type BetaManagedAgentsSessionErrorEvent as BetaManagedAgentsSessionErrorEvent,
+    type BetaManagedAgentsSessionEvent as BetaManagedAgentsSessionEvent,
+    type BetaManagedAgentsSessionRequiresAction as BetaManagedAgentsSessionRequiresAction,
+    type BetaManagedAgentsSessionRetriesExhausted as BetaManagedAgentsSessionRetriesExhausted,
+    type BetaManagedAgentsSessionStatusIdleEvent as BetaManagedAgentsSessionStatusIdleEvent,
+    type BetaManagedAgentsSessionStatusRescheduledEvent as BetaManagedAgentsSessionStatusRescheduledEvent,
+    type BetaManagedAgentsSessionStatusRunningEvent as BetaManagedAgentsSessionStatusRunningEvent,
+    type BetaManagedAgentsSessionStatusTerminatedEvent as BetaManagedAgentsSessionStatusTerminatedEvent,
+    type BetaManagedAgentsSessionThreadCreatedEvent as BetaManagedAgentsSessionThreadCreatedEvent,
+    type BetaManagedAgentsSessionThreadStatusIdleEvent as BetaManagedAgentsSessionThreadStatusIdleEvent,
+    type BetaManagedAgentsSessionThreadStatusRescheduledEvent as BetaManagedAgentsSessionThreadStatusRescheduledEvent,
+    type BetaManagedAgentsSessionThreadStatusRunningEvent as BetaManagedAgentsSessionThreadStatusRunningEvent,
+    type BetaManagedAgentsSessionThreadStatusTerminatedEvent as BetaManagedAgentsSessionThreadStatusTerminatedEvent,
+    type BetaManagedAgentsSpanModelRequestEndEvent as BetaManagedAgentsSpanModelRequestEndEvent,
+    type BetaManagedAgentsSpanModelRequestStartEvent as BetaManagedAgentsSpanModelRequestStartEvent,
+    type BetaManagedAgentsSpanModelUsage as BetaManagedAgentsSpanModelUsage,
+    type BetaManagedAgentsSpanOutcomeEvaluationEndEvent as BetaManagedAgentsSpanOutcomeEvaluationEndEvent,
+    type BetaManagedAgentsSpanOutcomeEvaluationOngoingEvent as BetaManagedAgentsSpanOutcomeEvaluationOngoingEvent,
+    type BetaManagedAgentsSpanOutcomeEvaluationStartEvent as BetaManagedAgentsSpanOutcomeEvaluationStartEvent,
+    type BetaManagedAgentsStreamSessionEvents as BetaManagedAgentsStreamSessionEvents,
+    type BetaManagedAgentsTextBlock as BetaManagedAgentsTextBlock,
+    type BetaManagedAgentsTextRubric as BetaManagedAgentsTextRubric,
+    type BetaManagedAgentsTextRubricParams as BetaManagedAgentsTextRubricParams,
+    type BetaManagedAgentsUnknownError as BetaManagedAgentsUnknownError,
+    type BetaManagedAgentsURLDocumentSource as BetaManagedAgentsURLDocumentSource,
+    type BetaManagedAgentsURLImageSource as BetaManagedAgentsURLImageSource,
+    type BetaManagedAgentsUserCustomToolResultEvent as BetaManagedAgentsUserCustomToolResultEvent,
+    type BetaManagedAgentsUserCustomToolResultEventParams as BetaManagedAgentsUserCustomToolResultEventParams,
+    type BetaManagedAgentsUserDefineOutcomeEvent as BetaManagedAgentsUserDefineOutcomeEvent,
+    type BetaManagedAgentsUserDefineOutcomeEventParams as BetaManagedAgentsUserDefineOutcomeEventParams,
+    type BetaManagedAgentsUserInterruptEvent as BetaManagedAgentsUserInterruptEvent,
+    type BetaManagedAgentsUserInterruptEventParams as BetaManagedAgentsUserInterruptEventParams,
+    type BetaManagedAgentsUserMessageEvent as BetaManagedAgentsUserMessageEvent,
+    type BetaManagedAgentsUserMessageEventParams as BetaManagedAgentsUserMessageEventParams,
+    type BetaManagedAgentsUserToolConfirmationEvent as BetaManagedAgentsUserToolConfirmationEvent,
+    type BetaManagedAgentsUserToolConfirmationEventParams as BetaManagedAgentsUserToolConfirmationEventParams,
+    type BetaManagedAgentsUserToolResultEventParams as BetaManagedAgentsUserToolResultEventParams,
+    type BetaManagedAgentsSessionEventsPageCursor as BetaManagedAgentsSessionEventsPageCursor,
+    type EventListParams as EventListParams,
+    type EventSendParams as EventSendParams,
+    type EventStreamParams as EventStreamParams,
+  };
+}