@jrkropp/codex-js 0.1.1 → 0.1.3

package/dist/server/index.js

@@ -1,3 +1,15 @@
-export { AppServerSession, CodexAppServerConnectionSessionState, CodexAppServerMessageProcessor, CodexAppServerRequestError, ConnectionRpcGate, ConnectionRpcGateClosedError, EmptyMcpConnectionManager, InMemoryThreadStore, LiveThread, LocalThreadStore, McpRequestProcessor, ModelClientSession, OutgoingMessageSender, RequestSerializationQueues, ResponsesClient, ResponsesWebsocketClient, ResponsesWebsocketConnection, StaticMcpConnectionManager, ThreadEventPersistenceMode, ThreadEventStore, ThreadHistoryBuilder, ThreadMemoryMode, ThreadRequestProcessor, ThreadScopedOutgoingMessageSender, TurnRequestProcessor, asThreadId, clientRequestExperimentalReason, clientRequestId, clientRequestMethod, clientRequestSerializationScope, createCodexAppServerRuntime, createModelClient, deniedRequestPermissionsResponse, jsonRpcInternalError, jsonRpcInvalidRequestError, jsonRpcParseError, parseClientTransportPayload, parseServerTransportPayload, queuedOutgoingMessage, serializeJsonRpcError, serializeJsonRpcResponse, serializeOutgoingMessage } from '../chunk-TZBLUZ2X.js';
+export { AppServerSession, CodexAppServerClientTransportError, PendingAppServerRequests, ThreadEventStore, createCodexAppServerClient, parseCodexAppServerEvent, requestMethodName, requestTyped, serverNotificationRequiresDelivery, serverNotificationThreadTarget, serverRequestThreadId, threadEventSnapshotHasStarted } from '../chunk-6ZMJ34KE.js';
+export { InMemoryThreadStore, LocalThreadStore } from '../chunk-4DPLJPB5.js';
+export { CodexAppServerConnectionSessionState, CodexAppServerMessageProcessor, CodexAppServerRequestError, ConnectionRpcGate, ConnectionRpcGateClosedError, McpRequestProcessor, OutgoingMessageSender, RequestSerializationQueues, ThreadRequestProcessor, ThreadScopedOutgoingMessageSender, TurnRequestProcessor, codexAppServerDeferredResponse, createCodexAppServerRuntime, jsonRpcInternalError, jsonRpcInvalidRequestError, jsonRpcParseError, outgoingMessageToAppServerEvent, parseClientTransportPayload, parseJsonRpcMessage, parseJsonRpcTransportPayload, parseServerTransportPayload, queuedOutgoingMessage, requestSerializationQueueKeyFromScope, serializeJsonRpcError, serializeJsonRpcResponse, serializeOutgoingMessage } from '../chunk-V4BMZWBM.js';
+export { CodexMcpConnectionManagerAdapter, EmptyMcpConnectionManager, ModelClientSession, ResponsesClient, ResponsesWebsocketClient, ResponsesWebsocketConnection, StaticMcpConnectionManager, asThreadId, createModelClient, deniedRequestPermissionsResponse } from '../chunk-LWQNX4LI.js';
+export { AuthMode, CODEX_CHATGPT_OAUTH_CALLBACK_PATH, CODEX_CHATGPT_OAUTH_CLIENT_ID, CODEX_CHATGPT_OAUTH_FALLBACK_PORT, CODEX_CHATGPT_OAUTH_ISSUER, CODEX_CHATGPT_OAUTH_ORIGINATOR, CODEX_CHATGPT_OAUTH_PRIMARY_PORT, CODEX_CHATGPT_OAUTH_SCOPE } from '../chunk-PST3ZWX2.js';
+import '../chunk-Z63UPBS3.js';
+import '../chunk-YHVCFD2D.js';
+import '../chunk-DCMKA2A6.js';
+export { LiveThread, SortDirection, ThreadEventPersistenceMode, ThreadMemoryMode, ThreadSortKey } from '../chunk-CGBS37IU.js';
+export { clientRequestExperimentalReason, clientRequestId, clientRequestMethod, clientRequestSerializationScope } from '../chunk-2DZRMCI2.js';
+export { ThreadHistoryBuilder, applyEventMsgToRenderedThread, createRenderedThreadState, renderThreadFromHistory, setRenderedThreadConnectionStatus } from '../chunk-DYLHN3HG.js';
+export { CODEX_PLAN_MODE_INSTRUCTIONS, ModeKind, TUI_VISIBLE_COLLABORATION_MODES, allowsRequestUserInput, applyCollaborationModeMask, builtinCollaborationModePresets, builtinCollaborationModePresets as codexBuiltinCollaborationModePresets, collaborationModeForModel, collaborationModePresetForMode, collaborationModeWithUpdates, defaultModeInstructions, normalizeCollaborationMode } from '../chunk-SYPHCDRD.js';
+export { BaseInstructions } from '../chunk-O44XP7LH.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/session-BRYzi8OT.d.ts

