@jrkropp/codex-js 0.1.4 → 0.2.0

package/dist/internal/codex/core/src/context_manager/history.d.ts

@@ -0,0 +1,60 @@
+import type { ResponseItem } from "../models.js";
+import type { BaseInstructions, FunctionCallOutputPayload, TokenUsage, TokenUsageInfo, TruncationPolicy, TurnContextItem } from "../protocol.js";
+export type TotalTokenUsageBreakdown = {
+    last_api_response_total_tokens: number;
+    all_history_items_model_visible_bytes: number;
+    estimated_tokens_of_items_added_since_last_successful_api_response: number;
+    estimated_bytes_of_items_added_since_last_successful_api_response: number;
+};
+export declare class ContextManager {
+    private items;
+    private history_version;
+    private token_info_value;
+    private reference_context_item_value;
+    static new(): ContextManager;
+    clone(): ContextManager;
+    token_info(): TokenUsageInfo | null;
+    tokenInfo(): TokenUsageInfo | null;
+    set_token_info(info: TokenUsageInfo | null): void;
+    setTokenInfo(info: TokenUsageInfo | null): void;
+    set_token_usage_full(contextWindow: number): void;
+    setTokenUsageFull(contextWindow: number): void;
+    recordItems(items: Iterable<ResponseItem>, policy?: TruncationPolicy | null): void;
+    record_items(items: Iterable<ResponseItem>, policy?: TruncationPolicy | null): void;
+    replace(items: ResponseItem[]): void;
+    rawItems(): ResponseItem[];
+    raw_items(): ResponseItem[];
+    forPrompt(inputModalities?: readonly string[] | null): ResponseItem[];
+    for_prompt(inputModalities?: readonly string[] | null): ResponseItem[];
+    historyVersion(): number;
+    history_version_value(): number;
+    estimate_token_count_with_base_instructions(baseInstructions: BaseInstructions): number;
+    setReferenceContextItem(item: TurnContextItem | null): void;
+    set_reference_context_item(item: TurnContextItem | null): void;
+    referenceContextItem(): TurnContextItem | null;
+    reference_context_item(): TurnContextItem | null;
+    dropLastNUserTurns(numTurns: number): void;
+    drop_last_n_user_turns(numTurns: number): void;
+    removeFirstItem(): void;
+    remove_first_item(): void;
+    removeLastItem(): boolean;
+    remove_last_item(): boolean;
+    replaceLastTurnImages(placeholder: string): boolean;
+    replace_last_turn_images(placeholder: string): boolean;
+    updateTokenInfo(usage: TokenUsage, modelContextWindow?: number | null): void;
+    update_token_info(usage: TokenUsage, modelContextWindow?: number | null): void;
+    getTotalTokenUsage(serverReasoningIncluded?: boolean): number;
+    get_total_token_usage(serverReasoningIncluded?: boolean): number;
+    getTotalTokenUsageBreakdown(): TotalTokenUsageBreakdown;
+    get_total_token_usage_breakdown(): TotalTokenUsageBreakdown;
+    private getNonLastReasoningItemsTokens;
+    private itemsAfterLastModelGeneratedItem;
+    private trim_pre_turn_context_updates;
+}
+export declare function processResponseItemForPrompt(item: ResponseItem, policy?: TruncationPolicy | null): ResponseItem;
+export declare function truncate_function_output_payload(output: FunctionCallOutputPayload, policy?: TruncationPolicy | null): FunctionCallOutputPayload;
+export declare function isApiMessage(item: ResponseItem): boolean;
+export declare function isUserTurnBoundary(item: ResponseItem): boolean;
+export declare function dropLastNUserTurns(items: ResponseItem[], numTurns: number): ResponseItem[];
+export declare function estimate_item_token_count(item: ResponseItem): number;
+export declare function estimate_response_item_model_visible_bytes(item: ResponseItem): number;

package/dist/internal/codex/core/src/context_manager/normalize.d.ts

@@ -0,0 +1,6 @@
+import type { ResponseItem } from "../models.js";
+export declare function ensureCallOutputsPresent(items: ResponseItem[]): ResponseItem[];
+export declare function removeOrphanOutputs(items: ResponseItem[]): ResponseItem[];
+export declare function removeCorrespondingFor(items: ResponseItem[], item: ResponseItem): ResponseItem[];
+export declare function normalizeResponseHistory(items: ResponseItem[]): ResponseItem[];
+export declare function stripImagesWhenUnsupported(inputModalities: readonly string[] | null | undefined, items: ResponseItem[]): ResponseItem[];

