@jrkropp/codex-js 0.1.4 → 0.2.0

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/SkillsConfigWriteResponse.d.ts

@@ -0,0 +1,3 @@
+export type SkillsConfigWriteResponse = {
+    effectiveEnabled: boolean;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/SkillsListEntry.d.ts

@@ -0,0 +1,7 @@
+import type { SkillErrorInfo } from "./SkillErrorInfo.js";
+import type { SkillMetadata } from "./SkillMetadata.js";
+export type SkillsListEntry = {
+    cwd: string;
+    skills: Array<SkillMetadata>;
+    errors: Array<SkillErrorInfo>;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/SkillsListExtraRootsForCwd.d.ts

@@ -0,0 +1,4 @@
+export type SkillsListExtraRootsForCwd = {
+    cwd: string;
+    extraUserRoots: Array<string>;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/SkillsListParams.d.ts

@@ -0,0 +1,15 @@
+import type { SkillsListExtraRootsForCwd } from "./SkillsListExtraRootsForCwd.js";
+export type SkillsListParams = {
+    /**
+     * When empty, defaults to the current session working directory.
+     */
+    cwds?: Array<string>;
+    /**
+     * When true, bypass the skills cache and re-scan skills from disk.
+     */
+    forceReload?: boolean;
+    /**
+     * Optional per-cwd extra roots to scan as user-scoped skills.
+     */
+    perCwdExtraUserRoots?: Array<SkillsListExtraRootsForCwd> | null;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/SkillsListResponse.d.ts

@@ -0,0 +1,4 @@
+import type { SkillsListEntry } from "./SkillsListEntry.js";
+export type SkillsListResponse = {
+    data: Array<SkillsListEntry>;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/SortDirection.d.ts

@@ -0,0 +1 @@
+export type SortDirection = "asc" | "desc";

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/SubagentMigration.d.ts

@@ -0,0 +1,3 @@
+export type SubagentMigration = {
+    name: string;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/TerminalInteractionNotification.d.ts

@@ -0,0 +1,7 @@
+export type TerminalInteractionNotification = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    processId: string;
+    stdin: string;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/TextElement.d.ts

@@ -0,0 +1,11 @@
+import type { ByteRange } from "./ByteRange.js";
+export type TextElement = {
+    /**
+     * Byte range in the parent `text` buffer that this element occupies.
+     */
+    byteRange: ByteRange;
+    /**
+     * Optional human-readable placeholder for the element, displayed in the UI.
+     */
+    placeholder: string | null;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/TextPosition.d.ts

@@ -0,0 +1,10 @@
+export type TextPosition = {
+    /**
+     * 1-based line number.
+     */
+    line: number;
+    /**
+     * 1-based column number (in Unicode scalar values).
+     */
+    column: number;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/TextRange.d.ts

@@ -0,0 +1,5 @@
+import type { TextPosition } from "./TextPosition.js";
+export type TextRange = {
+    start: TextPosition;
+    end: TextPosition;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/Thread.d.ts

@@ -0,0 +1,84 @@
+import type { AbsolutePathBuf } from "../AbsolutePathBuf.js";
+import type { GitInfo } from "./GitInfo.js";
+import type { SessionSource } from "./SessionSource.js";
+import type { ThreadSource } from "./ThreadSource.js";
+import type { ThreadStatus } from "./ThreadStatus.js";
+import type { Turn } from "./Turn.js";
+export type Thread = {
+    id: string;
+    /**
+     * Session id shared by threads that belong to the same session tree.
+     */
+    sessionId: string;
+    /**
+     * Source thread id when this thread was created by forking another thread.
+     */
+    forkedFromId: string | null;
+    /**
+     * Usually the first user message in the thread, if available.
+     */
+    preview: string;
+    /**
+     * Whether the thread is ephemeral and should not be materialized on disk.
+     */
+    ephemeral: boolean;
+    /**
+     * Model provider used for this thread (for example, 'openai').
+     */
+    modelProvider: string;
+    /**
+     * Unix timestamp (in seconds) when the thread was created.
+     */
+    createdAt: number;
+    /**
+     * Unix timestamp (in seconds) when the thread was last updated.
+     */
+    updatedAt: number;
+    /**
+     * Current runtime status for the thread.
+     */
+    status: ThreadStatus;
+    /**
+     * [UNSTABLE] Path to the thread on disk.
+     */
+    path: string | null;
+    /**
+     * Working directory captured for the thread.
+     */
+    cwd: AbsolutePathBuf;
+    /**
+     * Version of the CLI that created the thread.
+     */
+    cliVersion: string;
+    /**
+     * Origin of the thread (CLI, VSCode, codex exec, codex app-server, etc.).
+     */
+    source: SessionSource;
+    /**
+     * Optional analytics source classification for this thread.
+     */
+    threadSource: ThreadSource | null;
+    /**
+     * Optional random unique nickname assigned to an AgentControl-spawned sub-agent.
+     */
+    agentNickname: string | null;
+    /**
+     * Optional role (agent_role) assigned to an AgentControl-spawned sub-agent.
+     */
+    agentRole: string | null;
+    /**
+     * Optional Git metadata captured when the thread was created.
+     */
+    gitInfo: GitInfo | null;
+    /**
+     * Optional user-facing thread title.
+     */
+    name: string | null;
+    /**
+     * Only populated on `thread/resume`, `thread/rollback`, `thread/fork`, and `thread/read`
+     * (when `includeTurns` is true) responses.
+     * For all other responses and notifications returning a Thread,
+     * the turns field will be an empty list.
+     */
+    turns: Array<Turn>;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadActiveFlag.d.ts

@@ -0,0 +1 @@
+export type ThreadActiveFlag = "waitingOnApproval" | "waitingOnUserInput";

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadApproveGuardianDeniedActionParams.d.ts

@@ -0,0 +1,8 @@
+import type { JsonValue } from "../serde_json/JsonValue.js";
+export type ThreadApproveGuardianDeniedActionParams = {
+    threadId: string;
+    /**
+     * Serialized `codex_protocol::protocol::GuardianAssessmentEvent`.
+     */
+    event: JsonValue;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadApproveGuardianDeniedActionResponse.d.ts

@@ -0,0 +1 @@
+export type ThreadApproveGuardianDeniedActionResponse = Record<string, never>;

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadArchiveParams.d.ts

@@ -0,0 +1,3 @@
+export type ThreadArchiveParams = {
+    threadId: string;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadArchiveResponse.d.ts

@@ -0,0 +1 @@
+export type ThreadArchiveResponse = Record<string, never>;

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadArchivedNotification.d.ts

@@ -0,0 +1,3 @@
+export type ThreadArchivedNotification = {
+    threadId: string;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadClosedNotification.d.ts

@@ -0,0 +1,3 @@
+export type ThreadClosedNotification = {
+    threadId: string;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadCompactStartParams.d.ts

@@ -0,0 +1,3 @@
+export type ThreadCompactStartParams = {
+    threadId: string;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadCompactStartResponse.d.ts

@@ -0,0 +1 @@
+export type ThreadCompactStartResponse = Record<string, never>;

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadForkParams.d.ts

@@ -0,0 +1,38 @@
+import type { JsonValue } from "../serde_json/JsonValue.js";
+import type { ApprovalsReviewer } from "./ApprovalsReviewer.js";
+import type { AskForApproval } from "./AskForApproval.js";
+import type { SandboxMode } from "./SandboxMode.js";
+import type { ThreadSource } from "./ThreadSource.js";
+/**
+ * There are two ways to fork a thread:
+ * 1. By thread_id: load the thread from disk by thread_id and fork it into a new thread.
+ * 2. By path: load the thread from disk by path and fork it into a new thread.
+ *
+ * If using path, the thread_id param will be ignored.
+ *
+ * Prefer using thread_id whenever possible.
+ */
+export type ThreadForkParams = {
+    threadId: string; /**
+     * Configuration overrides for the forked thread, if any.
+     */
+    model?: string | null;
+    modelProvider?: string | null;
+    serviceTier?: string | null | null;
+    cwd?: string | null;
+    approvalPolicy?: AskForApproval | null; /**
+     * Override where approval requests are routed for review on this thread
+     * and subsequent turns.
+     */
+    approvalsReviewer?: ApprovalsReviewer | null;
+    sandbox?: SandboxMode | null;
+    config?: {
+        [key in string]?: JsonValue;
+    } | null;
+    baseInstructions?: string | null;
+    developerInstructions?: string | null;
+    ephemeral?: boolean; /**
+     * Optional client-supplied analytics source classification for this forked thread.
+     */
+    threadSource?: ThreadSource | null;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadForkResponse.d.ts

@@ -0,0 +1,26 @@
+import type { AbsolutePathBuf } from "../AbsolutePathBuf.js";
+import type { ReasoningEffort } from "../ReasoningEffort.js";
+import type { ApprovalsReviewer } from "./ApprovalsReviewer.js";
+import type { AskForApproval } from "./AskForApproval.js";
+import type { SandboxPolicy } from "./SandboxPolicy.js";
+import type { Thread } from "./Thread.js";
+export type ThreadForkResponse = {
+    thread: Thread;
+    model: string;
+    modelProvider: string;
+    serviceTier: string | null;
+    cwd: AbsolutePathBuf; /**
+     * Instruction source files currently loaded for this thread.
+     */
+    instructionSources: Array<AbsolutePathBuf>;
+    approvalPolicy: AskForApproval; /**
+     * Reviewer currently used for approval requests on this thread.
+     */
+    approvalsReviewer: ApprovalsReviewer; /**
+     * Legacy sandbox policy retained for compatibility. Experimental clients
+     * should prefer `permissionProfile` when they need exact runtime
+     * permissions.
+     */
+    sandbox: SandboxPolicy;
+    reasoningEffort: ReasoningEffort | null;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadGoal.d.ts

@@ -0,0 +1,11 @@
+import type { ThreadGoalStatus } from "./ThreadGoalStatus.js";
+export type ThreadGoal = {
+    threadId: string;
+    objective: string;
+    status: ThreadGoalStatus;
+    tokenBudget: number | null;
+    tokensUsed: number;
+    timeUsedSeconds: number;
+    createdAt: number;
+    updatedAt: number;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadGoalClearedNotification.d.ts

@@ -0,0 +1,3 @@
+export type ThreadGoalClearedNotification = {
+    threadId: string;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadGoalStatus.d.ts

@@ -0,0 +1 @@
+export type ThreadGoalStatus = "active" | "paused" | "budgetLimited" | "complete";

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadGoalUpdatedNotification.d.ts

@@ -0,0 +1,6 @@
+import type { ThreadGoal } from "./ThreadGoal.js";
+export type ThreadGoalUpdatedNotification = {
+    threadId: string;
+    turnId: string | null;
+    goal: ThreadGoal;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadInjectItemsParams.d.ts

@@ -0,0 +1,8 @@
+import type { JsonValue } from "../serde_json/JsonValue.js";
+export type ThreadInjectItemsParams = {
+    threadId: string;
+    /**
+     * Raw Responses API items to append to the thread's model-visible history.
+     */
+    items: Array<JsonValue>;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadInjectItemsResponse.d.ts

@@ -0,0 +1 @@
+export type ThreadInjectItemsResponse = Record<string, never>;

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadItem.d.ts

@@ -0,0 +1,180 @@
+import type { AbsolutePathBuf } from "../AbsolutePathBuf.js";
+import type { MessagePhase } from "../MessagePhase.js";
+import type { ReasoningEffort } from "../ReasoningEffort.js";
+import type { JsonValue } from "../serde_json/JsonValue.js";
+import type { CollabAgentState } from "./CollabAgentState.js";
+import type { CollabAgentTool } from "./CollabAgentTool.js";
+import type { CollabAgentToolCallStatus } from "./CollabAgentToolCallStatus.js";
+import type { CommandAction } from "./CommandAction.js";
+import type { CommandExecutionSource } from "./CommandExecutionSource.js";
+import type { CommandExecutionStatus } from "./CommandExecutionStatus.js";
+import type { DynamicToolCallOutputContentItem } from "./DynamicToolCallOutputContentItem.js";
+import type { DynamicToolCallStatus } from "./DynamicToolCallStatus.js";
+import type { FileUpdateChange } from "./FileUpdateChange.js";
+import type { HookPromptFragment } from "./HookPromptFragment.js";
+import type { McpToolCallError } from "./McpToolCallError.js";
+import type { McpToolCallResult } from "./McpToolCallResult.js";
+import type { McpToolCallStatus } from "./McpToolCallStatus.js";
+import type { MemoryCitation } from "./MemoryCitation.js";
+import type { PatchApplyStatus } from "./PatchApplyStatus.js";
+import type { UserInput } from "./UserInput.js";
+import type { WebSearchAction } from "./WebSearchAction.js";
+export type ThreadItem = {
+    "type": "userMessage";
+    id: string;
+    content: Array<UserInput>;
+} | {
+    "type": "hookPrompt";
+    id: string;
+    fragments: Array<HookPromptFragment>;
+} | {
+    "type": "agentMessage";
+    id: string;
+    text: string;
+    phase: MessagePhase | null;
+    memoryCitation: MemoryCitation | null;
+} | {
+    "type": "plan";
+    id: string;
+    text: string;
+} | {
+    "type": "reasoning";
+    id: string;
+    summary: Array<string>;
+    content: Array<string>;
+} | {
+    "type": "commandExecution";
+    id: string;
+    /**
+     * The command to be executed.
+     */
+    command: string;
+    /**
+     * The command's working directory.
+     */
+    cwd: AbsolutePathBuf;
+    /**
+     * Identifier for the underlying PTY process (when available).
+     */
+    processId: string | null;
+    source: CommandExecutionSource;
+    status: CommandExecutionStatus;
+    /**
+     * A best-effort parsing of the command to understand the action(s) it will perform.
+     * This returns a list of CommandAction objects because a single shell command may
+     * be composed of many commands piped together.
+     */
+    commandActions: Array<CommandAction>;
+    /**
+     * The command's output, aggregated from stdout and stderr.
+     */
+    aggregatedOutput: string | null;
+    /**
+     * The command's exit code.
+     */
+    exitCode: number | null;
+    /**
+     * The duration of the command execution in milliseconds.
+     */
+    durationMs: number | null;
+} | {
+    "type": "fileChange";
+    id: string;
+    changes: Array<FileUpdateChange>;
+    status: PatchApplyStatus;
+} | {
+    "type": "mcpToolCall";
+    id: string;
+    server: string;
+    tool: string;
+    status: McpToolCallStatus;
+    arguments: JsonValue;
+    mcpAppResourceUri?: string;
+    result: McpToolCallResult | null;
+    error: McpToolCallError | null;
+    /**
+     * The duration of the MCP tool call in milliseconds.
+     */
+    durationMs: number | null;
+} | {
+    "type": "dynamicToolCall";
+    id: string;
+    namespace: string | null;
+    tool: string;
+    arguments: JsonValue;
+    status: DynamicToolCallStatus;
+    contentItems: Array<DynamicToolCallOutputContentItem> | null;
+    success: boolean | null;
+    /**
+     * The duration of the dynamic tool call in milliseconds.
+     */
+    durationMs: number | null;
+} | {
+    "type": "collabAgentToolCall";
+    /**
+     * Unique identifier for this collab tool call.
+     */
+    id: string;
+    /**
+     * Name of the collab tool that was invoked.
+     */
+    tool: CollabAgentTool;
+    /**
+     * Current status of the collab tool call.
+     */
+    status: CollabAgentToolCallStatus;
+    /**
+     * Thread ID of the agent issuing the collab request.
+     */
+    senderThreadId: string;
+    /**
+     * Thread ID of the receiving agent, when applicable. In case of spawn operation,
+     * this corresponds to the newly spawned agent.
+     */
+    receiverThreadIds: Array<string>;
+    /**
+     * Prompt text sent as part of the collab tool call, when available.
+     */
+    prompt: string | null;
+    /**
+     * Model requested for the spawned agent, when applicable.
+     */
+    model: string | null;
+    /**
+     * Reasoning effort requested for the spawned agent, when applicable.
+     */
+    reasoningEffort: ReasoningEffort | null;
+    /**
+     * Last known status of the target agents, when available.
+     */
+    agentsStates: {
+        [key in string]?: CollabAgentState;
+    };
+} | {
+    "type": "webSearch";
+    id: string;
+    query: string;
+    action: WebSearchAction | null;
+} | {
+    "type": "imageView";
+    id: string;
+    path: AbsolutePathBuf;
+} | {
+    "type": "imageGeneration";
+    id: string;
+    status: string;
+    revisedPrompt: string | null;
+    result: string;
+    savedPath?: AbsolutePathBuf;
+} | {
+    "type": "enteredReviewMode";
+    id: string;
+    review: string;
+} | {
+    "type": "exitedReviewMode";
+    id: string;
+    review: string;
+} | {
+    "type": "contextCompaction";
+    id: string;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadListParams.d.ts

@@ -0,0 +1,51 @@
+import type { SortDirection } from "./SortDirection.js";
+import type { ThreadSortKey } from "./ThreadSortKey.js";
+import type { ThreadSourceKind } from "./ThreadSourceKind.js";
+export type ThreadListParams = {
+    /**
+     * Opaque pagination cursor returned by a previous call.
+     */
+    cursor?: string | null;
+    /**
+     * Optional page size; defaults to a reasonable server-side value.
+     */
+    limit?: number | null;
+    /**
+     * Optional sort key; defaults to created_at.
+     */
+    sortKey?: ThreadSortKey | null;
+    /**
+     * Optional sort direction; defaults to descending (newest first).
+     */
+    sortDirection?: SortDirection | null;
+    /**
+     * Optional provider filter; when set, only sessions recorded under these
+     * providers are returned. When present but empty, includes all providers.
+     */
+    modelProviders?: Array<string> | null;
+    /**
+     * Optional source filter; when set, only sessions from these source kinds
+     * are returned. When omitted or empty, defaults to interactive sources.
+     */
+    sourceKinds?: Array<ThreadSourceKind> | null;
+    /**
+     * Optional archived filter; when set to true, only archived threads are returned.
+     * If false or null, only non-archived threads are returned.
+     */
+    archived?: boolean | null;
+    /**
+     * Optional cwd filter or filters; when set, only threads whose session cwd
+     * exactly matches one of these paths are returned.
+     */
+    cwd?: string | Array<string> | null;
+    /**
+     * If true, return from the state DB without scanning JSONL rollouts to
+     * repair thread metadata. Omitted or false preserves scan-and-repair
+     * behavior.
+     */
+    useStateDbOnly?: boolean;
+    /**
+     * Optional substring filter for the extracted thread title.
+     */
+    searchTerm?: string | null;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadListResponse.d.ts

@@ -0,0 +1,16 @@
+import type { Thread } from "./Thread.js";
+export type ThreadListResponse = {
+    data: Array<Thread>;
+    /**
+     * Opaque cursor to pass to the next call to continue after the last item.
+     * if None, there are no more items to return.
+     */
+    nextCursor: string | null;
+    /**
+     * Opaque cursor to pass as `cursor` when reversing `sortDirection`.
+     * This is only populated when the page contains at least one thread.
+     * Use it with the opposite `sortDirection`; for timestamp sorts it anchors
+     * at the start of the page timestamp so same-second updates are not skipped.
+     */
+    backwardsCursor: string | null;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadLoadedListParams.d.ts

@@ -0,0 +1,10 @@
+export type ThreadLoadedListParams = {
+    /**
+     * Opaque pagination cursor returned by a previous call.
+     */
+    cursor?: string | null;
+    /**
+     * Optional page size; defaults to no limit.
+     */
+    limit?: number | null;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadLoadedListResponse.d.ts

@@ -0,0 +1,11 @@
+export type ThreadLoadedListResponse = {
+    /**
+     * Thread ids for sessions currently loaded in memory.
+     */
+    data: Array<string>;
+    /**
+     * Opaque cursor to pass to the next call to continue after the last item.
+     * if None, there are no more items to return.
+     */
+    nextCursor: string | null;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadMetadataGitInfoUpdateParams.d.ts

@@ -0,0 +1,17 @@
+export type ThreadMetadataGitInfoUpdateParams = {
+    /**
+     * Omit to leave the stored commit unchanged, set to `null` to clear it,
+     * or provide a non-empty string to replace it.
+     */
+    sha?: string | null;
+    /**
+     * Omit to leave the stored branch unchanged, set to `null` to clear it,
+     * or provide a non-empty string to replace it.
+     */
+    branch?: string | null;
+    /**
+     * Omit to leave the stored origin URL unchanged, set to `null` to clear it,
+     * or provide a non-empty string to replace it.
+     */
+    originUrl?: string | null;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadMetadataUpdateParams.d.ts

@@ -0,0 +1,10 @@
+import type { ThreadMetadataGitInfoUpdateParams } from "./ThreadMetadataGitInfoUpdateParams.js";
+export type ThreadMetadataUpdateParams = {
+    threadId: string;
+    /**
+     * Patch the stored Git metadata for this thread.
+     * Omit a field to leave it unchanged, set it to `null` to clear it, or
+     * provide a string to replace the stored value.
+     */
+    gitInfo?: ThreadMetadataGitInfoUpdateParams | null;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadMetadataUpdateResponse.d.ts

@@ -0,0 +1,4 @@
+import type { Thread } from "./Thread.js";
+export type ThreadMetadataUpdateResponse = {
+    thread: Thread;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadNameUpdatedNotification.d.ts

@@ -0,0 +1,4 @@
+export type ThreadNameUpdatedNotification = {
+    threadId: string;
+    threadName?: string;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadReadParams.d.ts

@@ -0,0 +1,7 @@
+export type ThreadReadParams = {
+    threadId: string;
+    /**
+     * When true, include turns and their items from rollout history.
+     */
+    includeTurns: boolean;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/v2/ThreadReadResponse.d.ts

@@ -0,0 +1,4 @@
+import type { Thread } from "./Thread.js";
+export type ThreadReadResponse = {
+    thread: Thread;
+};