@@ -0,0 +1,46 @@
+import { C as ClientRequest, I as InitializeParams, k as ThreadStartParams, h as ThreadResumeParams, i as ThreadResumeResponse, e as ThreadListParams, a as CollaborationModeListParams, L as ListMcpServerStatusParams, M as McpResourceReadParams, c as McpServerToolCallParams, b as McpServerOauthLoginParams, g as ThreadReadParams, j as ThreadSetNameParams, T as ThreadArchiveParams, l as ThreadUnarchiveParams, f as ThreadMetadataUpdateParams, n as TurnStartParams, o as TurnSteerParams, m as TurnInterruptParams, d as ThreadCompactStartParams } from './ThreadResumeResponse-DvmE1juU.js';
+import { I as InitializeResponse, l as ThreadStartResponse, h as ThreadListResponse, b as CollaborationModeListResponse, e as McpServerRefreshResponse, L as ListMcpServerStatusResponse, c as McpResourceReadResponse, f as McpServerToolCallResponse, d as McpServerOauthLoginResponse, j as ThreadReadResponse, k as ThreadSetNameResponse, T as ThreadArchiveResponse, m as ThreadUnarchiveResponse, i as ThreadMetadataUpdateResponse, o as TurnStartResponse, p as TurnSteerResponse, n as TurnInterruptResponse, g as ThreadCompactStartResponse } from './TurnSteerResponse-0kBCfplh.js';
+import { R as RequestId } from './ToolRequestUserInputQuestion-CeZa5X1J.js';
+import { A as AppServerEvent, J as JSONRPCErrorError, R as Result } from './lib-nXlaKiS-.js';
+
+type CodexAppServer = {
+    close?(): void;
+    events?(): AsyncIterable<AppServerEvent>;
+    nextEvent?(): Promise<AppServerEvent | null>;
+    rejectServerRequest(requestId: RequestId, error: JSONRPCErrorError): Promise<void>;
+    request(request: ClientRequest): Promise<unknown>;
+    requestTyped<T>(request: ClientRequest): Promise<T>;
+    resolveServerRequest(requestId: RequestId, result: Result): Promise<void>;
+};
+declare class AppServerSession {
+    private readonly client;
+    private nextRequestIdValue;
+    constructor(client: CodexAppServer);
+    nextRequestId(): RequestId;
+    nextEvent(): Promise<AppServerEvent | null>;
+    events(): AsyncIterable<AppServerEvent> | null;
+    requestTyped<T>(request: ClientRequest): Promise<T>;
+    initialize(params?: InitializeParams): Promise<InitializeResponse>;
+    threadStart(params: ThreadStartParams): Promise<ThreadStartResponse>;
+    threadResume(params: ThreadResumeParams): Promise<ThreadResumeResponse>;
+    threadList(params?: ThreadListParams): Promise<ThreadListResponse>;
+    collaborationModeList(params?: CollaborationModeListParams): Promise<CollaborationModeListResponse>;
+    configMcpServerReload(): Promise<McpServerRefreshResponse>;
+    mcpServerStatusList(params?: ListMcpServerStatusParams): Promise<ListMcpServerStatusResponse>;
+    mcpResourceRead(params: McpResourceReadParams): Promise<McpResourceReadResponse>;
+    mcpServerToolCall(params: McpServerToolCallParams): Promise<McpServerToolCallResponse>;
+    mcpServerOauthLogin(params: McpServerOauthLoginParams): Promise<McpServerOauthLoginResponse>;
+    threadRead(params: ThreadReadParams): Promise<ThreadReadResponse>;
+    threadNameSet(params: ThreadSetNameParams): Promise<ThreadSetNameResponse>;
+    threadArchive(params: ThreadArchiveParams): Promise<ThreadArchiveResponse>;
+    threadUnarchive(params: ThreadUnarchiveParams): Promise<ThreadUnarchiveResponse>;
+    threadMetadataUpdate(params: ThreadMetadataUpdateParams): Promise<ThreadMetadataUpdateResponse>;
+    turnStart(params: TurnStartParams): Promise<TurnStartResponse>;
+    turnSteer(params: TurnSteerParams): Promise<TurnSteerResponse>;
+    turnInterrupt(params: TurnInterruptParams): Promise<TurnInterruptResponse>;
+    threadCompactStart(params: ThreadCompactStartParams): Promise<ThreadCompactStartResponse>;
+    resolveServerRequest(requestId: RequestId, result: Result): Promise<void>;
+    rejectServerRequest(requestId: RequestId, error: JSONRPCErrorError): Promise<void>;
+}
+
+export { AppServerSession as A, type CodexAppServer as C };