package/dist/internal/codex/core/src/event-mapping.d.ts

@@ -0,0 +1,9 @@
+import type { ContentItem, ResponseItem } from "./models.js";
+import type { AgentMessageTurnItem, HookPromptTurnItem, TurnItem, UserMessageTurnItem } from "./items.js";
+export declare function isContextualUserMessageContent(message: readonly ContentItem[]): boolean;
+export declare function isContextualDevMessageContent(message: readonly ContentItem[]): boolean;
+export declare function hasNonContextualDevMessageContent(message: readonly ContentItem[]): boolean;
+export declare function parseUserMessage(id: string | null | undefined, message: readonly ContentItem[]): UserMessageTurnItem | null;
+export declare function parseAgentMessage(id: string | null | undefined, message: readonly ContentItem[], phase?: string | null): AgentMessageTurnItem;
+export declare function parseVisibleHookPromptMessage(id: string | null | undefined, message: readonly ContentItem[]): HookPromptTurnItem | null;
+export declare function parseTurnItem(item: ResponseItem): TurnItem | null;

package/dist/internal/codex/core/src/exec-output.d.ts

@@ -0,0 +1,20 @@
+export type StreamOutput<T = string> = {
+    text: T;
+    truncated_after_lines?: number | null;
+};
+export type ExecToolCallOutput = {
+    exit_code: number;
+    stdout: StreamOutput<string>;
+    stderr: StreamOutput<string>;
+    aggregated_output: StreamOutput<string>;
+    duration_ms: number;
+    timed_out: boolean;
+};
+export declare function streamOutput(text: string): StreamOutput<string>;
+export declare function execToolCallOutput(input: {
+    exit_code: number;
+    stdout?: string;
+    stderr?: string;
+    duration_ms?: number;
+    timed_out?: boolean;
+}): ExecToolCallOutput;

package/dist/internal/codex/core/src/goals/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./runtime.js";
+export * from "./types.js";

package/dist/internal/codex/core/src/goals/runtime.d.ts

@@ -0,0 +1,32 @@
+import { type ResponseItem, type ThreadGoal, type TokenUsageInfo } from "../protocol.js";
+import type { ThreadId } from "../ids.js";
+import { type CreateGoalRequest, type GoalRuntimeApplyResult, type GoalRuntimeEvent, type GoalToolOutput, type SetGoalRequest, type ThreadGoalStore } from "./types.js";
+export 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;
+}
+export declare function totalTokensFromTokenUsageInfo(info: TokenUsageInfo | null): number;
+export declare function goalToolOutput(goal: ThreadGoal | null): GoalToolOutput;
+export declare function remainingTokenBudget(goal: ThreadGoal | null): number | null;
+export declare function budget_limit_prompt(goal: ThreadGoal): string;
+export declare function budget_limit_steering_item(goal: ThreadGoal): ResponseItem;

package/dist/internal/codex/core/src/goals/types.d.ts

