@jrkropp/codex-js 0.1.1 → 0.1.3

package/dist/codex-rs/core/index.d.ts

@@ -0,0 +1,1393 @@
+import { l as ThreadId, af as ThreadGoal, A as ResponseItem, x as TokenUsageInfo, ah as HookEventName, aB as ResponseInputItem, F as FunctionCallOutputContentItem, y as TruncationPolicy, az as TurnContextItem, C as CollaborationMode, j as RolloutItem, B as BaseInstructions, aC as ContentItem, aD as AgentMessageTurnItem, t as TurnItem, a4 as UserMessageTurnItem, aE as HookPromptTurnItem, D as DynamicToolSpec, h as McpToolInfo, G as ToolSpec, a0 as ConfiguredToolSpec, k as Submission, I as RateLimitSnapshot, H as TokenUsage, aF as FileChange, i as ModeKind, aG as ExecToolCallOutput, ao as RequestPermissionsResponse, aq as RequestPermissionProfile, P as PermissionProfile } from '../../protocol-mpBcYHrm.js';
+export { L as ActivePermissionProfile, aH as AgentMessageContent, aI as AgentMessageContentDeltaEvent, aJ as AgentMessageContentDeltaEventMsg, aK as AgentMessageEvent, aL as AgentMessageEventMsg, aM as AgentPathWire, aN as AgentStatusWire, Y as ApprovalsReviewer, X as AskForApproval, aO as BASE_INSTRUCTIONS_DEFAULT, aP as ByteRange, aQ as CodexBrand, aR as CollabAgentInteractionBeginEvent, aS as CollabAgentInteractionEndEvent, aT as CollabAgentRef, aU as CollabAgentSpawnBeginEvent, aV as CollabAgentSpawnEndEvent, aW as CollabCloseBeginEvent, aX as CollabCloseEndEvent, aY as CollabResumeBeginEvent, aZ as CollabResumeEndEvent, a_ as CollabWaitingBeginEvent, a$ as CollabWaitingEndEvent, a as CollaborationModeMask, b0 as CollaborationModeSettings, b1 as CommandApprovalRequestEvent, b2 as CommandApprovalRequestEventMsg, b3 as CommandExecutionStatus, b4 as CommandExecutionTurnItem, b5 as CompactOp, ay as CompactedItem, b6 as CompactedRolloutItem, b7 as ContextCompactedEvent, b8 as ContextCompactedEventMsg, b9 as ContextCompactionTurnItem, ba as ConversationAudioParams, bb as ConversationStartParams, bc as ConversationStartTransport, bd as ConversationTextParams, be as DynamicToolCallOutputContentItem, w as DynamicToolCallRequest, bf as DynamicToolCallRequestEventMsg, bg as DynamicToolCallResponseEvent, bh as DynamicToolCallResponseEventMsg, bi as DynamicToolCallStatus, bj as DynamicToolCallTurnItem, a5 as DynamicToolResponse, bk as DynamicToolResponseOp, b as DynamicToolSpecWire, bl as ErrorEvent, bm as ErrorEventMsg, E as EventMsg, bn as EventMsgRolloutItem, bo as ExecCommandBeginEvent, bp as ExecCommandBeginEventMsg, bq as ExecCommandEndEvent, br as ExecCommandEndEventMsg, bs as ExecCommandOutputDeltaEvent, bt as ExecCommandOutputDeltaEventMsg, bu as ExecCommandStatus, bv as FileChangeApprovalRequestEvent, bw as FileChangeApprovalRequestEventMsg, bx as FileChangeTurnItem, by as FileSystemPermissions, bz as FileSystemSandboxPolicy, bA as FreeformTool, bB as FunctionCallOutputBody, z as FunctionCallOutputPayload, bC as GitInfo, an as HookCompletedEvent, bD as HookCompletedEventMsg, bE as HookExecutionMode, bF as HookHandlerType, ak as HookOutputEntry, bG as HookOutputEntryKind, bH as HookPromptFragment, aj as HookRunStatus, al as HookRunSummary, am as HookScope, ai as HookSource, bI as HookStartedEvent, bJ as HookStartedEventMsg, bK as HookTrustStatus, bL as ImageGenerationBeginEvent, bM as ImageGenerationBeginEventMsg, bN as ImageGenerationEndEvent, bO as ImageGenerationEndEventMsg, bP as ImageGenerationTurnItem, bQ as ImageViewTurnItem, bR as InterAgentCommunicationWire, bS as InterruptOp, bT as ItemCompletedEvent, bU as ItemCompletedEventMsg, bV as ItemStartedEvent, bW as ItemStartedEventMsg, bX as JsonSchema, $ as LoadableToolSpec, bY as MAX_THREAD_GOAL_OBJECTIVE_CHARS, bZ as McpInvocation, ad as McpRequestId, M as McpResourceInfo, a6 as McpResourceListParams, a7 as McpResourceListResponse, a9 as McpResourceReadParams, aa as McpResourceReadResponse, c as McpResourceTemplateInfo, a8 as McpResourceTemplateListResponse, d as McpRuntimeEnvironment, b_ as McpServerElicitationAction, ax as McpServerElicitationRequest, b$ as McpServerElicitationRequestEvent, c0 as McpServerElicitationRequestEventMsg, ae as McpServerElicitationResponse, c1 as McpServerElicitationResponseOp, c2 as McpServerOauthLoginCompletedEvent, c3 as McpServerOauthLoginCompletedEventMsg, c4 as McpServerOauthLoginParams, c5 as McpServerOauthLoginResponse, e as McpServerRefreshConfig, c6 as McpServerRegistry, c7 as McpServerStartupState, f as McpServerStatus, c8 as McpServerStatusDetail, g as McpServerStatusListOptions, c9 as McpServerStatusUpdatedEvent, ca as McpServerStatusUpdatedEventMsg, ab as McpServerToolCallParams, ac as McpServerToolCallResponse, cb as McpToolCallBeginEvent, cc as McpToolCallEndEvent, cd as McpToolCallError, ce as McpToolCallProgressEvent, cf as McpToolCallProgressEventMsg, cg as McpToolCallStatus, ch as McpToolCallTurnItem, ci as MemoryCitation, cj as MemoryCitationEntry, ck as MentionInput, cl as MessagePhase, cm as NetworkPermissions, av as NormalizedRequestUserInputArgs, cn as NormalizedRequestUserInputQuestion, O as Op, ar as OverrideTurnContextOp, co as PatchApplyStatus, cp as PatchApplyUpdatedEvent, cq as PatchApplyUpdatedEventMsg, cr as PermissionGrantScope, a1 as PermissionProfileBuiltinName, W as Personality, cs as PlanDeltaEvent, ct as PlanDeltaEventMsg, cu as PlanTurnItem, cv as PlanUpdateEventMsg, cw as REQUEST_PERMISSIONS_TOOL_NAME, cx as REQUEST_USER_INPUT_TOOL_NAME, cy as RateLimitWindow, cz as RawResponseItemEvent, cA as RawResponseItemEventMsg, cB as RealtimeAudioFrame, cC as RealtimeConversationAudioOp, cD as RealtimeConversationCloseOp, cE as RealtimeConversationClosedEvent, cF as RealtimeConversationClosedEventMsg, cG as RealtimeConversationListVoicesOp, cH as RealtimeConversationListVoicesResponseEvent, cI as RealtimeConversationListVoicesResponseEventMsg, cJ as RealtimeConversationRealtimeEvent, cK as RealtimeConversationRealtimeEventMsg, cL as RealtimeConversationSdpEvent, cM as RealtimeConversationSdpEventMsg, cN as RealtimeConversationStartOp, cO as RealtimeConversationStartedEvent, cP as RealtimeConversationStartedEventMsg, cQ as RealtimeConversationTextOp, cR as RealtimeConversationVersion, R as RealtimeEvent, cS as RealtimeHandoffRequested, cT as RealtimeInputAudioSpeechStarted, cU as RealtimeNoopRequested, cV as RealtimeOutputModality, cW as RealtimeResponseLifecycle, cX as RealtimeTranscriptDelta, cY as RealtimeTranscriptDone, cZ as RealtimeTranscriptEntry, c_ as RealtimeVoice, c$ as RealtimeVoicesList, d0 as ReasoningEffort, Q as ReasoningEffortConfig, V as ReasoningSummaryConfig, d1 as ReasoningTurnItem, aw as RequestPermissionsArgs, v as RequestPermissionsEvent, d2 as RequestPermissionsEventMsg, d3 as RequestPermissionsResponseOp, d4 as RequestUserInputAnswer, d5 as RequestUserInputArgs, u as RequestUserInputEvent, d6 as RequestUserInputEventMsg, d7 as RequestUserInputQuestion, d8 as RequestUserInputQuestionOption, ap as RequestUserInputResponse, a2 as ResponseItemWire, d9 as ResponseRolloutItem, da as ResponsesApiFunctionTool, db as ResponsesApiNamespace, dc as ResponsesApiNamespaceTool, dd as ResponsesApiTool, de as ReviewDecision, S as SandboxPolicy, N as ServiceTier, df as SessionConfiguredEvent, dg as SessionConfiguredEventMsg, dh as SessionMeta, di as SessionMetaLine, dj as SessionMetaRolloutItem, J as SessionSource, dk as SetThreadMemoryModeOp, dl as SetThreadNameOp, dm as ShutdownOp, dn as StreamOutput, dp as SubAgentSource, T as TUI_VISIBLE_COLLABORATION_MODES, dq as TerminalInteractionEvent, dr as TerminalInteractionEventMsg, K as TextElement, ag as ThreadGoalStatus, ds as ThreadGoalUpdatedEvent, dt as ThreadGoalUpdatedEventMsg, m as ThreadMemoryMode, du as ThreadMemoryModeSessionMetaValue, dv as ThreadRealtimeAppendAudioParams, dw as ThreadRealtimeAppendAudioResponse, dx as ThreadRealtimeAppendTextParams, dy as ThreadRealtimeAppendTextResponse, dz as ThreadRealtimeListVoicesParams, dA as ThreadRealtimeListVoicesResponse, dB as ThreadRealtimeStartParams, dC as ThreadRealtimeStartResponse, dD as ThreadRealtimeStopParams, dE as ThreadRealtimeStopResponse, dF as ThreadRollbackOp, dG as ThreadRolledBackEvent, dH as ThreadRolledBackEventMsg, dI as TokenCountEvent, dJ as TokenCountEventMsg, dK as TurnAbortReason, dL as TurnAbortedEvent, dM as TurnAbortedEventMsg, dN as TurnCompleteEvent, dO as TurnCompleteEventMsg, dP as TurnContextNetworkItem, dQ as TurnContextRolloutItem, _ as TurnEnvironmentSelection, dR as TurnStartedEvent, dS as TurnStartedEventMsg, dT as UpdatePlanArgs, dU as UpdatePlanStep, dV as UpdatePlanStepStatus, U as UserInput, dW as UserInputAnswerOp, as as UserInputOp, at as UserInputWithTurnContextOp, dX as UserMessageEvent, dY as UserMessageEventMsg, au as UserTurnOp, aA as W3cTraceContext, dZ as WarningEvent, d_ as WarningEventMsg, d$ as WebSearchAction, e0 as WebSearchTurnItem, Z as WindowsSandboxLevel, n as allowsRequestUserInput, o as applyCollaborationModeMask, p as asThreadId, e1 as assertValidResponsesToolSpecs, e2 as cloneRequestPermissionProfile, e3 as coalesce_loadable_tool_specs, q as collaborationModeForModel, r as collaborationModeWithUpdates, e4 as createRequestPermissionsTool, e5 as createRequestUserInputTool, e6 as create_tools_json_for_responses_api, e7 as default_namespace_description, s as deniedRequestPermissionsResponse, e8 as dynamicToolSpecFromWire, e9 as dynamicToolSpecToWire, ea as dynamic_tool_to_loadable_tool_spec, eb as dynamic_tool_to_responses_api_tool, ec as emptyRequestPermissionsResponse, ed as execToolCallOutput, ee as functionCallOutputPayloadToWire, ef as isEmptyRequestPermissionProfile, eg as mcpToolCallableName, eh as mcpToolCallableNamespace, ei as mcpToolDisplayName, ej as modeDisplayName, ek as normalizeRequestPermissionsArgs, el as normalizeRequestUserInputArgs, em as requestPermissionsToolDescription, en as requestUserInputAvailableModes, eo as requestUserInputToolDescription, ep as requestUserInputUnavailableMessage, a3 as responseInputToResponseItem, eq as streamOutput, er as threadMemoryModeToSessionMetaValue, es as toolSpecName, et as validateThreadGoalObjective } from '../../protocol-mpBcYHrm.js';
+import { A as AgentRegistry, j as AgentStatus, k as ThreadGoalStore, l as CreateGoalRequest, m as SetGoalRequest, G as GoalRuntimeEvent, n as GoalRuntimeApplyResult, o as GoalToolOutput, p as ConfiguredHookHandler, H as HookHandlerResult, h as Session, T as TurnContext, c as ModelClient, e as ModelClientSessionHandle, g as SessionConfiguration, q as ContextManager, r as TotalTokenUsageBreakdown, s as SessionTask, t as SessionTaskResult, u as TaskKind, v as SessionTaskRunInput } from '../../history-CfM-4V7b.js';
+export { w as ActiveTurn, x as AgentControl, y as AgentControlExecutor, z as AgentMetadata, B as AgentPath, D as AgentRoleConfig, F as AsyncManagedClient, I as CHATGPT_CODEX_RESPONSES_URL, J as CODEX_APPS_MCP_SERVER_NAME, K as CODEX_APPS_TOOLS_CACHE_DIR, L as CODEX_APPS_TOOLS_CACHE_SCHEMA_VERSION, N as CODEX_USER_AGENT, O as CachedCodexAppsToolsLoad, O as CachedCodexAppsToolsLoadResult, P as CodexAppsToolsCacheContext, Q as CodexAppsToolsCacheKey, R as CodexAppsToolsCacheStorage, U as CodexAuthLike, V as CodexMcpAuthLike, W as CodexMcpConnectionManager, C as CodexMcpConnectionManagerAdapter, X as CodexMcpConnectionManagerAdapterOptions, Y as CompactHookRequest, Z as CreateElicitationRequestParams, a as CreateModelClientInput, _ as DEFAULT_ROLE_NAME, $ as DEFAULT_STARTUP_TIMEOUT, a0 as DEFAULT_TOOL_TIMEOUT, a1 as ElicitationAction, a2 as ElicitationEventSink, a3 as ElicitationRequestEvent, a4 as ElicitationRequestManager, a5 as ElicitationResponse, a6 as ElicitationReviewRequest, a7 as ElicitationReviewer, a8 as ElicitationReviewerHandle, E as EmptyMcpConnectionManager, b as Event, a9 as GoalSteeringItem, aa as GoalTurnAccountingSnapshot, ab as HOOK_EVENT_NAMES, ac as HOOK_EVENT_NAMES_WITH_MATCHERS, ad as HookRuntimeOutcome, ae as Hooks, af as InMemoryCodexAppsToolsCacheStorage, ag as InterAgentCommunication, ah as ListedAgent, ai as LiveAgent, aj as MCP_SANDBOX_STATE_META_CAPABILITY, ak as MCP_TOOLS_FETCH_UNCACHED_DURATION_METRIC, al as MCP_TOOLS_LIST_DURATION_METRIC, am as MCP_TOOL_NAME_DELIMITER, an as MCP_TOOL_NAME_PREFIX, ao as Mailbox, ap as MailboxDeliveryPhase, aq as MailboxReceiver, ar as ManagedClient, as as ManagedClientInput, at as McpAuthStatus, au as McpAuthStatusEntry, av as McpCancellationToken, aw as McpClientFactoryOptions, ax as McpClientRuntimeEnvironment, M as McpConnectionManager, ay as McpJsonRpcMessage, az as McpJsonRpcTransport, aA as McpOAuthLoginConfig, aB as McpOAuthLoginSupport, aB as McpOAuthLoginSupportResult, aC as McpOAuthScopesSource, aD as McpServerConfig, aE as McpServerTransportConfig, aF as McpStartupFailure, aG as McpTransportServerConfig, d as ModelClientSession, aH as OAuthProviderError, aI as OPENAI_BETA_HEADER, aJ as PendingDynamicTool, aK as PendingMcpElicitation, aL as PendingRequestPermissions, aM as PendingUserInput, aN as PermissionRequestDecision, aO as PermissionRequestOutcome, aP as PermissionRequestRequest, aQ as PostToolUseOutcome, aR as PostToolUseRequest, aS as PreToolUseOutcome, aT as PreToolUseRequest, aU as QualifiedToolInfo, aV as RESPONSES_WEBSOCKETS_V2_BETA_HEADER_VALUE, aW as RemovedTask, aX as ResolvedMcpOAuthScopes, aY as RmcpClientLike, aZ as RmcpJsonRpcClient, a_ as RmcpListToolsResult, a$ as RmcpRawTool, b0 as RunningTask, b1 as RunningTaskPlaceholder, b2 as SendElicitation, b3 as SessionConfigurationFromConfigOptions, b4 as SessionParams, b5 as SessionSettingsUpdate, b6 as SessionSettingsUpdateError, b7 as SessionStartRequest, b8 as SessionTaskContext, b9 as SpawnAgentForkMode, ba as SpawnAgentOptions, bb as SpawnReservation, bc as StartupOutcomeError, S as StaticMcpConnectionManager, bd as StaticMcpConnectionManagerOptions, be as StdioServerLauncher, bf as SteerInputError, i as SteerInputErrorKind, bg as StreamableHttpMcpTransport, bh as StreamableHttpOAuthDiscovery, bi as ThreadGoalAccountingMode, bj as ThreadGoalAccountingOutcome, bk as ThreadGoalUpdate, bl as ToolFilter, bm as ToolInfo, bn as ToolPluginProvenance, bo as TurnContextParams, bp as TurnState, bq as TurnTimingSnapshot, br as TurnTimingState, bs as UnsupportedStdioServerLauncher, bt as UserPromptSubmitRequest, bu as X_CODEX_INSTALLATION_ID_HEADER, bv as X_CODEX_PARENT_THREAD_ID_HEADER, bw as X_CODEX_TURN_METADATA_HEADER, bx as X_CODEX_TURN_STATE_HEADER, by as X_CODEX_WINDOW_ID_HEADER, bz as X_OPENAI_SUBAGENT_HEADER, bA as X_RESPONSESAPI_INCLUDE_TIMING_METRICS_HEADER, bB as applySessionSettingsUpdate, bC as builtin_agent_roles, bD as can_auto_accept_elicitation, bE as codex_apps_tools_cache_key, bF as completedHookRunSummary, bG as compute_auth_status, bH as compute_auth_statuses, f as createModelClient, bI as declared_openai_file_input_param_names, bJ as defaultSessionConfiguration, bK as default_agent_nickname_list, bL as discover_streamable_http_oauth, bM as discover_supported_scopes, bN as discovery_paths, bO as dropLastNUserTurns, bP as elicitation_capability_for_server, bQ as elicitation_is_rejected_by_policy, bR as emptyTokenUsage, bS as estimate_item_token_count, bT as estimate_response_item_model_visible_bytes, bU as exceeds_thread_spawn_depth_limit, bV as filter_disallowed_codex_apps_tools, bW as filter_non_codex_apps_mcp_tools_only, bX as filter_tools, bY as hookAdditionalContextResponseItem, bZ as hookRunId, b_ as isApiMessage, b$ as isUserTurnBoundary, c0 as is_connector_id_allowed, c1 as is_mcp_client_auth_required_error, c2 as is_mcp_client_startup_timeout_error, c3 as keep_forked_rollout_item, c4 as list_tools_for_client_uncached, c5 as load_cached_codex_apps_tools, c6 as load_startup_cached_codex_apps_tools_snapshot, c7 as make_rmcp_client, c8 as mcp_init_error_display, c9 as mcp_permission_prompt_is_auto_approved, ca as next_thread_spawn_depth, cb as normalize_codex_apps_callable_name, cc as normalize_codex_apps_callable_namespace, cd as normalize_codex_apps_tool_title, ce as normalize_mcp_server_config, cf as normalize_mcp_server_configs, cg as oauth_login_support, ch as processResponseItemForPrompt, ci as qualified_mcp_tool_name_prefix, cj as qualify_tool_infos, ck as qualify_tools, cl as read_cached_codex_apps_tools, cm as record_additional_contexts, cn as requestPermissionsResponseFromDecision, co as resolve_oauth_scopes, cp as resolve_role_config, cq as resolve_session_base_instructions, cr as run_permission_request_hooks, cs as run_post_compact_hooks, ct as run_post_tool_use_hooks, cu as run_pre_compact_hooks, cv as run_pre_tool_use_hooks, cw as run_session_start_hooks, cx as run_stop_hooks, cy as run_user_prompt_submit_hooks, cz as runningHookRunSummary, cA as sanitize_name, cB as sanitize_responses_api_tool_name, cC as scopeForHookEvent, cD as sessionConfigurationActivePermissionProfile, cE as sessionConfigurationPermissionProfile, cF as sessionConfigurationSandboxPolicy, cG as sessionSettingsUpdateFromOverrideTurnContext, cH as sessionSettingsUpdateFromUserInput, cI as sessionSettingsUpdateFromUserInputWithTurnContext, cJ as sessionSettingsUpdateFromUserTurn, cK as session_configuration_from_config, cL as should_retry_without_scopes, cM as start_server_task, cN as startup_outcome_error_message, cO as tool_with_model_visible_input_schema, cP as transport_origin, cQ as truncate_function_output_payload, cR as turn_context_from_config, cS as validate_mcp_server_name, cT as write_cached_codex_apps_tools, cU as write_cached_codex_apps_tools_if_needed } from '../../history-CfM-4V7b.js';
+import { n as ProviderCapabilities } from '../../index-CoDZosq0.js';
+export { A as AuthDotJson, a as AuthMode, o as CHATGPT_CODEX_BASE_URL, p as CHATGPT_CODEX_PROVIDER_ID, q as CHATGPT_CODEX_PROVIDER_NAME, C as CODEX_CHATGPT_OAUTH_CALLBACK_PATH, b as CODEX_CHATGPT_OAUTH_CLIENT_ID, c as CODEX_CHATGPT_OAUTH_FALLBACK_PORT, d as CODEX_CHATGPT_OAUTH_ISSUER, e as CODEX_CHATGPT_OAUTH_ORIGINATOR, f as CODEX_CHATGPT_OAUTH_PRIMARY_PORT, g as CODEX_CHATGPT_OAUTH_SCOPE, r as ChatgptOAuthTokenExchangeRequest, h as ChatgptOAuthTokenExchangeResponse, i as CodexAuth, s as ConfiguredModelProvider, G as GetAccountResponse, M as Model, l as ModelInfo, t as ModelInstructionsVariables, u as ModelListParams, v as ModelListResponse, w as ModelMessages, j as ModelPreset, m as ModelProvider, x as ModelProviderAuthInfo, y as ModelProviderAwsAuthInfo, z as ModelProviderInfo, B as ModelServiceTier, D as ModelsManager, O as OPENAI_PROVIDER_ID, E as OPENAI_PROVIDER_NAME, F as OPENAI_RESPONSES_BASE_URL, H as PlanType, I as ProviderAccount, P as ProviderAccountState, k as ProviderRuntimeConfig, R as ReasoningEffortOption, J as RefreshStrategy, S as StaticModelsManager, T as TokenData, W as WireApi, K as apiKeyProviderAccountState, L as authDotJsonToBearerToken, N as authDotJsonToOpenAiApiKey, Q as autoCompactTokenLimit, U as chatgptAuthFromAuthDotJson, V as codexAuthToAccountState, X as createChatgptCodexModelProviderInfo, Y as createModelProvider, Z as createOpenAiModelProviderInfo, _ as defaultCodexModelInfo, $ as defaultCodexModels, a0 as defaultModelProviderAccountState, a1 as defaultModelsManager, a2 as defaultProviderCapabilities, a3 as effectiveContextWindow, a4 as get_model_instructions, a5 as isReasoningEffortSupported, a6 as listDefaultCodexModels, a7 as modelInfoFromSlug, a8 as modelInfoToPreset, a9 as normalizePlanType, aa as openAiAuthClaims, ab as parseJwtPayload, ac as providerRuntimeConfig, ad as resolveReasoningEffortForModel, ae as resolvedAuthMode, af as resolvedContextWindow, ag as validateModelProviderInfo } from '../../index-CoDZosq0.js';
+export { C as CODEX_PLAN_MODE_INSTRUCTIONS, b as builtinCollaborationModePresets, c as collaborationModePresetForMode, d as defaultModeInstructions, n as normalizeCollaborationMode } from '../../plan-mode-Cv6KWb_S.js';
+export { AgentRole, AgentRoles, BUILT_IN_DANGER_NO_SANDBOX_PROFILE, BUILT_IN_READ_ONLY_PROFILE, BUILT_IN_WORKSPACE_PROFILE, ManagedFeature, ManagedFeatures, NetworkProxySpec, activePermissionProfileForBuiltin, active_permission_profile, builtinPermissionProfile, builtinPermissionProfileNameFromProfile, defaultBuiltinPermissionProfileName, defaultNetworkProxySpec, disabledPermissionProfile, effectivePermissionProfile, emptyManagedFeatures, legacySandboxPolicyFromPermissionProfile, permissionProfileFromLegacySandboxPolicy, readOnlyPermissionProfile, tools_config_from_config, validatePermissionProfile, workspaceWritePermissionProfile } from './config/index.js';
+export { A as ApplyEventOptions, R as RenderedThreadConnectionStatus, a as RenderedThreadState, b as applyEventMsgToRenderedThread, d as applyRolloutItemToRenderedThread, c as createRenderedThreadState, f as fingerprintRolloutItems, r as renderThreadFromHistory, s as setRenderedThreadConnectionStatus } from '../../rendered-thread-AOxw3V5b.js';
+import { l as ToolNameInput, m as ToolName, n as DiscoverableTool, k as ToolsConfig, o as ToolSearchEntry, p as ToolSearchSourceInfo, f as WebSearchMode, W as WebSearchConfig, q as WebSearchToolType, r as ToolRegistryPlanParams, s as ToolRegistryPlan } from '../../spec_plan_types-CmsJ-Tfn.js';
+export { D as DefaultToolsConfigInput, t as TOOL_SEARCH_DEFAULT_LIMIT, u as TOOL_SEARCH_TOOL_NAME, v as ToolHandlerKind, w as ToolHandlerSpec, x as build_tool_search_entries, y as build_tool_search_entries_for_config, z as createToolRegistryPlan, A as defaultToolsConfig, B as dynamic_tool_to_tool_search_entry, E as mcp_tool_to_tool_search_entry, G as tool_search_outputs, H as tool_search_source_info_for_dynamic_tools, I as tool_search_source_info_for_mcp_tools } from '../../spec_plan_types-CmsJ-Tfn.js';
+export { L as LiveThread, a as LiveThreadInitGuard } from '../../live-thread-BMvlflzM.js';
+export { T as ThreadStore } from '../../store-AGRxhgQ3.js';
+export { A as AppendThreadItemsParams, a as ArchiveThreadParams, C as CreateThreadParams, G as GitInfoPatch, L as ListThreadsParams, b as LoadThreadHistoryParams, O as OptionalStringPatch, R as ReadThreadByRolloutPathParams, c as ReadThreadParams, d as ResumeThreadParams, S as SortDirection, e as StoredThread, f as StoredThreadHistory, T as ThreadEventPersistenceMode, g as ThreadMetadataPatch, h as ThreadPage, i as ThreadPersistenceMetadata, j as ThreadSortKey, U as UpdateThreadMetadataParams } from '../../types-BTeabLYr.js';
+export { P as PendingTurn, T as ThreadHistoryBuilder, a as Turn, b as TurnError, c as TurnItemsView, d as TurnStatus, e as appendCompactionTurnToTurns, f as applyEventToThreadHistoryBuilder, g as applyEventToTurns, h as applyResponseItemToTurns, i as buildTurnsFromRolloutItems, j as flattenTurnsToTurnItems } from '../../thread-history-builder-zW0zeqcS.js';
+export { P as Prompt, R as ResponseCreateWsRequest, a as ResponseEvent, b as ResponseProcessedWsRequest, c as ResponseStream, d as ResponsesApiRequest, e as ResponsesClient, f as ResponsesClientInput, j as ResponsesOptions, g as ResponsesWebsocketClient, k as ResponsesWebsocketClientInput, h as ResponsesWebsocketConnection, i as ResponsesWsRequest } from '../../responses_websocket-BhxSgCzK.js';
+export { l as resolve_web_search_mode_for_turn } from '../../merge-B_AWVmnI.js';
+import '../../WebSearchToolConfig-D3ep0625.js';
+
+declare const MCP_TOOL_CODEX_APPS_META_KEY = "_codex_apps";
+declare const CONNECTOR_AUTH_FAILURE_META_KEY = "connector_auth_failure";
+declare const CONNECTOR_AUTH_FAILURE_IS_AUTH_FAILURE_KEY = "is_auth_failure";
+declare const CONNECTOR_AUTH_FAILURE_AUTH_REASON_KEY = "auth_reason";
+declare const CONNECTOR_AUTH_FAILURE_CONNECTOR_ID_KEY = "connector_id";
+declare const CONNECTOR_AUTH_FAILURE_LINK_ID_KEY = "link_id";
+declare const CONNECTOR_AUTH_FAILURE_ERROR_CODE_KEY = "error_code";
+declare const CONNECTOR_AUTH_FAILURE_ERROR_HTTP_STATUS_CODE_KEY = "error_http_status_code";
+declare const CONNECTOR_AUTH_FAILURE_ERROR_ACTION_KEY = "error_action";
+type CallToolResult = {
+    content?: unknown[];
+    structured_content?: unknown;
+    is_error?: boolean | null;
+    meta?: unknown;
+};
+type CodexAppsConnectorAuthFailure = {
+    connector_id: string;
+    connector_name: string;
+    install_url: string;
+    auth_reason?: string | null;
+    link_id?: string | null;
+    error_code?: string | null;
+    error_http_status_code?: number | null;
+    error_action?: string | null;
+};
+type CodexAppsAuthElicitation = {
+    meta: unknown;
+    message: string;
+    url: string;
+    elicitation_id: string;
+};
+type CodexAppsAuthElicitationPlan = {
+    auth_failure: CodexAppsConnectorAuthFailure;
+    elicitation: CodexAppsAuthElicitation;
+};
+declare function connector_auth_failure_from_tool_result(result: CallToolResult, connector_id?: string | null, connector_name?: string | null, install_url?: string | null): CodexAppsConnectorAuthFailure | null;
+declare function build_auth_elicitation_plan(call_id: string, result: CallToolResult, connector_id?: string | null, connector_name?: string | null, install_url?: string | null): CodexAppsAuthElicitationPlan | null;
+declare function build_auth_elicitation(call_id: string, auth_failure: CodexAppsConnectorAuthFailure): CodexAppsAuthElicitation;
+declare function auth_elicitation_completed_result(auth_failure: CodexAppsConnectorAuthFailure, meta?: unknown): CallToolResult;
+declare function auth_elicitation_id(call_id: string): string;
+declare function auth_elicitation_message(auth_failure: CodexAppsConnectorAuthFailure): string;
+
+declare function resolve_agent_target(registry: AgentRegistry, target: string): ThreadId | null;
+
+declare function is_final(status: AgentStatus): boolean;
+declare function agent_status_from_event(event: unknown): AgentStatus;
+
+declare class GoalRuntimeState {
+    private readonly params;
+    private readonly turn_snapshots;
+    private budget_limit_reported_goal_id;
+    constructor(params: {
+        thread_id: ThreadId;
+        store?: ThreadGoalStore | null;
+        now?: () => number;
+    });
+    get_thread_goal(): Promise<ThreadGoal | null>;
+    create_thread_goal(request: CreateGoalRequest): Promise<ThreadGoal>;
+    set_thread_goal(request: SetGoalRequest): Promise<ThreadGoal>;
+    update_thread_goal_complete(): Promise<ThreadGoal>;
+    clear_thread_goal(): Promise<void>;
+    apply(event: GoalRuntimeEvent): Promise<GoalRuntimeApplyResult>;
+    budget_limit_steering_items(): Promise<ResponseItem[]>;
+    format_tool_output(goal: ThreadGoal | null): GoalToolOutput;
+    private mark_thread_goal_turn_started;
+    private finish_thread_goal_turn;
+    private handle_thread_goal_task_abort;
+    private account_thread_goal_progress;
+    private require_store;
+    private now;
+}
+declare function totalTokensFromTokenUsageInfo(info: TokenUsageInfo | null): number;
+declare function goalToolOutput(goal: ThreadGoal | null): GoalToolOutput;
+declare function remainingTokenBudget(goal: ThreadGoal | null): number | null;
+declare function budget_limit_prompt(goal: ThreadGoal): string;
+declare function budget_limit_steering_item(goal: ThreadGoal): ResponseItem;
+
+declare function select_handlers(handlers: readonly ConfiguredHookHandler[], eventName: HookEventName, matcherInput?: string | null): ConfiguredHookHandler[];
+declare function select_handlers_for_matcher_inputs(handlers: readonly ConfiguredHookHandler[], eventName: HookEventName, matcherInputs: readonly string[]): ConfiguredHookHandler[];
+declare function matches_matcher(matcher: string | null | undefined, input: string | null): boolean;
+declare function matcher_inputs(toolName: string, matcherAliases?: readonly string[]): string[];
+
+type UniversalHookOutput = {
+    continue_processing?: boolean;
+    stop_reason?: string | null;
+    suppress_output?: boolean;
+    system_message?: string | null;
+};
+declare function looks_like_json(text: string): boolean;
+declare function parse_hook_handler_json(stdout: string): HookHandlerResult | null;
+
+declare const ToolKind: {
+    readonly Function: "Function";
+    readonly Mcp: "Mcp";
+};
+type ToolKind = (typeof ToolKind)[keyof typeof ToolKind];
+type SearchToolCallParams = {
+    query?: string;
+    limit?: number;
+    [key: string]: unknown;
+};
+type ShellToolCallParams = {
+    command?: string[];
+    workdir?: string | null;
+    timeout_ms?: number | null;
+    sandbox_permissions?: unknown;
+    prefix_rule?: string[] | null;
+    justification?: string | null;
+    [key: string]: unknown;
+};
+type ToolPayload = {
+    type: "function";
+    arguments: string;
+} | {
+    type: "tool_search";
+    arguments: SearchToolCallParams;
+} | {
+    type: "custom";
+    input: string;
+} | {
+    type: "local_shell";
+    params: ShellToolCallParams;
+} | {
+    type: "mcp";
+    server: string;
+    tool: string;
+    raw_arguments: string;
+};
+declare function logPayload(payload: ToolPayload): string;
+type ToolCallSource = {
+    type: "direct";
+} | {
+    type: "code_mode";
+    cell_id: string;
+    runtime_tool_call_id: string;
+};
+type ToolInvocation = {
+    session: Session;
+    turn: TurnContext;
+    cancellation_token: CancellationToken;
+    call_id: string;
+    tool_name: ToolNameInput;
+    source: ToolCallSource;
+    payload: ToolPayload;
+};
+declare class CancellationToken {
+    readonly signal?: AbortSignal | undefined;
+    constructor(signal?: AbortSignal | undefined);
+    is_cancelled(): boolean;
+    cancelled(): Promise<void>;
+}
+type PreToolUsePayload = {
+    tool_name: string;
+    tool_input: unknown;
+};
+type PostToolUsePayload = {
+    tool_name: string;
+    tool_use_id: string;
+    tool_input: unknown;
+    tool_response: unknown;
+};
+interface ToolArgumentDiffConsumer {
+    consumeDiff(turn: TurnContext, callId: string, diff: string): unknown | null;
+    finish?(): unknown | null;
+}
+interface ToolOutput {
+    logPreview(): string;
+    successForLogging(): boolean;
+    toResponseItem(callId: string, payload: ToolPayload): ResponseInputItem;
+    postToolUseResponse(callId: string, payload: ToolPayload): unknown | null;
+    codeModeResult(payload: ToolPayload): unknown;
+}
+declare class FunctionToolOutput implements ToolOutput {
+    readonly body: FunctionCallOutputContentItem[];
+    readonly success?: boolean | null | undefined;
+    readonly post_tool_use_response: unknown | null;
+    constructor(body: FunctionCallOutputContentItem[], success?: boolean | null | undefined, post_tool_use_response?: unknown | null);
+    static fromText(text: string, success?: boolean | null): FunctionToolOutput;
+    static fromContent(content: FunctionCallOutputContentItem[], success?: boolean | null): FunctionToolOutput;
+    intoText(): string;
+    logPreview(): string;
+    successForLogging(): boolean;
+    toResponseItem(callId: string, payload: ToolPayload): ResponseInputItem;
+    postToolUseResponse(): unknown | null;
+    codeModeResult(): unknown;
+}
+declare class McpToolOutput implements ToolOutput {
+    readonly result: unknown;
+    readonly tool_input: unknown;
+    readonly wall_time_ms: number;
+    readonly original_image_detail_supported: boolean;
+    readonly truncation_policy?: (TruncationPolicy | null) | undefined;
+    constructor(result: unknown, tool_input: unknown, wall_time_ms: number, original_image_detail_supported: boolean, truncation_policy?: (TruncationPolicy | null) | undefined);
+    logPreview(): string;
+    successForLogging(): boolean;
+    toResponseItem(callId: string): ResponseInputItem;
+    postToolUseResponse(): unknown | null;
+    codeModeResult(): unknown;
+    private response_payload;
+}
+interface ToolHandler<TOutput extends ToolOutput = ToolOutput> {
+    toolName(): ToolNameInput;
+    kind(): ToolKind;
+    matchesKind?(payload: ToolPayload): boolean;
+    isMutating?(invocation: ToolInvocation): Promise<boolean>;
+    preToolUsePayload?(invocation: ToolInvocation): PreToolUsePayload | null;
+    postToolUsePayload?(invocation: ToolInvocation, result: TOutput): PostToolUsePayload | null;
+    createDiffConsumer?(): ToolArgumentDiffConsumer | null;
+    handle(invocation: ToolInvocation): Promise<TOutput>;
+}
+declare function matchesToolKind(kind: ToolKind, payload: ToolPayload): boolean;
+declare class AnyToolResult {
+    readonly call_id: string;
+    readonly payload: ToolPayload;
+    readonly result: ToolOutput;
+    readonly post_tool_use_payload: PostToolUsePayload | null;
+    constructor(call_id: string, payload: ToolPayload, result: ToolOutput, post_tool_use_payload: PostToolUsePayload | null);
+    intoResponse(): ResponseInputItem;
+    codeModeResult(): unknown;
+}
+declare const FunctionCallErrorKind: {
+    readonly RespondToModel: "respond_to_model";
+    readonly Fatal: "fatal";
+};
+type FunctionCallErrorKind = (typeof FunctionCallErrorKind)[keyof typeof FunctionCallErrorKind];
+declare class FunctionCallError extends Error {
+    readonly kind: FunctionCallErrorKind;
+    private constructor();
+    static respondToModel(message: string): FunctionCallError;
+    static fatal(message: string): FunctionCallError;
+}
+declare class ToolRegistry {
+    private readonly handlers;
+    private constructor();
+    static emptyForTest(): ToolRegistry;
+    static withHandlerForTest(handler: ToolHandler): ToolRegistry;
+    static fromHandlersForBuilder(handlers: Map<string, ToolHandler>): ToolRegistry;
+    hasHandler(name: ToolNameInput): boolean;
+    createDiffConsumer(name: ToolNameInput): ToolArgumentDiffConsumer | null;
+    dispatchAny(invocation: ToolInvocation): Promise<AnyToolResult>;
+}
+
+declare const SUMMARIZATION_PROMPT: string;
+declare const SUMMARY_PREFIX: string;
+declare function compactedThreadWarning(): string;
+declare function contentItemsToText(content: readonly ResponseItemMessageContent[]): string | null;
+declare function collectUserMessages(items: readonly ResponseItem[]): string[];
+declare function isSummaryMessage(message: string): boolean;
+declare function buildCompactedHistory(initialContext: ResponseItem[], userMessages: readonly string[], summaryText: string): ResponseItem[];
+type ResponseItemMessageContent = Extract<ResponseItem, {
+    type: "message";
+}>["content"][number];
+
+type ContextualUserFragmentParams = {
+    role: string;
+    start_marker: string;
+    end_marker: string;
+    body: () => string;
+};
+declare class ContextualUserFragment {
+    readonly role: string;
+    readonly start_marker: string;
+    readonly end_marker: string;
+    private readonly bodyFn;
+    constructor(params: ContextualUserFragmentParams);
+    body(): string;
+    matchesText(text: string): boolean;
+    render(): string;
+    toResponseItem(): ResponseItem;
+}
+declare function contextualFragmentMatchesText(text: string, markers: {
+    start_marker: string;
+    end_marker: string;
+}): boolean;
+
+declare const ENVIRONMENT_CONTEXT_OPEN_TAG = "<environment_context>";
+declare const ENVIRONMENT_CONTEXT_CLOSE_TAG = "</environment_context>";
+type EnvironmentContextEnvironment = {
+    id?: string;
+    cwd: string;
+    shell: string;
+};
+type NetworkContext = {
+    allowed_domains: string[];
+    denied_domains: string[];
+};
+declare class EnvironmentContext extends ContextualUserFragment {
+    constructor(params: {
+        environments: EnvironmentContextEnvironment[];
+        current_date?: string | null;
+        timezone?: string | null;
+        network?: NetworkContext | null;
+    });
+    static fromTurnContext(turnContext: TurnContext): EnvironmentContext;
+    static fromTurnContextItem(item: TurnContextItem): EnvironmentContext;
+}
+
+declare class CollaborationModeInstructions {
+    private readonly instructions;
+    private constructor();
+    static fromCollaborationMode(collaborationMode: CollaborationMode | null): CollaborationModeInstructions | null;
+    toResponseItem(): ResponseItem;
+    toText(): string;
+    private toFragment;
+}
+
+type PreviousTurnSettings = {
+    model?: string | null;
+    realtime_active?: boolean | null;
+};
+type RolloutReconstruction = {
+    history: ResponseItem[];
+    previous_turn_settings: PreviousTurnSettings | null;
+    reference_context_item: TurnContextItem | null;
+};
+declare function reconstructHistoryFromRollout(rolloutItems: RolloutItem[]): RolloutReconstruction;
+
+declare class ModelSwitchInstructions extends ContextualUserFragment {
+    constructor(text: string);
+}
+declare function buildInitialContextItems(turnContext: TurnContext): ResponseItem[];
+declare function buildSettingsUpdateItems(previous: TurnContextItem | null | undefined, previousTurnSettings: PreviousTurnSettings | null | undefined, next: TurnContext): ResponseItem[];
+declare function buildModelInstructionsUpdateItem(previousTurnSettings: PreviousTurnSettings | null | undefined, next: TurnContext): string | null;
+
+declare class PermissionsInstructions extends ContextualUserFragment {
+    constructor(text: string);
+    static fromTurnContext(turnContext: TurnContext, options?: {
+        request_permissions_tool_enabled?: boolean;
+    }): PermissionsInstructions;
+}
+
+declare function buildPromptBaseInstructions(turnContext: TurnContext): BaseInstructions;
+declare function buildPromptInputWithContext(input: ResponseItem[], turnContext: TurnContext): ResponseItem[];
+declare function buildCollaborationModeInstructions(turnContext: TurnContext): ResponseItem | null;
+
+declare const TURN_ABORTED_INTERRUPTED_GUIDANCE = "The user interrupted the previous turn on purpose. Any running unified exec processes may still be running in the background. If any tools/commands were aborted, they may have partially executed.";
+declare function turnAbortedResponseItem(guidance?: string): ResponseItem;
+
+declare class UserInstructions extends ContextualUserFragment {
+    constructor(params: {
+        directory: string;
+        text: string;
+    });
+}
+
+declare function ensureCallOutputsPresent(items: ResponseItem[]): ResponseItem[];
+declare function removeOrphanOutputs(items: ResponseItem[]): ResponseItem[];
+declare function removeCorrespondingFor(items: ResponseItem[], item: ResponseItem): ResponseItem[];
+declare function normalizeResponseHistory(items: ResponseItem[]): ResponseItem[];
+declare function stripImagesWhenUnsupported(inputModalities: readonly string[] | null | undefined, items: ResponseItem[]): ResponseItem[];
+
+declare function isContextualUserMessageContent(message: readonly ContentItem[]): boolean;
+declare function isContextualDevMessageContent(message: readonly ContentItem[]): boolean;
+declare function hasNonContextualDevMessageContent(message: readonly ContentItem[]): boolean;
+declare function parseUserMessage(id: string | null | undefined, message: readonly ContentItem[]): UserMessageTurnItem | null;
+declare function parseAgentMessage(id: string | null | undefined, message: readonly ContentItem[], phase?: string | null): AgentMessageTurnItem;
+declare function parseVisibleHookPromptMessage(id: string | null | undefined, message: readonly ContentItem[]): HookPromptTurnItem | null;
+declare function parseTurnItem(item: ResponseItem): TurnItem | null;
+
+type ToolRouterParams = {
+    dynamic_tools: readonly DynamicToolSpec[];
+    mcp_tools?: readonly McpToolInfo[];
+    deferred_mcp_tools?: readonly McpToolInfo[];
+    unavailable_called_tools?: readonly ToolName[];
+    parallel_mcp_server_names?: ReadonlySet<string>;
+    discoverable_tools?: readonly DiscoverableTool[];
+    provider_capabilities?: Partial<ProviderCapabilities>;
+    tools_config?: Partial<ToolsConfig>;
+};
+type ToolCall = {
+    call_id: string;
+    tool_name: ToolName;
+    payload: ToolPayload;
+};
+declare class ToolRouter {
+    private readonly tool_registry;
+    private readonly configured_specs;
+    private readonly visible_specs;
+    private readonly parallel_tool_names;
+    private readonly parallel_mcp_server_names;
+    private constructor();
+    static from_config(params: ToolRouterParams): ToolRouter;
+    specs(): ToolSpec[];
+    configured_tools(): ConfiguredToolSpec[];
+    model_visible_specs(): ToolSpec[];
+    registry_for_test(): ToolRegistry;
+    registry(): ToolRegistry;
+    find_spec(toolName: ToolNameInput): ToolSpec | null;
+    createDiffConsumer(toolName: ToolNameInput): ToolArgumentDiffConsumer | null;
+    tool_supports_parallel(call: ToolCall): boolean;
+    static build_tool_call(session: Session, item: ResponseItem): Promise<ToolCall | null>;
+    dispatch_tool_call_with_code_mode_result(params: {
+        session: Session;
+        turn: TurnContext;
+        call: ToolCall;
+        source?: ToolCallSource;
+        signal?: AbortSignal;
+    }): Promise<AnyToolResult>;
+}
+
+declare class ToolDispatchTrace {
+    readonly events: Array<{
+        type: "started" | "completed" | "failed";
+        call_id: string;
+        tool_name: string;
+        message?: string;
+    }>;
+    start(call: ToolCall): void;
+    record_completed(call: ToolCall): void;
+    record_failed(call: ToolCall, error: Error): void;
+}
+
+type ToolCallRuntimeParams = {
+    router: ToolRouter;
+    session: Session;
+    turn: TurnContext;
+};
+declare class AbortedToolOutput implements ToolOutput {
+    readonly message: string;
+    constructor(message: string);
+    logPreview(): string;
+    successForLogging(): boolean;
+    toResponseItem(callId: string, payload: ToolPayload): ResponseInputItem;
+    postToolUseResponse(): unknown | null;
+    codeModeResult(): unknown;
+}
+declare class ToolCallRuntime {
+    private readonly params;
+    private readonly parallelExecution;
+    constructor(params: ToolCallRuntimeParams);
+    find_spec(toolName: Parameters<ToolRouter["find_spec"]>[0]): ToolSpec | null;
+    create_diff_consumer(toolName: Parameters<ToolRouter["createDiffConsumer"]>[0]): ToolArgumentDiffConsumer | null;
+    handle_tool_call(call: ToolCall, signal?: AbortSignal): Promise<ResponseInputItem>;
+    handle_tool_call_with_source(call: ToolCall, source?: ToolCallSource, signal?: AbortSignal, trace?: ToolDispatchTrace): Promise<AnyToolResult>;
+    static failureResponse(call: ToolCall, error: FunctionCallError): ResponseInputItem;
+    static abortedResponse(call: ToolCall, secs: number): AnyToolResult;
+    private raceAbort;
+    private static abortMessage;
+}
+
+type RunTurnParams = {
+    modelClient: ModelClient;
+    session: Session;
+    turn: TurnContext;
+    history: RolloutItem[];
+    submission: Submission;
+    signal?: AbortSignal;
+    completeTurn?: boolean;
+};
+type SamplingRequestResult = {
+    turn: TurnContext;
+    modelInput: ResponseItem[];
+    lastAgentMessage: string | null;
+    steps: number;
+};
+declare function runTurn(params: RunTurnParams): Promise<SamplingRequestResult>;
+declare function run_sampling_request(params: {
+    session: Session;
+    turn: TurnContext;
+    router: ToolRouter;
+    toolRuntime?: ToolCallRuntime;
+    clientSession: ModelClientSessionHandle;
+    input: ResponseItem[];
+    maxSteps?: number;
+    signal?: AbortSignal;
+    completeTurn?: boolean;
+    includePromptContext?: boolean;
+}): Promise<SamplingRequestResult>;
+
+type SessionStateParams = {
+    session_configuration: SessionConfiguration;
+    history?: ContextManager | null;
+    latest_rate_limits?: RateLimitSnapshot | null;
+    server_reasoning_included?: boolean;
+    previous_turn_settings?: PreviousTurnSettings | null;
+    reference_context_item?: TurnContextItem | null;
+    token_info?: TokenUsageInfo | null;
+};
+declare class SessionState {
+    readonly session_configuration: SessionConfiguration;
+    readonly history: ContextManager;
+    private latest_rate_limits_value;
+    private server_reasoning_included_value;
+    private previous_turn_settings_value;
+    constructor(params: SessionStateParams);
+    record_items(items: Iterable<ResponseItem>, policy?: TruncationPolicy | null): void;
+    previous_turn_settings(): PreviousTurnSettings | null;
+    set_previous_turn_settings(value: PreviousTurnSettings | null): void;
+    clone_history(): ContextManager;
+    replace_history(items: ResponseItem[], referenceContextItem: TurnContextItem | null): void;
+    set_token_info(info: TokenUsageInfo | null): void;
+    set_reference_context_item(item: TurnContextItem | null): void;
+    reference_context_item(): TurnContextItem | null;
+    update_token_info_from_usage(usage: TokenUsage, modelContextWindow?: number | null): void;
+    token_info(): TokenUsageInfo | null;
+    set_rate_limits(snapshot: RateLimitSnapshot): void;
+    set_latest_rate_limits(snapshot: RateLimitSnapshot | null): void;
+    latest_rate_limits(): RateLimitSnapshot | null;
+    token_info_and_rate_limits(): [TokenUsageInfo | null, RateLimitSnapshot | null];
+    set_token_usage_full(contextWindow: number): void;
+    get_total_token_usage(serverReasoningIncluded?: boolean): number;
+    get_total_token_usage_breakdown(): TotalTokenUsageBreakdown;
+    set_server_reasoning_included(included: boolean): void;
+    server_reasoning_included(): boolean;
+}
+
+type StreamTextChunk<TExtracted> = {
+    visible_text: string;
+    extracted: TExtracted[];
+};
+type ProposedPlanSegment = {
+    type: "Normal";
+    text: string;
+} | {
+    type: "ProposedPlanStart";
+} | {
+    type: "ProposedPlanDelta";
+    text: string;
+} | {
+    type: "ProposedPlanEnd";
+};
+type AssistantTextChunk = {
+    visible_text: string;
+    citations: string[];
+    plan_segments: ProposedPlanSegment[];
+};
+declare class ProposedPlanParser {
+    private readonly parser;
+    push_str(chunk: string): StreamTextChunk<ProposedPlanSegment>;
+    finish(): StreamTextChunk<ProposedPlanSegment>;
+}
+declare function stripProposedPlanBlocks(text: string): string;
+declare function extractProposedPlanText(text: string): string | null;
+declare class AssistantTextStreamParser {
+    private readonly planMode;
+    private readonly citations;
+    private readonly plan;
+    constructor(planMode: boolean);
+    push_str(chunk: string): AssistantTextChunk;
+    finish(): AssistantTextChunk;
+    private parseVisibleText;
+}
+
+declare function record_completed_response_item(session: Session, turnContext: TurnContext, item: ResponseItem): Promise<void>;
+type InFlightFuture = Promise<ResponseItem>;
+type OutputItemResult = {
+    last_agent_message: string | null;
+    needs_follow_up: boolean;
+    tool_future: InFlightFuture | null;
+    streamed_item_id?: string | null;
+};
+type HandleOutputCtx = {
+    session: Session;
+    turn_context: TurnContext;
+    tool_runtime: ToolCallRuntime;
+    plan_mode_stream: PlanModeStreamState | null;
+    streamed_item_id: string | null;
+    signal?: AbortSignal;
+};
+declare function handle_output_item_done(ctx: HandleOutputCtx, item: ResponseItem): Promise<OutputItemResult>;
+declare function handle_non_tool_response_item(ctx: HandleOutputCtx, item: ResponseItem): Promise<OutputItemResult>;
+declare function last_assistant_message_from_item(item: ResponseItem, planMode: boolean): string | null;
+declare class PlanModeStreamState {
+    private readonly params;
+    private readonly itemId;
+    private readonly parser;
+    private emittedPlanText;
+    private planItemStarted;
+    constructor(params: {
+        session: Session;
+        turn: TurnContext;
+    });
+    pushDelta(delta: string): Promise<string>;
+    completeFromFinalText(text: string): Promise<{
+        assistantText: string | null;
+        planText: string | null;
+    }>;
+    private emitPlanSegments;
+    private emitRemainingPlanDelta;
+    private emitPlanDelta;
+    private startPlanItem;
+}
+
+type RegularTaskRunner = (input: {
+    session: Session;
+    turn: TurnContext;
+    history: RolloutItem[];
+    submission: Submission;
+    signal?: AbortSignal;
+}) => Promise<SessionTaskResult>;
+type RegularTaskParams = {
+    history: RolloutItem[];
+    submission: Submission;
+    run_turn: RegularTaskRunner;
+};
+declare class RegularTask implements SessionTask {
+    private readonly history;
+    private readonly submission;
+    private readonly run_turn;
+    constructor(params: RegularTaskParams);
+    static new(params: RegularTaskParams): RegularTask;
+    kind(): TaskKind;
+    span_name(): string;
+    records_turn_token_usage_on_span(): boolean;
+    run(input: SessionTaskRunInput): Promise<SessionTaskResult>;
+}
+
+type CompactTaskRunner = (input: {
+    session: Session;
+    turn: TurnContext;
+    history: RolloutItem[];
+    submission: Submission;
+    signal?: AbortSignal;
+}) => Promise<SessionTaskResult>;
+type CompactTaskParams = {
+    history: RolloutItem[];
+    submission: Submission;
+    run_compact_task: CompactTaskRunner;
+};
+declare class CompactTask implements SessionTask {
+    private readonly history;
+    private readonly submission;
+    private readonly run_compact_task;
+    constructor(params: CompactTaskParams);
+    kind(): TaskKind;
+    span_name(): string;
+    records_turn_token_usage_on_span(): boolean;
+    run(input: SessionTaskRunInput): Promise<SessionTaskResult>;
+}
+
+declare const CORE_TEMPLATES: {
+    readonly "compact/prompt.md": "Your task is to create a concise summary of the conversation so far.\n\nPreserve user intent, important decisions, constraints, current task state, and any unresolved requests.\nDo not add new recommendations or solve the task.";
+    readonly "compact/summary_prefix.md": "Conversation summary:";
+    readonly "goals/budget_limit.md": "The active thread goal has reached its token budget.\n\n<untrusted_objective>\n{{objective}}\n</untrusted_objective>\n\nGoal status is now budgetLimited. Do not start substantive new work on the goal. Wrap up soon with concise progress, remaining work, and the next useful step. Do not call update_goal unless the objective is actually complete.\n\nTime spent: {{time_used_seconds}}s\nTokens used: {{tokens_used}}\nToken budget: {{token_budget}}\nRemaining budget: {{remaining_token_budget}}";
+    readonly "goals/continuation.md": "The active thread goal is still in progress. Continue working toward the objective while respecting the remaining budget.";
+    readonly "model_instructions/default_instructions_template.md": "";
+    readonly "personalities/default.md": "";
+    readonly "search_tool/tool_search.md": "Search available deferred tools and return the best matching tool definitions.";
+};
+type CoreTemplatePath = keyof typeof CORE_TEMPLATES;
+declare function loadCoreTemplate(path: CoreTemplatePath): string;
+declare function renderCoreTemplate(path: CoreTemplatePath, variables: Record<string, string | number | null | undefined>): string;
+
+type CompactTaskResult = {
+    summary: string;
+    replacement_history: ResponseItem[];
+};
+declare function run_compact_task(params: {
+    modelClient: ModelClient;
+    session: Session;
+    history: RolloutItem[];
+    submission: Submission;
+    turn?: TurnContext;
+    signal?: AbortSignal;
+    completeTurn?: boolean;
+}): Promise<CompactTaskResult>;
+
+declare const HookToolEventName: {
+    readonly PreToolUse: "PreToolUse";
+    readonly PostToolUse: "PostToolUse";
+    readonly PermissionRequest: "PermissionRequest";
+};
+type HookToolEventName = (typeof HookToolEventName)[keyof typeof HookToolEventName];
+
+type NetworkApprovalDecision = {
+    type: "approved";
+} | {
+    type: "denied";
+    reason: string;
+};
+declare function request_network_approval(): Promise<NetworkApprovalDecision>;
+declare function network_approval_denied_error(decision: Extract<NetworkApprovalDecision, {
+    type: "denied";
+}>): FunctionCallError;
+
+declare const APPLY_PATCH_TOOL_NAME = "apply_patch";
+declare class ApplyPatchHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    isMutating(): Promise<boolean>;
+    handle(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+type ApplyPatchArgs = {
+    patch?: string;
+};
+declare function parseApplyPatchChanges(patch: string): Record<string, FileChange>;
+
+declare function create_apply_patch_tool(): {
+    type: "function";
+    name: string;
+    description: string;
+    strict: boolean;
+    parameters: {
+        type: string;
+        properties: {
+            patch: {
+                type: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+};
+
+declare const LIST_MCP_RESOURCES_TOOL_NAME = "list_mcp_resources";
+declare const LIST_MCP_RESOURCE_TEMPLATES_TOOL_NAME = "list_mcp_resource_templates";
+declare const READ_MCP_RESOURCE_TOOL_NAME = "read_mcp_resource";
+declare abstract class McpResourceHandler implements ToolHandler<FunctionToolOutput> {
+    abstract toolName(): ToolName;
+    abstract handleFunctionCall(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+    kind(): ToolKind;
+    handle(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+declare class ListMcpResourcesHandler extends McpResourceHandler {
+    toolName(): ToolName;
+    handleFunctionCall(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+declare class ListMcpResourceTemplatesHandler extends McpResourceHandler {
+    toolName(): ToolName;
+    handleFunctionCall(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+declare class ReadMcpResourceHandler extends McpResourceHandler {
+    toolName(): ToolName;
+    handleFunctionCall(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+
+declare function create_list_mcp_resources_tool(): {
+    parameters: {
+        type: string;
+        properties: {
+            server: {
+                type: string;
+                description: string;
+            };
+            cursor: {
+                type: string;
+                description: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    type: "function";
+    name: string;
+    description: string;
+    strict: boolean;
+};
+declare function create_list_mcp_resource_templates_tool(): {
+    parameters: {
+        type: string;
+        properties: {
+            server: {
+                type: string;
+                description: string;
+            };
+            cursor: {
+                type: string;
+                description: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    type: "function";
+    name: string;
+    description: string;
+    strict: boolean;
+};
+declare function create_read_mcp_resource_tool(): {
+    parameters: {
+        type: string;
+        properties: {
+            server: {
+                type: string;
+                description: string;
+            };
+            uri: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    type: "function";
+    name: string;
+    description: string;
+    strict: boolean;
+};
+
+type DynamicToolHandlerParams = {
+    tool_name: ToolNameInput;
+};
+declare class DynamicToolHandler implements ToolHandler<FunctionToolOutput> {
+    private readonly tool_name;
+    constructor(params: DynamicToolHandlerParams);
+    toolName(): ToolName;
+    kind(): ToolKind;
+    isMutating(): Promise<boolean>;
+    handle(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+declare function dynamicToolName(input: {
+    namespace?: string | null;
+    name: string;
+}): string;
+
+declare const GET_GOAL_TOOL_NAME = "get_goal";
+declare const CREATE_GOAL_TOOL_NAME = "create_goal";
+declare const UPDATE_GOAL_TOOL_NAME = "update_goal";
+declare class GetGoalHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+declare class CreateGoalHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+declare class UpdateGoalHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+
+declare function create_get_goal_tool(): {
+    type: "function";
+    name: string;
+    description: string;
+    strict: boolean;
+    parameters: {
+        type: string;
+        properties: {};
+        required: never[];
+        additionalProperties: boolean;
+    };
+};
+declare function create_create_goal_tool(): {
+    type: "function";
+    name: string;
+    description: string;
+    strict: boolean;
+    parameters: {
+        type: string;
+        properties: {
+            objective: {
+                type: string;
+                description: string;
+            };
+            token_budget: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+};
+declare function create_update_goal_tool(): {
+    type: "function";
+    name: string;
+    description: string;
+    strict: boolean;
+    parameters: {
+        type: string;
+        properties: {
+            status: {
+                type: string;
+                enum: "complete"[];
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+};
+
+declare class McpToolHandler implements ToolHandler<McpToolOutput> {
+    readonly tool: McpToolInfo;
+    private readonly name;
+    constructor(tool: McpToolInfo);
+    toolName(): ToolNameInput;
+    kind(): ToolKind;
+    matchesKind(payload: ToolPayload): boolean;
+    preToolUsePayload(invocation: ToolInvocation): {
+        tool_name: string;
+        tool_input: unknown;
+    };
+    postToolUsePayload(invocation: ToolInvocation, result: McpToolOutput): {
+        tool_name: string;
+        tool_use_id: string;
+        tool_input: unknown;
+        tool_response: unknown;
+    };
+    handle(invocation: ToolInvocation): Promise<McpToolOutput>;
+}
+declare function mcpArgumentsFromPayload(payload: ToolPayload): unknown;
+
+declare const SPAWN_AGENT_TOOL_NAME = "spawn_agent";
+declare const SEND_INPUT_TOOL_NAME = "send_input";
+declare const WAIT_AGENT_TOOL_NAME = "wait_agent";
+declare const CLOSE_AGENT_TOOL_NAME = "close_agent";
+declare const RESUME_AGENT_TOOL_NAME = "resume_agent";
+declare const LIST_AGENTS_TOOL_NAME = "list_agents";
+declare const SEND_MESSAGE_TOOL_NAME = "send_message";
+declare const FOLLOWUP_TASK_TOOL_NAME = "followup_task";
+declare class SpawnAgentHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+declare class SendInputHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+declare class WaitAgentHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+declare class CloseAgentHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+declare class ResumeAgentHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+declare class ListAgentsHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+declare class SendMessageHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+declare class FollowupTaskHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+
+declare const MIN_WAIT_TIMEOUT_MS = 1000;
+declare const DEFAULT_WAIT_TIMEOUT_MS = 30000;
+declare const MAX_WAIT_TIMEOUT_MS = 3600000;
+
+type WaitAgentTimeoutOptions = {
+    default_timeout_ms: number;
+    min_timeout_ms: number;
+    max_timeout_ms: number;
+};
+
+declare const PLAN_TOOL_NAME = "update_plan";
+declare class PlanHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+
+declare function create_update_plan_tool(): {
+    type: "function";
+    name: string;
+    description: string;
+    strict: boolean;
+    parameters: {
+        type: string;
+        properties: {
+            explanation: {
+                type: string;
+            };
+            plan: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                    properties: {
+                        step: {
+                            type: string;
+                        };
+                        status: {
+                            type: string;
+                            description: string;
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+};
+declare const create_plan_tool: typeof create_update_plan_tool;
+
+declare const REQUEST_PLUGIN_INSTALL_TOOL_NAME = "request_plugin_install";
+declare class RequestPluginInstallHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(): Promise<FunctionToolOutput>;
+}
+
+declare function create_request_plugin_install_tool(): {
+    type: "function";
+    name: string;
+    description: string;
+    strict: boolean;
+    parameters: {
+        type: string;
+        properties: {};
+        required: never[];
+        additionalProperties: boolean;
+    };
+};
+
+declare class RequestPermissionsHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+
+type RequestUserInputHandlerParams = {
+    available_modes: ModeKind[];
+};
+declare class RequestUserInputHandler implements ToolHandler<FunctionToolOutput> {
+    private readonly params;
+    constructor(params: RequestUserInputHandlerParams);
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+
+declare function create_exec_command_tool(): {
+    type: "function";
+    name: string;
+    description: string;
+    strict: boolean;
+    parameters: {
+        type: string;
+        properties: {
+            cmd: {
+                type: string;
+            };
+            workdir: {
+                type: string;
+            };
+            yield_time_ms: {
+                type: string;
+            };
+            max_output_tokens: {
+                type: string;
+            };
+            sandbox_permissions: {};
+            justification: {
+                type: string;
+            };
+            prefix_rule: {
+                type: string;
+                items: {
+                    type: string;
+                };
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+};
+declare function create_write_stdin_tool(): {
+    type: "function";
+    name: string;
+    description: string;
+    strict: boolean;
+    parameters: {
+        type: string;
+        properties: {
+            process_id: {
+                type: string;
+            };
+            chars: {
+                type: string;
+            };
+            yield_time_ms: {
+                type: string;
+            };
+            max_output_tokens: {
+                type: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+};
+
+declare const TEST_SYNC_TOOL_NAME = "test_sync";
+
+declare function create_test_sync_tool(): {
+    type: "function";
+    name: string;
+    description: string;
+    strict: boolean;
+    parameters: {
+        type: string;
+        properties: {};
+        required: never[];
+        additionalProperties: boolean;
+    };
+};
+
+declare class ToolSearchOutput {
+    readonly tools: unknown[];
+    constructor(tools: unknown[]);
+    logPreview(): string;
+    successForLogging(): boolean;
+    toResponseItem(callId: string): {
+        type: "tool_search_output";
+        call_id: string;
+        status: "completed";
+        execution: "client";
+        tools: unknown[];
+    };
+    postToolUseResponse(): unknown | null;
+    codeModeResult(): unknown;
+}
+declare class ToolSearchHandler implements ToolHandler<ToolSearchOutput> {
+    private readonly entries;
+    private readonly searchEngine;
+    constructor(entries: readonly ToolSearchEntry[]);
+    toolName(): ToolNameInput;
+    kind(): ToolKind;
+    matchesKind(payload: ToolPayload): boolean;
+    handle(invocation: ToolInvocation): Promise<ToolSearchOutput>;
+    private search;
+}
+
+declare function create_tool_search_tool(sources: readonly ToolSearchSourceInfo[], defaultLimit: number): {
+    type: "tool_search";
+    execution: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+};
+
+declare function unavailable_tool_message(toolName: string, nextStep: string): string;
+declare class UnavailableToolHandler implements ToolHandler<FunctionToolOutput> {
+    private readonly tool_name;
+    constructor(toolName: ToolNameInput);
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+
+declare const EXEC_COMMAND_TOOL_NAME = "exec_command";
+declare class ExecCommandHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    isMutating(): Promise<boolean>;
+    handle(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+type ExecCommandArgs = {
+    cmd?: string;
+    workdir?: string | null;
+};
+
+declare const WRITE_STDIN_TOOL_NAME = "write_stdin";
+declare class WriteStdinHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(invocation: ToolInvocation): Promise<FunctionToolOutput>;
+}
+
+declare class CodeModeExecuteHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(): Promise<FunctionToolOutput>;
+}
+
+declare const CODE_MODE_EXECUTE_TOOL_NAME = "code_mode_execute";
+declare function create_code_mode_execute_tool(): {
+    type: "function";
+    name: string;
+    description: string;
+    strict: boolean;
+    parameters: {
+        type: string;
+        properties: {};
+        required: never[];
+        additionalProperties: boolean;
+    };
+};
+
+declare function code_mode_response_item(item: ResponseInputItem): ResponseInputItem;
+
+declare class CodeModeWaitHandler implements ToolHandler<FunctionToolOutput> {
+    toolName(): ToolName;
+    kind(): ToolKind;
+    handle(): Promise<FunctionToolOutput>;
+}
+
+declare const CODE_MODE_WAIT_TOOL_NAME = "code_mode_wait";
+declare function create_code_mode_wait_tool(): {
+    type: "function";
+    name: string;
+    description: string;
+    strict: boolean;
+    parameters: {
+        type: string;
+        properties: {};
+        required: never[];
+        additionalProperties: boolean;
+    };
+};
+
+type ToolEventCtx = {
+    session: Session;
+    turn: TurnContext;
+    call_id: string;
+};
+type ToolEventFailure = {
+    type: "output";
+    output: ExecToolCallOutput;
+} | {
+    type: "message";
+    message: string;
+} | {
+    type: "rejected";
+    message: string;
+};
+type ToolEventStage = {
+    type: "begin";
+} | {
+    type: "success";
+    output: ExecToolCallOutput;
+} | {
+    type: "failure";
+    failure: ToolEventFailure;
+};
+type ToolEmitter = {
+    type: "unified_exec";
+    command: string[];
+    cwd: string;
+    process_id?: string | null;
+} | {
+    type: "apply_patch";
+    changes: Record<string, FileChange>;
+    auto_approved?: boolean;
+};
+declare const ToolEmitter: {
+    unified_exec(input: {
+        command: string[];
+        cwd: string;
+        process_id?: string | null;
+    }): ToolEmitter;
+    apply_patch(input: {
+        changes: Record<string, FileChange>;
+        auto_approved?: boolean;
+    }): ToolEmitter;
+};
+declare function emitToolEvent(emitter: ToolEmitter, ctx: ToolEventCtx, stage: ToolEventStage): Promise<void>;
+
+type WebSearchToolOptions = {
+    web_search_mode?: WebSearchMode | null;
+    web_search_config?: WebSearchConfig | null;
+    web_search_tool_type?: WebSearchToolType;
+};
+declare function create_image_generation_tool(outputFormat: string): ToolSpec;
+declare function create_web_search_tool(options: WebSearchToolOptions): ToolSpec | null;
+
+declare const ToolApprovalRequirement: {
+    readonly Skip: "skip";
+    readonly NeedsApproval: "needs_approval";
+    readonly Forbidden: "forbidden";
+};
+type ToolApprovalRequirement = {
+    type: typeof ToolApprovalRequirement.Skip;
+} | {
+    type: typeof ToolApprovalRequirement.NeedsApproval;
+    reason?: string | null;
+} | {
+    type: typeof ToolApprovalRequirement.Forbidden;
+    reason: string;
+};
+declare class PermissionGrantStore {
+    private readonly grants;
+    private strict_auto_review;
+    record(response: RequestPermissionsResponse): void;
+    all(): RequestPermissionProfile[];
+    hasGrants(): boolean;
+    strictAutoReviewEnabled(): boolean;
+    clear(): void;
+}
+declare class ToolOrchestrator {
+    static defaultApprovalRequirement(): ToolApprovalRequirement;
+}
+declare function normalizeRequestPermissionsResponseForCwd(response: RequestPermissionsResponse, cwd: string): RequestPermissionsResponse;
+
+declare function run_apply_patch_runtime(): Promise<FunctionToolOutput>;
+
+declare function run_shell_runtime(): Promise<FunctionToolOutput>;
+
+declare function run_unified_exec_runtime(): Promise<FunctionToolOutput>;
+
+declare const TOOL_RUNTIME_UNAVAILABLE = "tool execution is unavailable in this Codex assistant runtime; a desktop/local executor is required.";
+
+declare const ToolErrorKind: {
+    readonly Rejected: "rejected";
+    readonly Unavailable: "unavailable";
+    readonly Failed: "failed";
+};
+type ToolErrorKind = (typeof ToolErrorKind)[keyof typeof ToolErrorKind];
+declare class ToolError extends Error {
+    readonly kind: ToolErrorKind;
+    constructor(kind: ToolErrorKind, message: string);
+    static rejected(message: string): ToolError;
+    static unavailable(message: string): ToolError;
+    static failed(message: string): ToolError;
+}
+type SandboxAttempt = {
+    sandbox: "none" | "read-only" | "workspace-write";
+    permissions?: PermissionProfile | null;
+};
+type ToolCtx = {
+    session: Session;
+    turn: TurnContext;
+    call_id: string;
+    signal?: AbortSignal;
+};
+interface Sandboxable {
+    sandbox_preference(): "auto" | "none";
+    escalate_on_failure?(): boolean;
+}
+interface Approvable<TRequest> {
+    approval_keys(request: TRequest): unknown[];
+}
+interface ToolRuntime<TRequest, TOutput> {
+    run(request: TRequest, attempt: SandboxAttempt, ctx: ToolCtx): Promise<TOutput>;
+}
+
+declare function build_tool_registry_plan(config: ToolsConfig, params: ToolRegistryPlanParams): ToolRegistryPlan;
+
+declare class ToolRegistryBuilder {
+    private readonly handlers;
+    private readonly specs;
+    pushSpec(spec: ToolSpec): void;
+    pushSpecWithParallelSupport(spec: ToolSpec, supportsParallelToolCalls: boolean): void;
+    registerHandler(handler: ToolHandler): void;
+    build(): {
+        specs: ConfiguredToolSpec[];
+        registry: ToolRegistry;
+    };
+}
+
+type BuildSpecsWithDiscoverableToolsParams = ToolRegistryPlanParams & {
+    dynamic_tools: readonly DynamicToolSpec[];
+    mcp_tools?: readonly McpToolInfo[];
+};
+declare function build_specs_with_discoverable_tools(config: ToolsConfig, params: BuildSpecsWithDiscoverableToolsParams): ToolRegistryBuilder;
+
+export { APPLY_PATCH_TOOL_NAME, AbortedToolOutput, AgentMessageTurnItem, AgentRegistry, AgentStatus, AnyToolResult, type ApplyPatchArgs, ApplyPatchHandler, type Approvable, type AssistantTextChunk, AssistantTextStreamParser, BaseInstructions, type BuildSpecsWithDiscoverableToolsParams, CLOSE_AGENT_TOOL_NAME, CODE_MODE_EXECUTE_TOOL_NAME, CODE_MODE_WAIT_TOOL_NAME, CONNECTOR_AUTH_FAILURE_AUTH_REASON_KEY, CONNECTOR_AUTH_FAILURE_CONNECTOR_ID_KEY, CONNECTOR_AUTH_FAILURE_ERROR_ACTION_KEY, CONNECTOR_AUTH_FAILURE_ERROR_CODE_KEY, CONNECTOR_AUTH_FAILURE_ERROR_HTTP_STATUS_CODE_KEY, CONNECTOR_AUTH_FAILURE_IS_AUTH_FAILURE_KEY, CONNECTOR_AUTH_FAILURE_LINK_ID_KEY, CONNECTOR_AUTH_FAILURE_META_KEY, CORE_TEMPLATES, CREATE_GOAL_TOOL_NAME, type CallToolResult, CancellationToken, CloseAgentHandler, CodeModeExecuteHandler, CodeModeWaitHandler, type CodexAppsAuthElicitation, type CodexAppsAuthElicitationPlan, type CodexAppsConnectorAuthFailure, CollaborationMode, CollaborationModeInstructions, CompactTask, type CompactTaskParams, type CompactTaskResult, type CompactTaskRunner, ConfiguredHookHandler, ConfiguredToolSpec, ContentItem, ContextManager, ContextualUserFragment, type ContextualUserFragmentParams, type CoreTemplatePath, CreateGoalHandler, CreateGoalRequest, DEFAULT_WAIT_TIMEOUT_MS, DiscoverableTool, DynamicToolHandler, type DynamicToolHandlerParams, DynamicToolSpec, ENVIRONMENT_CONTEXT_CLOSE_TAG, ENVIRONMENT_CONTEXT_OPEN_TAG, EXEC_COMMAND_TOOL_NAME, EnvironmentContext, type EnvironmentContextEnvironment, type ExecCommandArgs, ExecCommandHandler, ExecToolCallOutput, FOLLOWUP_TASK_TOOL_NAME, FileChange, FollowupTaskHandler, FunctionCallError, FunctionCallErrorKind, FunctionCallOutputContentItem, FunctionToolOutput, GET_GOAL_TOOL_NAME, GetGoalHandler, GoalRuntimeApplyResult, GoalRuntimeEvent, GoalRuntimeState, GoalToolOutput, type HandleOutputCtx, HookEventName, HookHandlerResult, HookPromptTurnItem, HookToolEventName, type InFlightFuture, LIST_AGENTS_TOOL_NAME, LIST_MCP_RESOURCES_TOOL_NAME, LIST_MCP_RESOURCE_TEMPLATES_TOOL_NAME, ListAgentsHandler, ListMcpResourceTemplatesHandler, ListMcpResourcesHandler, MAX_WAIT_TIMEOUT_MS, MCP_TOOL_CODEX_APPS_META_KEY, MIN_WAIT_TIMEOUT_MS, McpToolHandler, McpToolInfo, McpToolOutput, ModeKind, ModelClient, ModelClientSessionHandle, ModelSwitchInstructions, type NetworkApprovalDecision, type NetworkContext, type OutputItemResult, PLAN_TOOL_NAME, PermissionGrantStore, PermissionProfile, PermissionsInstructions, PlanHandler, PlanModeStreamState, type PostToolUsePayload, type PreToolUsePayload, type PreviousTurnSettings, ProposedPlanParser, type ProposedPlanSegment, ProviderCapabilities, READ_MCP_RESOURCE_TOOL_NAME, REQUEST_PLUGIN_INSTALL_TOOL_NAME, RESUME_AGENT_TOOL_NAME, RateLimitSnapshot, ReadMcpResourceHandler, RegularTask, type RegularTaskParams, type RegularTaskRunner, RequestPermissionProfile, RequestPermissionsHandler, RequestPermissionsResponse, RequestPluginInstallHandler, RequestUserInputHandler, type RequestUserInputHandlerParams, ResponseInputItem, ResponseItem, ResumeAgentHandler, RolloutItem, type RolloutReconstruction, type RunTurnParams, SEND_INPUT_TOOL_NAME, SEND_MESSAGE_TOOL_NAME, SPAWN_AGENT_TOOL_NAME, SUMMARIZATION_PROMPT, SUMMARY_PREFIX, type SamplingRequestResult, type SandboxAttempt, type Sandboxable, type SearchToolCallParams, SendInputHandler, SendMessageHandler, Session, SessionConfiguration, SessionState, type SessionStateParams, SessionTask, SessionTaskResult, SessionTaskRunInput, SetGoalRequest, type ShellToolCallParams, SpawnAgentHandler, type StreamTextChunk, Submission, TEST_SYNC_TOOL_NAME, TOOL_RUNTIME_UNAVAILABLE, TURN_ABORTED_INTERRUPTED_GUIDANCE, TaskKind, ThreadGoal, ThreadGoalStore, ThreadId, TokenUsage, TokenUsageInfo, ToolApprovalRequirement, type ToolArgumentDiffConsumer, type ToolCall, ToolCallRuntime, type ToolCallRuntimeParams, type ToolCallSource, type ToolCtx, ToolDispatchTrace, ToolEmitter, ToolError, ToolErrorKind, type ToolEventCtx, type ToolEventFailure, type ToolEventStage, type ToolHandler, type ToolInvocation, ToolKind, ToolName, ToolNameInput, ToolOrchestrator, type ToolOutput, type ToolPayload, ToolRegistry, ToolRegistryBuilder, ToolRegistryPlan, ToolRegistryPlanParams, ToolRouter, type ToolRouterParams, type ToolRuntime, ToolSearchEntry, ToolSearchHandler, ToolSearchOutput, ToolSearchSourceInfo, ToolSpec, ToolsConfig, TotalTokenUsageBreakdown, TruncationPolicy, TurnContext, TurnContextItem, TurnItem, UPDATE_GOAL_TOOL_NAME, UnavailableToolHandler, type UniversalHookOutput, UpdateGoalHandler, UserInstructions, UserMessageTurnItem, WAIT_AGENT_TOOL_NAME, WRITE_STDIN_TOOL_NAME, WaitAgentHandler, type WaitAgentTimeoutOptions, WebSearchConfig, WebSearchMode, type WebSearchToolOptions, WebSearchToolType, WriteStdinHandler, agent_status_from_event, auth_elicitation_completed_result, auth_elicitation_id, auth_elicitation_message, budget_limit_prompt, budget_limit_steering_item, buildCollaborationModeInstructions, buildCompactedHistory, buildInitialContextItems, buildModelInstructionsUpdateItem, buildPromptBaseInstructions, buildPromptInputWithContext, buildSettingsUpdateItems, build_auth_elicitation, build_auth_elicitation_plan, build_specs_with_discoverable_tools, build_tool_registry_plan, code_mode_response_item, collectUserMessages, compactedThreadWarning, connector_auth_failure_from_tool_result, contentItemsToText, contextualFragmentMatchesText, create_apply_patch_tool, create_code_mode_execute_tool, create_code_mode_wait_tool, create_create_goal_tool, create_exec_command_tool, create_get_goal_tool, create_image_generation_tool, create_list_mcp_resource_templates_tool, create_list_mcp_resources_tool, create_plan_tool, create_read_mcp_resource_tool, create_request_plugin_install_tool, create_test_sync_tool, create_tool_search_tool, create_update_goal_tool, create_update_plan_tool, create_web_search_tool, create_write_stdin_tool, dynamicToolName, emitToolEvent, ensureCallOutputsPresent, extractProposedPlanText, goalToolOutput, handle_non_tool_response_item, handle_output_item_done, hasNonContextualDevMessageContent, isContextualDevMessageContent, isContextualUserMessageContent, isSummaryMessage, is_final, last_assistant_message_from_item, loadCoreTemplate, logPayload, looks_like_json, matcher_inputs, matchesToolKind, matches_matcher, mcpArgumentsFromPayload, network_approval_denied_error, normalizeRequestPermissionsResponseForCwd, normalizeResponseHistory, parseAgentMessage, parseApplyPatchChanges, parseTurnItem, parseUserMessage, parseVisibleHookPromptMessage, parse_hook_handler_json, reconstructHistoryFromRollout, record_completed_response_item, remainingTokenBudget, removeCorrespondingFor, removeOrphanOutputs, renderCoreTemplate, request_network_approval, resolve_agent_target, runTurn, run_apply_patch_runtime, run_compact_task, run_sampling_request, run_shell_runtime, run_unified_exec_runtime, select_handlers, select_handlers_for_matcher_inputs, stripImagesWhenUnsupported, stripProposedPlanBlocks, totalTokensFromTokenUsageInfo, turnAbortedResponseItem, unavailable_tool_message };