package/dist/shadcn/index.d.ts

@@ -1,4 +1,4 @@
-export { B as Button, I as Input, S as Separator, a as Sidebar, b as SidebarContent, c as SidebarFooter, d as SidebarGroup, e as SidebarGroupAction, f as SidebarGroupContent, g as SidebarGroupLabel, h as SidebarHeader, i as SidebarInput, j as SidebarInset, k as SidebarMenu, l as SidebarMenuAction, m as SidebarMenuBadge, n as SidebarMenuButton, o as SidebarMenuItem, p as SidebarMenuSkeleton, q as SidebarMenuSub, r as SidebarMenuSubButton, s as SidebarMenuSubItem, t as SidebarProvider, u as SidebarRail, v as SidebarSeparator, w as SidebarTrigger, T as Tooltip, x as TooltipContent, y as TooltipProvider, z as TooltipTrigger, A as buttonVariants, C as useSidebar } from '../sidebar-DT2XoitN.js';
+export { B as Button, I as Input, b as Separator, S as Sidebar, c as SidebarContent, d as SidebarFooter, e as SidebarGroup, f as SidebarGroupAction, g as SidebarGroupContent, h as SidebarGroupLabel, i as SidebarHeader, j as SidebarInput, k as SidebarInset, l as SidebarMenu, m as SidebarMenuAction, n as SidebarMenuBadge, o as SidebarMenuButton, p as SidebarMenuItem, q as SidebarMenuSkeleton, r as SidebarMenuSub, s as SidebarMenuSubButton, t as SidebarMenuSubItem, a as SidebarProvider, u as SidebarRail, v as SidebarSeparator, w as SidebarTrigger, T as Tooltip, x as TooltipContent, y as TooltipProvider, z as TooltipTrigger, A as buttonVariants, C as useSidebar } from '../sidebar-DMMij22z.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { Collapsible as Collapsible$1, Dialog as Dialog$1, ScrollArea as ScrollArea$1 } from 'radix-ui';
 import * as React$1 from 'react';

package/dist/{sidebar-DT2XoitN.d.ts → sidebar-DMMij22z.d.ts}

@@ -84,4 +84,4 @@ declare function SidebarMenuSubButton({ asChild, size, isActive, className, ...p
     isActive?: boolean;
 }): react_jsx_runtime.JSX.Element;
 