@@ -0,0 +1,95 @@
+import type { ThreadId } from "../ids.js";
+import type { ResponseItem, ThreadGoal, ThreadGoalStatus } from "../protocol.js";
+export type ThreadGoalUpdate = {
+    status?: ThreadGoalStatus;
+    token_budget?: number | null;
+    expected_goal_id?: string | null;
+};
+export declare const ThreadGoalAccountingMode: {
+    readonly ActiveStatusOnly: "active_status_only";
+    readonly ActiveOnly: "active_only";
+    readonly ActiveOrComplete: "active_or_complete";
+    readonly ActiveOrStopped: "active_or_stopped";
+};
+export type ThreadGoalAccountingMode = (typeof ThreadGoalAccountingMode)[keyof typeof ThreadGoalAccountingMode];
+export type ThreadGoalAccountingOutcome = {
+    type: "updated";
+    goal: ThreadGoal;
+} | {
+    type: "unchanged";
+    goal: ThreadGoal | null;
+};
+export type ThreadGoalStore = {
+    getThreadGoal(threadId: ThreadId): Promise<ThreadGoal | null>;
+    replaceThreadGoal(params: {
+        thread_id: ThreadId;
+        objective: string;
+        status: ThreadGoalStatus;
+        token_budget?: number | null;
+    }): Promise<ThreadGoal>;
+    insertThreadGoal(params: {
+        thread_id: ThreadId;
+        objective: string;
+        status: ThreadGoalStatus;
+        token_budget?: number | null;
+    }): Promise<ThreadGoal>;
+    updateThreadGoal(params: {
+        thread_id: ThreadId;
+        update: ThreadGoalUpdate;
+    }): Promise<ThreadGoal>;
+    pauseActiveThreadGoal(threadId: ThreadId): Promise<ThreadGoal | null>;
+    deleteThreadGoal(threadId: ThreadId): Promise<void>;
+    accountThreadGoalUsage(params: {
+        thread_id: ThreadId;
+        tokens_used_delta?: number;
+        time_used_seconds_delta?: number;
+        mode?: ThreadGoalAccountingMode;
+    }): Promise<ThreadGoalAccountingOutcome>;
+};
+export type GoalRuntimeEvent = {
+    type: "turn_started";
+    turn_id: string;
+    total_tokens: number;
+} | {
+    type: "tool_completed";
+    turn_id: string;
+    tool_name: string;
+    total_tokens: number;
+} | {
+    type: "tool_completed_goal";
+    turn_id: string;
+    total_tokens: number;
+} | {
+    type: "turn_finished";
+    turn_id: string;
+    total_tokens: number;
+} | {
+    type: "task_aborted";
+    turn_id: string;
+    total_tokens: number;
+} | {
+    type: "thread_resumed";
+};
+export type GoalRuntimeApplyResult = {
+    goal_updated?: ThreadGoal | null;
+};
+export type GoalTurnAccountingSnapshot = {
+    total_tokens: number;
+    started_at_ms: number;
+    last_accounted_total_tokens: number;
+    last_accounted_at_ms: number;
+};
+export type CreateGoalRequest = {
+    objective: string;
+    token_budget?: number | null;
+};
+export type SetGoalRequest = {
+    objective?: string | null;
+    status?: ThreadGoalStatus | null;
+    token_budget?: number | null;
+};
+export type GoalToolOutput = {
+    goal: ThreadGoal | null;
+    remaining_token_budget: number | null;
+};
+export type GoalSteeringItem = ResponseItem;

package/dist/internal/codex/core/src/goals.d.ts

@@ -0,0 +1 @@
+export * from "./goals/index.js";

package/dist/internal/codex/core/src/hooks/dispatcher.d.ts

@@ -0,0 +1,5 @@
+import { HookEventName, type ConfiguredHookHandler } from "./types.js";
+export declare function select_handlers(handlers: readonly ConfiguredHookHandler[], eventName: HookEventName, matcherInput?: string | null): ConfiguredHookHandler[];
+export declare function select_handlers_for_matcher_inputs(handlers: readonly ConfiguredHookHandler[], eventName: HookEventName, matcherInputs: readonly string[]): ConfiguredHookHandler[];
+export declare function matches_matcher(matcher: string | null | undefined, input: string | null): boolean;
+export declare function matcher_inputs(toolName: string, matcherAliases?: readonly string[]): string[];

package/dist/internal/codex/core/src/hooks/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./dispatcher.js";
+export * from "./output-parser.js";
+export * from "./runtime.js";
+export * from "./types.js";

package/dist/internal/codex/core/src/hooks/output-parser.d.ts

@@ -0,0 +1,9 @@
+import { type HookHandlerResult } from "./types.js";
+export type UniversalHookOutput = {
+    continue_processing?: boolean;
+    stop_reason?: string | null;
+    suppress_output?: boolean;
+    system_message?: string | null;
+};
+export declare function looks_like_json(text: string): boolean;
+export declare function parse_hook_handler_json(stdout: string): HookHandlerResult | null;

package/dist/internal/codex/core/src/hooks/runtime.d.ts