-export { buttonVariants as A, Button as B, useSidebar as C, Input as I, Separator as S, Tooltip as T, Sidebar as a, SidebarContent as b, SidebarFooter as c, SidebarGroup as d, SidebarGroupAction as e, SidebarGroupContent as f, SidebarGroupLabel as g, SidebarHeader as h, SidebarInput as i, SidebarInset as j, SidebarMenu as k, SidebarMenuAction as l, SidebarMenuBadge as m, SidebarMenuButton as n, SidebarMenuItem as o, SidebarMenuSkeleton as p, SidebarMenuSub as q, SidebarMenuSubButton as r, SidebarMenuSubItem as s, SidebarProvider as t, SidebarRail as u, SidebarSeparator as v, SidebarTrigger as w, TooltipContent as x, TooltipProvider as y, TooltipTrigger as z };
+export { buttonVariants as A, Button as B, useSidebar as C, Input as I, Sidebar as S, Tooltip as T, SidebarProvider as a, Separator as b, SidebarContent as c, SidebarFooter as d, SidebarGroup as e, SidebarGroupAction as f, SidebarGroupContent as g, SidebarGroupLabel as h, SidebarHeader as i, SidebarInput as j, SidebarInset as k, SidebarMenu as l, SidebarMenuAction as m, SidebarMenuBadge as n, SidebarMenuButton as o, SidebarMenuItem as p, SidebarMenuSkeleton as q, SidebarMenuSub as r, SidebarMenuSubButton as s, SidebarMenuSubItem as t, SidebarRail as u, SidebarSeparator as v, SidebarTrigger as w, TooltipContent as x, TooltipProvider as y, TooltipTrigger as z };

package/dist/spec_plan_types-CmsJ-Tfn.d.ts