@@ -0,0 +1,125 @@
+import type { ResponseItem } from "../models.js";
+import { type HookCompletedEvent, type HookRunSummary } from "../protocol.js";
+import { type RequestPermissionsResponse } from "../request_permissions.js";
+import type { Session } from "../session/session.js";
+import type { TurnContext } from "../session/turn-context.js";
+import { type ConfiguredHookHandler, type PermissionRequestDecision } from "./types.js";
+export type HookRuntimeOutcome = {
+    should_stop: boolean;
+    stop_reason?: string | null;
+    additional_contexts: string[];
+};
+export type SessionStartRequest = {
+    session_id: string;
+    turn_id: string;
+    cwd: string;
+    transcript_path?: string | null;
+    model: string;
+    permission_mode: string;
+    source: string;
+};
+export type UserPromptSubmitRequest = {
+    session_id: string;
+    turn_id: string;
+    cwd: string;
+    transcript_path?: string | null;
+    model: string;
+    permission_mode: string;
+    prompt: string;
+};
+export type PreToolUseRequest = {
+    session_id: string;
+    turn_id: string;
+    cwd: string;
+    transcript_path?: string | null;
+    model: string;
+    permission_mode: string;
+    tool_name: string;
+    matcher_aliases: string[];
+    tool_use_id: string;
+    tool_input: unknown;
+};
+export type PostToolUseRequest = PreToolUseRequest & {
+    tool_response: unknown;
+};
+export type PermissionRequestRequest = PreToolUseRequest & {
+    run_id_suffix: string;
+};
+export type CompactHookRequest = {
+    session_id: string;
+    turn_id: string;
+    cwd: string;
+    transcript_path?: string | null;
+    model: string;
+    trigger: "manual" | "auto";
+};
+export type PreToolUseOutcome = {
+    hook_events: HookCompletedEvent[];
+    should_block: boolean;
+    block_reason?: string | null;
+    additional_contexts: string[];
+};
+export type PostToolUseOutcome = {
+    hook_events: HookCompletedEvent[];
+    should_stop: boolean;
+    stop_reason?: string | null;
+    feedback_message?: string | null;
+    additional_contexts: string[];
+};
+export type PermissionRequestOutcome = {
+    hook_events: HookCompletedEvent[];
+    decision?: PermissionRequestDecision | null;
+};
+export declare class Hooks {
+    private readonly handlers;
+    constructor(handlers?: readonly ConfiguredHookHandler[]);
+    static empty(): Hooks;
+    static withHandlersForTest(handlers: readonly ConfiguredHookHandler[]): Hooks;
+    is_empty(): boolean;
+    preview_session_start(request: SessionStartRequest): HookRunSummary[];
+    run_session_start(request: SessionStartRequest): Promise<PostToolUseOutcome>;
+    preview_user_prompt_submit(): HookRunSummary[];
+    run_user_prompt_submit(request: UserPromptSubmitRequest): Promise<PostToolUseOutcome>;
+    preview_pre_tool_use(request: PreToolUseRequest): HookRunSummary[];
+    run_pre_tool_use(request: PreToolUseRequest): Promise<PreToolUseOutcome>;
+    preview_post_tool_use(request: PostToolUseRequest): HookRunSummary[];
+    run_post_tool_use(request: PostToolUseRequest): Promise<PostToolUseOutcome>;
+    preview_permission_request(request: PermissionRequestRequest): HookRunSummary[];
+    run_permission_request(request: PermissionRequestRequest): Promise<PermissionRequestOutcome>;
+    preview_pre_compact(request: CompactHookRequest): HookRunSummary[];
+    run_pre_compact(request: CompactHookRequest): Promise<PostToolUseOutcome>;
+    preview_post_compact(request: CompactHookRequest): HookRunSummary[];
+    run_post_compact(request: CompactHookRequest): Promise<PostToolUseOutcome>;
+    preview_stop(): HookRunSummary[];
+    run_stop(request: CompactHookRequest): Promise<PostToolUseOutcome>;
+    private preview;
+    private runContextInjecting;
+    private runMatching;
+}
+export declare function run_session_start_hooks(session: Session, turnContext: TurnContext, source?: string): Promise<boolean>;
+export declare function run_user_prompt_submit_hooks(session: Session, turnContext: TurnContext, prompt: string): Promise<HookRuntimeOutcome>;
+export declare function run_pre_tool_use_hooks(session: Session, turnContext: TurnContext, input: {
+    tool_use_id: string;
+    tool_name: string;
+    matcher_aliases?: string[];
+    tool_input: unknown;
+}): Promise<string | null>;
+export declare function run_post_tool_use_hooks(session: Session, turnContext: TurnContext, input: {
+    tool_use_id: string;
+    tool_name: string;
+    matcher_aliases?: string[];
+    tool_input: unknown;
+    tool_response: unknown;
+}): Promise<PostToolUseOutcome>;
+export declare function run_permission_request_hooks(session: Session, turnContext: TurnContext, input: {
+    run_id_suffix: string;
+    tool_name: string;
+    matcher_aliases?: string[];
+    tool_input: unknown;
+}): Promise<PermissionRequestDecision | null>;
+export declare function run_pre_compact_hooks(session: Session, turnContext: TurnContext, trigger?: "manual" | "auto"): Promise<HookRuntimeOutcome>;
+export declare function run_post_compact_hooks(session: Session, turnContext: TurnContext, trigger?: "manual" | "auto"): Promise<HookRuntimeOutcome>;
+export declare function run_stop_hooks(session: Session, turnContext: TurnContext): Promise<HookRuntimeOutcome>;
+export declare function hookAdditionalContextResponseItem(text: string): ResponseItem;
+export declare function record_additional_contexts(session: Session, turnContext: TurnContext, contexts: readonly string[]): Promise<void>;
+export declare function requestPermissionsResponseFromDecision(decision: PermissionRequestDecision | null): RequestPermissionsResponse | null;

package/dist/internal/codex/core/src/hooks/types.d.ts

@@ -0,0 +1,40 @@
+import { HookEventName, HookExecutionMode, HookHandlerType, HookOutputEntryKind, HookRunStatus, HookScope, HookSource, type HookCompletedEvent, type HookOutputEntry, type HookRunSummary, type HookStartedEvent } from "../protocol.js";
+export { HookEventName, HookExecutionMode, HookHandlerType, HookOutputEntryKind, HookRunStatus, HookScope, HookSource, type HookCompletedEvent, type HookOutputEntry, type HookRunSummary, type HookStartedEvent, };
+export declare const HOOK_EVENT_NAMES: readonly ["PreToolUse", "PermissionRequest", "PostToolUse", "PreCompact", "PostCompact", "SessionStart", "UserPromptSubmit", "Stop"];
+export declare const HOOK_EVENT_NAMES_WITH_MATCHERS: readonly ["PreToolUse", "PermissionRequest", "PostToolUse", "PreCompact", "PostCompact", "SessionStart"];
+export type ConfiguredHookHandler = {
+    event_name: HookEventName;
+    matcher?: string | null;
+    name?: string | null;
+    status_message?: string | null;
+    source_path?: string | null;
+    source?: HookSource;
+    display_order?: number;
+    run?: (request: unknown) => Promise<HookHandlerResult> | HookHandlerResult;
+};
+export type HookHandlerResult = {
+    status?: HookRunStatus;
+    entries?: HookOutputEntry[];
+    additional_contexts?: string[];
+    block_reason?: string | null;
+    stop_reason?: string | null;
+    feedback_message?: string | null;
+    permission_decision?: PermissionRequestDecision | null;
+};
+export declare const PermissionRequestDecision: {
+    readonly Allow: "allow";
+    readonly Deny: "deny";
+};
+export type PermissionRequestDecision = {
+    type: typeof PermissionRequestDecision.Allow;
+} | {
+    type: typeof PermissionRequestDecision.Deny;
+    message?: string | null;
+};
+export declare function runningHookRunSummary(handler: ConfiguredHookHandler, now?: number): HookRunSummary;
+export declare function completedHookRunSummary(handler: ConfiguredHookHandler, result: HookHandlerResult, input: {
+    started_at: number;
+    completed_at?: number;
+}): HookRunSummary;
+export declare function hookRunId(handler: ConfiguredHookHandler): string;
+export declare function scopeForHookEvent(eventName: HookEventName): HookScope;

package/dist/internal/codex/core/src/ids.d.ts

@@ -0,0 +1,5 @@
+export type CodexBrand<TValue, TBrand extends string> = TValue & {
+    readonly __codexBrand: TBrand;
+};
+export type ThreadId = CodexBrand<string, "ThreadId">;
+export declare function asThreadId(value: string): ThreadId;

package/dist/internal/codex/core/src/index.d.ts