@@ -0,0 +1,260 @@
+import { N as ServiceTier, Q as ReasoningEffortConfig, V as ReasoningSummaryConfig, W as Personality, X as AskForApproval, Y as ApprovalsReviewer, S as SandboxPolicy, P as PermissionProfile, L as ActivePermissionProfile, Z as WindowsSandboxLevel, B as BaseInstructions, C as CollaborationMode, J as SessionSource, _ as TurnEnvironmentSelection, D as DynamicToolSpec, y as TruncationPolicy, $ as LoadableToolSpec, h as McpToolInfo, i as ModeKind, a0 as ConfiguredToolSpec } from './protocol-mpBcYHrm.js';
+import { W as WebSearchMode$1, a as WebSearchToolConfig } from './WebSearchToolConfig-D3ep0625.js';
+
+declare const CONFIG_TOML_FILE = "config.toml";
+type ConfigLayerSource = {
+    type: "Mdm";
+    domain: string;
+    key: string;
+} | {
+    type: "System";
+    file: string;
+} | {
+    type: "User";
+    file: string;
+} | {
+    type: "Project";
+    dot_codex_folder: string;
+} | {
+    type: "SessionFlags";
+} | {
+    type: "LegacyManagedConfigTomlFromFile";
+    file: string;
+} | {
+    type: "LegacyManagedConfigTomlFromMdm";
+};
+type ConfigLayerMetadata = {
+    name: ConfigLayerSource;
+    version: string;
+};
+type ConfigLayerEntry = {
+    name: ConfigLayerSource;
+    config: ConfigToml;
+    raw_toml?: string | null;
+    version: string;
+    disabled_reason?: string | null;
+};
+type ConfigLayerStack = {
+    layers: ConfigLayerEntry[];
+    startup_warnings: string[];
+};
+declare const ConfigLayerStackOrdering: {
+    readonly LowestPrecedenceFirst: "LowestPrecedenceFirst";
+    readonly HighestPrecedenceFirst: "HighestPrecedenceFirst";
+};
+type ConfigLayerStackOrdering = (typeof ConfigLayerStackOrdering)[keyof typeof ConfigLayerStackOrdering];
+type ConfigOverrides = ConfigToml;
+type ConfigToml = {
+    model?: string;
+    review_model?: string;
+    model_provider?: string;
+    service_tier?: ServiceTier | null;
+    model_reasoning_effort?: ReasoningEffortConfig | null;
+    plan_mode_reasoning_effort?: ReasoningEffortConfig | null;
+    model_reasoning_summary?: ReasoningSummaryConfig;
+    personality?: Personality | null;
+    approval_policy?: AskForApproval;
+    approvals_reviewer?: ApprovalsReviewer | null;
+    sandbox_policy?: SandboxPolicy | null;
+    sandbox_mode?: SandboxPolicy["mode"] | null;
+    default_permissions?: string | null;
+    permission_profile?: PermissionProfile | null;
+    active_permission_profile?: ActivePermissionProfile | null;
+    windows_sandbox_level?: WindowsSandboxLevel | null;
+    cwd?: string;
+    instructions?: string | null;
+    model_instructions_file?: string | null;
+    model_instructions_file_contents?: string | null;
+    base_instructions?: BaseInstructions | string | null;
+    developer_instructions?: string | null;
+    user_instructions?: string | null;
+    collaboration_mode?: CollaborationMode | null;
+    session_source?: SessionSource;
+    environments?: TurnEnvironmentSelection[];
+    dynamic_tools?: DynamicToolSpec[];
+    final_output_json_schema?: unknown;
+    truncation_policy?: TruncationPolicy | null;
+    web_search?: WebSearchMode$1 | null;
+    tools?: ToolsToml | null;
+    features?: FeaturesToml | null;
+    profiles?: Record<string, ConfigProfile>;
+    profile?: string | null;
+    compact_prompt?: string | null;
+    include_permissions_instructions?: boolean;
+    include_environment_context?: boolean;
+    include_apps_instructions?: boolean;
+    include_skill_instructions?: boolean;
+};
+type ConfigProfile = Omit<ConfigToml, "profiles" | "profile">;
+type ToolsToml = Omit<DefaultToolsConfigInput, "web_search"> & {
+    web_search?: Partial<WebSearchToolConfig> | boolean | null;
+};
+type FeaturesToml = Record<string, unknown>;
+type ResolvedConfig = Required<Pick<ConfigToml, "model" | "model_provider" | "approval_policy" | "cwd" | "session_source">> & Omit<ConfigToml, "model" | "model_provider" | "approval_policy" | "cwd" | "session_source"> & {
+    base_instructions: BaseInstructions;
+    base_instructions_source: "config" | "model_instructions_file" | "default";
+    service_tier: ServiceTier | null;
+    reasoning_effort: ReasoningEffortConfig | null;
+    reasoning_summary: ReasoningSummaryConfig;
+    developer_instructions: string | null;
+    user_instructions: string | null;
+    personality: Personality | null;
+    sandbox_policy: SandboxPolicy;
+    permission_profile: PermissionProfile;
+    active_permission_profile: ActivePermissionProfile | null;
+    windows_sandbox_level: WindowsSandboxLevel | null;
+    collaboration_mode: CollaborationMode;
+    environments: TurnEnvironmentSelection[];
+    dynamic_tools: DynamicToolSpec[];
+    final_output_json_schema?: unknown;
+    truncation_policy: TruncationPolicy | null;
+    web_search_mode: WebSearchMode$1;
+    tools: ToolsConfig;
+    startup_warnings: string[];
+};
+declare function createConfigLayerStack(layers?: ConfigLayerEntry[], startup_warnings?: string[]): ConfigLayerStack;
+type LoaderOverrides = {
+    ignore_user_config?: boolean;
+    ignore_managed_requirements?: boolean;
+    ignore_user_and_project_exec_policy_rules?: boolean;
+};
+
+type ToolNameInput = ToolName | string | {
+    namespace?: string | null;
+    name: string;
+};
+declare class ToolName {
+    readonly namespace: string | null;
+    readonly name: string;
+    private constructor();
+    static plain(name: string): ToolName;
+    static namespaced(namespace: string, name: string): ToolName;
+    static new(namespace: string | null | undefined, name: string): ToolName;
+    static from(input: ToolNameInput): ToolName;
+    display(): string;
+    key(): string;
+    equals(other: ToolNameInput): boolean;
+    toJSON(): string;
+}
+
+declare const TOOL_SEARCH_TOOL_NAME = "tool_search";
+declare const TOOL_SEARCH_DEFAULT_LIMIT = 8;
+type ToolSearchSourceInfo = {
+    name: string;
+    description?: string | null;
+};
+type DiscoverableTool = {
+    name: string;
+    title?: string | null;
+    description: string;
+    source: string;
+    input_schema?: unknown;
+    server_name?: string | null;
+    tool_name?: string | null;
+    mcp_app_resource_uri?: string | null;
+};
+type ToolSearchEntry = {
+    limit_bucket?: string | null;
+    output: LoadableToolSpec;
+    search_text: string;
+};
+declare function build_tool_search_entries(input: {
+    dynamic_tools: readonly DynamicToolSpec[];
+    mcp_tools?: readonly McpToolInfo[];
+}): ToolSearchEntry[];
+declare function build_tool_search_entries_for_config(config: ToolsConfig, mcp_tools: readonly McpToolInfo[] | null | undefined, dynamic_tools: readonly DynamicToolSpec[]): ToolSearchEntry[];
+declare function dynamic_tool_to_tool_search_entry(tool: DynamicToolSpec): ToolSearchEntry;
+declare function mcp_tool_to_tool_search_entry(tool: McpToolInfo): ToolSearchEntry;
+declare function tool_search_source_info_for_dynamic_tools(tools: readonly DynamicToolSpec[]): ToolSearchSourceInfo[];
+declare function tool_search_source_info_for_mcp_tools(tools: readonly McpToolInfo[]): ToolSearchSourceInfo[];
+declare function tool_search_outputs(entries: readonly ToolSearchEntry[]): LoadableToolSpec[];
+
+declare const ToolHandlerKind: {
+    readonly DynamicTool: "DynamicTool";
+    readonly RequestPermissions: "RequestPermissions";
+    readonly RequestUserInput: "RequestUserInput";
+    readonly ToolSearch: "ToolSearch";
+    readonly UnavailableTool: "UnavailableTool";
+    readonly Mcp: "Mcp";
+    readonly ListMcpResources: "ListMcpResources";
+    readonly ListMcpResourceTemplates: "ListMcpResourceTemplates";
+    readonly ReadMcpResource: "ReadMcpResource";
+    readonly ExecCommand: "ExecCommand";
+    readonly WriteStdin: "WriteStdin";
+    readonly ApplyPatch: "ApplyPatch";
+    readonly Plan: "Plan";
+    readonly GetGoal: "GetGoal";
+    readonly CreateGoal: "CreateGoal";
+    readonly UpdateGoal: "UpdateGoal";
+    readonly SpawnAgent: "SpawnAgent";
+    readonly SendInput: "SendInput";
+    readonly WaitAgent: "WaitAgent";
+    readonly CloseAgent: "CloseAgent";
+    readonly ResumeAgent: "ResumeAgent";
+    readonly ListAgents: "ListAgents";
+    readonly SendMessage: "SendMessage";
+    readonly FollowupTask: "FollowupTask";
+};
+type ToolHandlerKind = (typeof ToolHandlerKind)[keyof typeof ToolHandlerKind];
+type ToolHandlerSpec = {
+    name: ToolName;
+    kind: ToolHandlerKind;
+};
+type ToolRegistryPlan = {
+    specs: ConfiguredToolSpec[];
+    handlers: ToolHandlerSpec[];
+};
+type ToolRegistryPlanParams = {
+    dynamic_tools: readonly DynamicToolSpec[];
+    mcp_tools?: readonly McpToolInfo[];
+    deferred_mcp_tools?: readonly McpToolInfo[];
+    discoverable_tools?: readonly DiscoverableTool[];
+    tool_namespaces?: readonly string[];
+    unavailable_called_tools?: readonly ToolName[];
+    parallel_mcp_tool_names?: readonly ToolName[];
+};
+type WebSearchMode = "disabled" | "cached" | "live";
+type WebSearchToolType = "text" | "text_and_image";
+type WebSearchConfig = {
+    filters?: unknown;
+    user_location?: unknown;
+    search_context_size?: unknown;
+};
+type ToolsConfig = {
+    namespace_tools: boolean;
+    request_permissions_tool_enabled: boolean;
+    request_user_input_available_modes: readonly ModeKind[];
+    search_tool: boolean;
+    web_search_mode: WebSearchMode | null;
+    web_search_tool_type: WebSearchToolType;
+    web_search_config?: WebSearchConfig | null;
+    image_gen_tool: boolean;
+    exec_command_tool_enabled: boolean;
+    write_stdin_tool_enabled: boolean;
+    apply_patch_tool_enabled: boolean;
+    thread_goal_tools_enabled: boolean;
+    mcp_tools_enabled: boolean;
+    multi_agent_tools_enabled: boolean;
+};
+type DefaultToolsConfigInput = {
+    namespace_tools?: boolean;
+    image_generation?: boolean;
+    web_search?: boolean;
+    request_permissions_tool_enabled?: boolean;
+    request_user_input_available_modes?: readonly ModeKind[];
+    search_tool?: boolean;
+    web_search_mode?: WebSearchMode | null;
+    web_search_tool_type?: WebSearchToolType;
+    web_search_config?: WebSearchConfig | null;
+    image_gen_tool?: boolean;
+    exec_command_tool_enabled?: boolean;
+    write_stdin_tool_enabled?: boolean;
+    apply_patch_tool_enabled?: boolean;
+    thread_goal_tools_enabled?: boolean;
+    mcp_tools_enabled?: boolean;
+    multi_agent_tools_enabled?: boolean;
+};
+declare function createToolRegistryPlan(): ToolRegistryPlan;
+declare function defaultToolsConfig(input?: DefaultToolsConfigInput): ToolsConfig;
+
+export { defaultToolsConfig as A, dynamic_tool_to_tool_search_entry as B, type ConfigLayerEntry as C, type DefaultToolsConfigInput as D, mcp_tool_to_tool_search_entry as E, type FeaturesToml as F, tool_search_outputs as G, tool_search_source_info_for_dynamic_tools as H, tool_search_source_info_for_mcp_tools as I, type LoaderOverrides as L, type ResolvedConfig as R, type ToolsToml as T, type WebSearchConfig as W, type ConfigLayerSource as a, type ConfigToml as b, type ConfigLayerStack as c, ConfigLayerStackOrdering as d, type ConfigOverrides as e, type WebSearchMode as f, CONFIG_TOML_FILE as g, type ConfigLayerMetadata as h, type ConfigProfile as i, createConfigLayerStack as j, type ToolsConfig as k, type ToolNameInput as l, ToolName as m, type DiscoverableTool as n, type ToolSearchEntry as o, type ToolSearchSourceInfo as p, type WebSearchToolType as q, type ToolRegistryPlanParams as r, type ToolRegistryPlan as s, TOOL_SEARCH_DEFAULT_LIMIT as t, TOOL_SEARCH_TOOL_NAME as u, ToolHandlerKind as v, type ToolHandlerSpec as w, build_tool_search_entries as x, build_tool_search_entries_for_config as y, createToolRegistryPlan as z };

package/dist/{store-H2cQxdpe.d.ts → store-AGRxhgQ3.d.ts}

@@ -1,4 +1,5 @@
-import { C as CreateThreadParams, R as ResumeThreadParams, A as AppendThreadItemsParams, T as ThreadId, L as LoadThreadHistoryParams, b as StoredThreadHistory, c as ReadThreadParams, d as StoredThread, e as ReadThreadByRolloutPathParams, f as ListThreadsParams, g as ThreadPage, U as UpdateThreadMetadataParams, h as ArchiveThreadParams } from './thread_event_store-BIS0qzhi.js';
+import { l as ThreadId } from './protocol-mpBcYHrm.js';
+import { C as CreateThreadParams, d as ResumeThreadParams, A as AppendThreadItemsParams, b as LoadThreadHistoryParams, f as StoredThreadHistory, c as ReadThreadParams, e as StoredThread, R as ReadThreadByRolloutPathParams, L as ListThreadsParams, h as ThreadPage, U as UpdateThreadMetadataParams, a as ArchiveThreadParams } from './types-BTeabLYr.js';
 
 interface ThreadStore {
     createThread(params: CreateThreadParams): Promise<void>;