@@ -0,0 +1,98 @@
+export * from "./config-types.js";
+export * from "./agent/mod.js";
+export * from "./auth.js";
+export * from "./collaboration-mode-presets.js";
+export * from "./client.js";
+export * from "./compact.js";
+export * from "./context/environment-context.js";
+export * from "./context/fragment.js";
+export * from "./context/collaboration-mode-instructions.js";
+export * from "./context/context-updates.js";
+export * from "./context/permissions-instructions.js";
+export * from "./context/prompt-context.js";
+export * from "./context/turn-aborted.js";
+export * from "./context/user-instructions.js";
+export * from "./context_manager/history.js";
+export * from "./context_manager/normalize.js";
+export * from "./event-mapping.js";
+export * from "./exec-output.js";
+export * from "./hooks/index.js";
+export * from "./goals.js";
+export * from "./ids.js";
+export * from "./items.js";
+export * from "./memory.js";
+export * from "./mcp.js";
+export * from "./model-provider.js";
+export * from "./config/mod.js";
+export * from "./plan-mode.js";
+export * from "./protocol.js";
+export * from "./protocol/dynamic_tools.js";
+export * from "./protocol/user_input.js";
+export * from "./rendered-thread.js";
+export * from "./request_permissions.js";
+export * from "./request_user_input.js";
+export * from "./session/session.js";
+export * from "./session/session-settings.js";
+export * from "./session/rollout-reconstruction.js";
+export * from "./session/turn.js";
+export * from "./session/turn-context.js";
+export * from "./session/turn-timing.js";
+export * from "./state/session.js";
+export * from "./state/turn.js";
+export * from "./stream-parser.js";
+export * from "./stream_events_utils.js";
+export * from "./tasks/mod.js";
+export * from "./tasks/regular.js";
+export * from "./tasks/compact.js";
+export * from "./templates.js";
+export * from "./thread-store/live-thread.js";
+export * from "./thread-store/store.js";
+export * from "./thread-store/types.js";
+export * from "./thread-history-builder.js";
+export * from "./compact-task-runner.js";
+export * from "./tools/context.js";
+export * from "./tools/hook_names.js";
+export * from "./tools/network_approval.js";
+export * from "./tools/handlers/apply_patch.js";
+export * from "./tools/handlers/apply_patch_spec.js";
+export * from "./tools/handlers/mcp_resource.js";
+export * from "./tools/handlers/mcp_resource_spec.js";
+export * from "./tools/handlers/dynamic.js";
+export * from "./tools/handlers/goal.js";
+export * from "./tools/handlers/goal_spec.js";
+export * from "./tools/handlers/mcp.js";
+export * from "./tools/handlers/multi_agents.js";
+export * from "./tools/handlers/multi_agents_common.js";
+export * from "./tools/handlers/multi_agents_spec.js";
+export * from "./tools/handlers/multi_agents_v2.js";
+export * from "./tools/handlers/plan.js";
+export * from "./tools/handlers/plan_spec.js";
+export * from "./tools/handlers/request_plugin_install.js";
+export * from "./tools/handlers/request_plugin_install_spec.js";
+export * from "./tools/handlers/request_permissions.js";
+export * from "./tools/handlers/request_permissions_spec.js";
+export * from "./tools/handlers/request_user_input.js";
+export * from "./tools/handlers/request_user_input_spec.js";
+export * from "./tools/handlers/shell_spec.js";
+export * from "./tools/handlers/test_sync.js";
+export * from "./tools/handlers/test_sync_spec.js";
+export * from "./tools/handlers/tool_search.js";
+export * from "./tools/handlers/tool_search_spec.js";
+export * from "./tools/handlers/unavailable_tool.js";
+export * from "./tools/handlers/unified_exec.js";
+export * from "./tools/code_mode/mod.js";
+export * from "./tools/events.js";
+export * from "./tools/hosted_spec.js";
+export * from "./tools/orchestrator.js";
+export * from "./tools/parallel.js";
+export * from "./tools/responses_api.js";
+export * from "./tools/runtimes/mod.js";
+export * from "./tools/router.js";
+export * from "./tools/sandboxing.js";
+export * from "./tools/spec.js";
+export * from "./tools/spec_plan.js";
+export * from "./tools/spec_plan_types.js";
+export * from "./tools/tool_dispatch_trace.js";
+export * from "./tools/tool_search_entry.js";
+export * from "./tools/tool_spec.js";
+export * from "./tools/tool_name.js";

package/dist/internal/codex/core/src/items.d.ts

@@ -0,0 +1,137 @@
+import type { MemoryCitation } from "./memory.js";
+import type { UserInput } from "./protocol.js";
+export type AgentMessageContent = {
+    type: "Text";
+    text: string;
+};
+export type UserMessageTurnItem = {
+    type: "UserMessage";
+    id: string;
+    content: UserInput[];
+};
+export type HookPromptFragment = {
+    text: string;
+    hookRunId: string;
+};
+export type HookPromptTurnItem = {
+    type: "HookPrompt";
+    id: string;
+    fragments: HookPromptFragment[];
+};
+export type AgentMessageTurnItem = {
+    type: "AgentMessage";
+    id: string;
+    content: AgentMessageContent[];
+    phase?: string | null;
+    memory_citation?: MemoryCitation | null;
+};
+export type PlanTurnItem = {
+    type: "Plan";
+    id: string;
+    text: string;
+};
+export type ReasoningTurnItem = {
+    type: "Reasoning";
+    id: string;
+    summary_text: string[];
+    raw_content: string[];
+};
+export type WebSearchAction = {
+    type: "search";
+    query?: string;
+    queries?: string[];
+} | {
+    type: "open_page";
+    url?: string;
+} | {
+    type: "find_in_page";
+    url?: string;
+    pattern?: string;
+} | {
+    type: "other";
+};
+export type WebSearchTurnItem = {
+    type: "WebSearch";
+    id: string;
+    query: string;
+    action: WebSearchAction;
+};
+export type ImageViewTurnItem = {
+    type: "ImageView";
+    id: string;
+    path: string;
+};
+export type ImageGenerationTurnItem = {
+    type: "ImageGeneration";
+    id: string;
+    status: string;
+    revised_prompt?: string;
+    result: string;
+    saved_path?: string;
+};
+export type FileChange = {
+    type: "add";
+    content: string;
+} | {
+    type: "delete";
+    content: string;
+} | {
+    type: "update";
+    unified_diff: string;
+    move_path: string | null;
+};
+export type PatchApplyStatus = "completed" | "failed" | "declined";
+export type FileChangeTurnItem = {
+    type: "FileChange";
+    id: string;
+    changes: Record<string, FileChange>;
+    status?: PatchApplyStatus | null;
+    auto_approved?: boolean;
+    stdout?: string;
+    stderr?: string;
+};
+export type CommandExecutionStatus = "in_progress" | "completed" | "failed" | "cancelled";
+export type CommandExecutionTurnItem = {
+    type: "CommandExecution";
+    id: string;
+    command: string[];
+    cwd: string;
+    status: CommandExecutionStatus;
+    stdout?: string;
+    stderr?: string;
+    exit_code?: number | null;
+    duration_ms?: number | null;
+};
+export type McpToolCallStatus = "inProgress" | "completed" | "failed";
+export type McpToolCallError = {
+    message: string;
+};
+export type McpToolCallTurnItem = {
+    type: "McpToolCall";
+    id: string;
+    server: string;
+    tool: string;
+    arguments: unknown;
+    mcpAppResourceUri?: string;
+    status: McpToolCallStatus;
+    result?: unknown;
+    error?: McpToolCallError;
+    duration?: string;
+};
+export type DynamicToolCallStatus = "inProgress" | "completed" | "failed";
+export type DynamicToolCallTurnItem = {
+    type: "DynamicToolCall";
+    id: string;
+    namespace?: string | null;
+    tool: string;
+    arguments: unknown;
+    status: DynamicToolCallStatus;
+    content_items?: unknown[] | null;
+    success?: boolean | null;
+    duration?: string | null;
+};
+export type ContextCompactionTurnItem = {
+    type: "ContextCompaction";
+    id: string;
+};
+export type TurnItem = UserMessageTurnItem | HookPromptTurnItem | AgentMessageTurnItem | PlanTurnItem | ReasoningTurnItem | WebSearchTurnItem | ImageViewTurnItem | ImageGenerationTurnItem | CommandExecutionTurnItem | FileChangeTurnItem | McpToolCallTurnItem | DynamicToolCallTurnItem | ContextCompactionTurnItem;