t3code-cli 0.2.0 → 0.4.0

package/dist/src/application/model-selection.d.ts

@@ -0,0 +1,19 @@
+import * as Effect from "effect/Effect";
+import { ModelSelection } from "#t3tools/contracts";
+import type { OrchestrationProjectShell } from "#t3tools/contracts";
+import { ModelSelectionError } from "../domain/error.ts";
+import type { ServerConfigForCli } from "../orchestration/service.ts";
+import type { StartThreadInput } from "./service.ts";
+export declare function resolveModelSelection(input: {
+    readonly start: StartThreadInput;
+    readonly project: OrchestrationProjectShell;
+    readonly serverConfig: ServerConfigForCli;
+}): Effect.Effect<{
+    readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+    readonly model: string;
+    readonly options?: readonly {
+        readonly id: string;
+        readonly value: string | boolean;
+    }[];
+}, ModelSelectionError, never>;
+export declare function mergeModelOptions(selection: ModelSelection, options: NonNullable<ModelSelection["options"]>): ModelSelection;

package/dist/src/application/models.d.ts

@@ -0,0 +1,93 @@
+import * as Effect from "effect/Effect";
+import { T3Orchestration } from "../orchestration/service.ts";
+export declare const makeModelsApplication: () => Effect.Effect<{
+    listModels: (input: {
+        readonly all?: boolean;
+        readonly provider?: string;
+    }) => Effect.Effect<{
+        readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+        readonly driver: string & import("effect/Brand").Brand<"ProviderDriverKind">;
+        readonly enabled: boolean;
+        readonly installed: boolean;
+        readonly version: string | null;
+        readonly status: "error" | "ready" | "warning" | "disabled";
+        readonly auth: {
+            readonly status: "authenticated" | "unknown" | "unauthenticated";
+            readonly type?: string | undefined;
+            readonly label?: string | undefined;
+            readonly email?: string | undefined;
+        };
+        readonly checkedAt: string;
+        readonly models: readonly {
+            readonly slug: string;
+            readonly name: string;
+            readonly isCustom: boolean;
+            readonly capabilities: {
+                readonly optionDescriptors?: readonly ({
+                    readonly type: "select";
+                    readonly options: readonly {
+                        readonly id: string;
+                        readonly label: string;
+                        readonly description?: string | undefined;
+                        readonly isDefault?: boolean | undefined;
+                    }[];
+                    readonly id: string;
+                    readonly label: string;
+                    readonly currentValue?: string | undefined;
+                    readonly promptInjectedValues?: readonly string[] | undefined;
+                    readonly description?: string | undefined;
+                } | {
+                    readonly type: "boolean";
+                    readonly id: string;
+                    readonly label: string;
+                    readonly currentValue?: boolean | undefined;
+                    readonly description?: string | undefined;
+                })[] | undefined;
+            } | null;
+            readonly shortName?: string | undefined;
+            readonly subProvider?: string | undefined;
+        }[];
+        readonly slashCommands: readonly {
+            readonly name: string;
+            readonly description?: string | undefined;
+            readonly input?: {
+                readonly hint: string;
+            } | undefined;
+        }[];
+        readonly skills: readonly {
+            readonly name: string;
+            readonly path: string;
+            readonly enabled: boolean;
+            readonly description?: string | undefined;
+            readonly scope?: string | undefined;
+            readonly displayName?: string | undefined;
+            readonly shortDescription?: string | undefined;
+        }[];
+        readonly displayName?: string | undefined;
+        readonly accentColor?: string | undefined;
+        readonly badgeLabel?: string | undefined;
+        readonly continuation?: {
+            readonly groupKey: string;
+        } | undefined;
+        readonly showInteractionModeToggle?: boolean | undefined;
+        readonly message?: string | undefined;
+        readonly availability?: "available" | "unavailable" | undefined;
+        readonly unavailableReason?: string | undefined;
+        readonly versionAdvisory?: {
+            readonly status: "unknown" | "current" | "behind_latest";
+            readonly currentVersion: string | null;
+            readonly latestVersion: string | null;
+            readonly updateCommand: string | null;
+            readonly canUpdate: boolean;
+            readonly checkedAt: string | null;
+            readonly message: string | null;
+        };
+        readonly updateState?: {
+            readonly status: "idle" | "running" | "failed" | "queued" | "succeeded" | "unchanged";
+            readonly startedAt: string | null;
+            readonly finishedAt: string | null;
+            readonly message: string | null;
+            readonly output: string | null;
+        };
+    }[], import("../rpc/error.ts").RpcError, never>;
+}, never, T3Orchestration>;

package/dist/src/application/project-commands.d.ts

@@ -0,0 +1,15 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Path from "effect/Path";
+import { Environment } from "../environment/service.ts";
+export declare const makeProjectCreateCommand: (input: {
+    readonly path: string;
+    readonly title?: string;
+}) => Effect.Effect<{
+    type: "project.create";
+    commandId: string & import("effect/Brand").Brand<"CommandId">;
+    projectId: string & import("effect/Brand").Brand<"ProjectId">;
+    title: string;
+    workspaceRoot: string;
+    createdAt: string;
+}, never, Environment | Path.Path | Crypto.Crypto>;

package/dist/src/application/projects.d.ts

@@ -0,0 +1,136 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Path from "effect/Path";
+import { Environment } from "../environment/service.ts";
+import { T3Orchestration } from "../orchestration/service.ts";
+import { ProjectCreateVisibilityError } from "../domain/error.ts";
+export declare const makeProjectApplication: () => Effect.Effect<{
+    loadShell: () => Effect.Effect<{
+        readonly snapshotSequence: number;
+        readonly projects: readonly {
+            readonly id: string & import("effect/Brand").Brand<"ProjectId">;
+            readonly title: string;
+            readonly workspaceRoot: string;
+            readonly defaultModelSelection: {
+                readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+                readonly model: string;
+                readonly options?: readonly {
+                    readonly id: string;
+                    readonly value: string | boolean;
+                }[];
+            } | null;
+            readonly scripts: readonly {
+                readonly id: string;
+                readonly name: string;
+                readonly command: string;
+                readonly icon: "play" | "test" | "lint" | "configure" | "build" | "debug";
+                readonly runOnWorktreeCreate: boolean;
+            }[];
+            readonly createdAt: string;
+            readonly updatedAt: string;
+            readonly repositoryIdentity?: {
+                readonly canonicalKey: string;
+                readonly locator: {
+                    readonly source: "git-remote";
+                    readonly remoteName: string;
+                    readonly remoteUrl: string;
+                };
+                readonly rootPath?: string;
+                readonly displayName?: string;
+                readonly provider?: string;
+                readonly owner?: string;
+                readonly name?: string;
+            } | null | undefined;
+        }[];
+        readonly threads: readonly {
+            readonly id: string & import("effect/Brand").Brand<"ThreadId">;
+            readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+            readonly title: string;
+            readonly modelSelection: {
+                readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+                readonly model: string;
+                readonly options?: readonly {
+                    readonly id: string;
+                    readonly value: string | boolean;
+                }[];
+            };
+            readonly runtimeMode: "approval-required" | "auto-accept-edits" | "full-access";
+            readonly interactionMode: "default" | "plan";
+            readonly branch: string | null;
+            readonly worktreePath: string | null;
+            readonly latestTurn: {
+                readonly turnId: string & import("effect/Brand").Brand<"TurnId">;
+                readonly state: "error" | "running" | "interrupted" | "completed";
+                readonly requestedAt: string;
+                readonly startedAt: string | null;
+                readonly completedAt: string | null;
+                readonly assistantMessageId: (string & import("effect/Brand").Brand<"MessageId">) | null;
+                readonly sourceProposedPlan?: {
+                    readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+                    readonly planId: string;
+                } | undefined;
+            } | null;
+            readonly createdAt: string;
+            readonly updatedAt: string;
+            readonly archivedAt: string | null;
+            readonly session: {
+                readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+                readonly status: "error" | "idle" | "starting" | "running" | "ready" | "interrupted" | "stopped";
+                readonly providerName: string | null;
+                readonly runtimeMode: "approval-required" | "auto-accept-edits" | "full-access";
+                readonly activeTurnId: (string & import("effect/Brand").Brand<"TurnId">) | null;
+                readonly lastError: string | null;
+                readonly updatedAt: string;
+                readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
+            } | null;
+            readonly latestUserMessageAt: string | null;
+            readonly hasPendingApprovals: boolean;
+            readonly hasPendingUserInput: boolean;
+            readonly hasActionableProposedPlan: boolean;
+        }[];
+        readonly updatedAt: string;
+    }, import("../rpc/error.ts").RpcError, never>;
+    addProject: (projectInput: {
+        readonly path: string;
+        readonly title?: string;
+    }) => Effect.Effect<{
+        dispatch: {
+            readonly sequence: number;
+        };
+        project: {
+            readonly id: string & import("effect/Brand").Brand<"ProjectId">;
+            readonly title: string;
+            readonly workspaceRoot: string;
+            readonly defaultModelSelection: {
+                readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+                readonly model: string;
+                readonly options?: readonly {
+                    readonly id: string;
+                    readonly value: string | boolean;
+                }[];
+            } | null;
+            readonly scripts: readonly {
+                readonly id: string;
+                readonly name: string;
+                readonly command: string;
+                readonly icon: "play" | "test" | "lint" | "configure" | "build" | "debug";
+                readonly runOnWorktreeCreate: boolean;
+            }[];
+            readonly createdAt: string;
+            readonly updatedAt: string;
+            readonly repositoryIdentity?: {
+                readonly canonicalKey: string;
+                readonly locator: {
+                    readonly source: "git-remote";
+                    readonly remoteName: string;
+                    readonly remoteUrl: string;
+                };
+                readonly rootPath?: string;
+                readonly displayName?: string;
+                readonly provider?: string;
+                readonly owner?: string;
+                readonly name?: string;
+            } | null | undefined;
+        };
+    }, ProjectCreateVisibilityError | import("../rpc/error.ts").RpcError, never>;
+}, never, Environment | Path.Path | Crypto.Crypto | T3Orchestration>;

package/dist/src/application/service.d.ts

@@ -0,0 +1,72 @@
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import type * as Stream from "effect/Stream";
+import type { DispatchResult, ModelSelection, OrchestrationMessage, OrchestrationProjectShell, OrchestrationShellSnapshot, OrchestrationThread, OrchestrationThreadShell, ServerProvider } from "#t3tools/contracts";
+import type { ApplicationError } from "./error.ts";
+export type StartThreadInput = {
+    readonly projectRef: string;
+    readonly message: string;
+    readonly title?: string;
+    readonly provider?: string;
+    readonly model?: string;
+    readonly options?: NonNullable<ModelSelection["options"]>;
+    readonly worktreePath?: string;
+};
+export type SendThreadInput = {
+    readonly threadId: string;
+    readonly message: string;
+    readonly options?: NonNullable<ModelSelection["options"]>;
+};
+export type StartThreadPolicy = {
+    readonly until: "dispatch" | "visible" | "complete";
+};
+export type WaitEvent = {
+    readonly type: "thread";
+    readonly thread: OrchestrationThread;
+} | {
+    readonly type: "message";
+    readonly message: OrchestrationMessage;
+} | {
+    readonly type: "status";
+    readonly status: string;
+    readonly threadId: string;
+} | {
+    readonly type: "done";
+    readonly thread: OrchestrationThread;
+};
+declare const T3Application_base: Context.ServiceClass<T3Application, "t3cli/T3Application", {
+    readonly loadShell: () => Effect.Effect<OrchestrationShellSnapshot, ApplicationError>;
+    readonly listModels: (input: {
+        readonly all?: boolean;
+        readonly provider?: string;
+    }) => Effect.Effect<ReadonlyArray<ServerProvider>, ApplicationError>;
+    readonly addProject: (input: {
+        readonly path: string;
+        readonly title?: string;
+    }) => Effect.Effect<{
+        readonly dispatch: DispatchResult;
+        readonly project: OrchestrationProjectShell;
+    }, ApplicationError>;
+    readonly listThreads: (projectRef: string) => Effect.Effect<{
+        readonly project: OrchestrationProjectShell;
+        readonly threads: ReadonlyArray<OrchestrationThreadShell>;
+    }, ApplicationError>;
+    readonly getThreadMessages: (threadId: string) => Effect.Effect<OrchestrationThread, ApplicationError>;
+    readonly archiveThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
+    readonly startThread: (input: StartThreadInput, policy?: StartThreadPolicy) => Effect.Effect<{
+        readonly dispatch: DispatchResult;
+        readonly project: OrchestrationProjectShell;
+        readonly threadId: string;
+        readonly thread?: OrchestrationThread;
+    }, ApplicationError>;
+    readonly sendThread: (input: SendThreadInput, policy?: StartThreadPolicy) => Effect.Effect<{
+        readonly dispatch: DispatchResult;
+        readonly threadId: string;
+        readonly thread?: OrchestrationThread;
+    }, ApplicationError>;
+    readonly watchThread: (threadId: string) => Stream.Stream<WaitEvent, ApplicationError>;
+    readonly waitForThread: (threadId: string) => Effect.Effect<OrchestrationThread, ApplicationError>;
+}>;
+export declare class T3Application extends T3Application_base {
+}
+export {};

package/dist/src/application/shell-sequence.d.ts

@@ -0,0 +1,91 @@
+import * as Effect from "effect/Effect";
+import type { Orchestration } from "../orchestration/service.ts";
+import { RpcError } from "../rpc/error.ts";
+export declare function waitForShellSequence(input: {
+    readonly orchestration: Orchestration;
+    readonly sequence: number;
+}): Effect.Effect<{
+    readonly snapshotSequence: number;
+    readonly projects: readonly {
+        readonly id: string & import("effect/Brand").Brand<"ProjectId">;
+        readonly title: string;
+        readonly workspaceRoot: string;
+        readonly defaultModelSelection: {
+            readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+            readonly model: string;
+            readonly options?: readonly {
+                readonly id: string;
+                readonly value: string | boolean;
+            }[];
+        } | null;
+        readonly scripts: readonly {
+            readonly id: string;
+            readonly name: string;
+            readonly command: string;
+            readonly icon: "play" | "test" | "lint" | "configure" | "build" | "debug";
+            readonly runOnWorktreeCreate: boolean;
+        }[];
+        readonly createdAt: string;
+        readonly updatedAt: string;
+        readonly repositoryIdentity?: {
+            readonly canonicalKey: string;
+            readonly locator: {
+                readonly source: "git-remote";
+                readonly remoteName: string;
+                readonly remoteUrl: string;
+            };
+            readonly rootPath?: string;
+            readonly displayName?: string;
+            readonly provider?: string;
+            readonly owner?: string;
+            readonly name?: string;
+        } | null | undefined;
+    }[];
+    readonly threads: readonly {
+        readonly id: string & import("effect/Brand").Brand<"ThreadId">;
+        readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+        readonly title: string;
+        readonly modelSelection: {
+            readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+            readonly model: string;
+            readonly options?: readonly {
+                readonly id: string;
+                readonly value: string | boolean;
+            }[];
+        };
+        readonly runtimeMode: "approval-required" | "auto-accept-edits" | "full-access";
+        readonly interactionMode: "default" | "plan";
+        readonly branch: string | null;
+        readonly worktreePath: string | null;
+        readonly latestTurn: {
+            readonly turnId: string & import("effect/Brand").Brand<"TurnId">;
+            readonly state: "error" | "running" | "interrupted" | "completed";
+            readonly requestedAt: string;
+            readonly startedAt: string | null;
+            readonly completedAt: string | null;
+            readonly assistantMessageId: (string & import("effect/Brand").Brand<"MessageId">) | null;
+            readonly sourceProposedPlan?: {
+                readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+                readonly planId: string;
+            } | undefined;
+        } | null;
+        readonly createdAt: string;
+        readonly updatedAt: string;
+        readonly archivedAt: string | null;
+        readonly session: {
+            readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+            readonly status: "error" | "idle" | "starting" | "running" | "ready" | "interrupted" | "stopped";
+            readonly providerName: string | null;
+            readonly runtimeMode: "approval-required" | "auto-accept-edits" | "full-access";
+            readonly activeTurnId: (string & import("effect/Brand").Brand<"TurnId">) | null;
+            readonly lastError: string | null;
+            readonly updatedAt: string;
+            readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
+        } | null;
+        readonly latestUserMessageAt: string | null;
+        readonly hasPendingApprovals: boolean;
+        readonly hasPendingUserInput: boolean;
+        readonly hasActionableProposedPlan: boolean;
+    }[];
+    readonly updatedAt: string;
+}, RpcError, never>;

package/dist/src/application/thread-commands.d.ts

@@ -0,0 +1,84 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import { type ModelSelection, type OrchestrationProjectShell } from "#t3tools/contracts";
+import type { ServerConfigForCli } from "../orchestration/service.ts";
+import type { SendThreadInput, StartThreadInput } from "./service.ts";
+export declare const makeThreadStartCommands: (input: {
+    readonly start: StartThreadInput;
+    readonly project: OrchestrationProjectShell;
+    readonly serverConfig: ServerConfigForCli;
+}) => Effect.Effect<{
+    createCommand: {
+        type: "thread.create";
+        commandId: string & import("effect/Brand").Brand<"CommandId">;
+        threadId: string & import("effect/Brand").Brand<"ThreadId">;
+        projectId: string & import("effect/Brand").Brand<"ProjectId">;
+        title: string;
+        modelSelection: {
+            readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+            readonly model: string;
+            readonly options?: readonly {
+                readonly id: string;
+                readonly value: string | boolean;
+            }[];
+        };
+        runtimeMode: "full-access";
+        interactionMode: "default";
+        branch: null;
+        worktreePath: string | null;
+        createdAt: string;
+    };
+    turnCommand: {
+        type: "thread.turn.start";
+        commandId: string & import("effect/Brand").Brand<"CommandId">;
+        threadId: string & import("effect/Brand").Brand<"ThreadId">;
+        message: {
+            messageId: string & import("effect/Brand").Brand<"MessageId">;
+            role: "user";
+            text: string;
+            attachments: never[];
+        };
+        modelSelection: {
+            readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+            readonly model: string;
+            readonly options?: readonly {
+                readonly id: string;
+                readonly value: string | boolean;
+            }[];
+        };
+        titleSeed: string;
+        runtimeMode: "full-access";
+        interactionMode: "default";
+        createdAt: string;
+    };
+    threadId: string & import("effect/Brand").Brand<"ThreadId">;
+}, import("../domain/error.ts").ModelSelectionError, Crypto.Crypto>;
+export declare const makeThreadTurnContinueCommand: (input: SendThreadInput & {
+    readonly modelSelection?: ModelSelection;
+}) => Effect.Effect<{
+    createdAt: string;
+    modelSelection?: {
+        readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+        readonly model: string;
+        readonly options?: readonly {
+            readonly id: string;
+            readonly value: string | boolean;
+        }[];
+    };
+    type: "thread.turn.start";
+    commandId: string & import("effect/Brand").Brand<"CommandId">;
+    threadId: string & import("effect/Brand").Brand<"ThreadId">;
+    message: {
+        messageId: string & import("effect/Brand").Brand<"MessageId">;
+        role: "user";
+        text: string;
+        attachments: never[];
+    };
+    runtimeMode: "full-access";
+    interactionMode: "default";
+}, never, Crypto.Crypto>;
+export declare const makeThreadArchiveCommand: (threadId: string) => Effect.Effect<{
+    type: "thread.archive";
+    commandId: string & import("effect/Brand").Brand<"CommandId">;
+    threadId: string & import("effect/Brand").Brand<"ThreadId">;
+}, never, Crypto.Crypto>;

package/dist/src/application/thread-wait.d.ts

@@ -0,0 +1,104 @@
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import { ThreadSessionError } from "../domain/error.ts";
+import type { Orchestration } from "../orchestration/service.ts";
+import type { WaitEvent } from "./service.ts";
+export declare function watchThread(input: {
+    readonly orchestration: Orchestration;
+    readonly threadId: string;
+}): Stream.Stream<WaitEvent, ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
+export declare function waitForThread(input: {
+    readonly orchestration: Orchestration;
+    readonly threadId: string;
+}): Effect.Effect<{
+    readonly id: string & import("effect/Brand").Brand<"ThreadId">;
+    readonly projectId: string & import("effect/Brand").Brand<"ProjectId">;
+    readonly title: string;
+    readonly modelSelection: {
+        readonly instanceId: string & import("effect/Brand").Brand<"ProviderInstanceId">;
+        readonly model: string;
+        readonly options?: readonly {
+            readonly id: string;
+            readonly value: string | boolean;
+        }[];
+    };
+    readonly runtimeMode: "approval-required" | "auto-accept-edits" | "full-access";
+    readonly interactionMode: "default" | "plan";
+    readonly branch: string | null;
+    readonly worktreePath: string | null;
+    readonly latestTurn: {
+        readonly turnId: string & import("effect/Brand").Brand<"TurnId">;
+        readonly state: "error" | "running" | "interrupted" | "completed";
+        readonly requestedAt: string;
+        readonly startedAt: string | null;
+        readonly completedAt: string | null;
+        readonly assistantMessageId: (string & import("effect/Brand").Brand<"MessageId">) | null;
+        readonly sourceProposedPlan?: {
+            readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+            readonly planId: string;
+        } | undefined;
+    } | null;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly archivedAt: string | null;
+    readonly deletedAt: string | null;
+    readonly messages: readonly {
+        readonly id: string & import("effect/Brand").Brand<"MessageId">;
+        readonly role: "user" | "assistant" | "system";
+        readonly text: string;
+        readonly turnId: (string & import("effect/Brand").Brand<"TurnId">) | null;
+        readonly streaming: boolean;
+        readonly createdAt: string;
+        readonly updatedAt: string;
+        readonly attachments?: readonly {
+            readonly type: "image";
+            readonly id: string;
+            readonly name: string;
+            readonly mimeType: string;
+            readonly sizeBytes: number;
+        }[] | undefined;
+    }[];
+    readonly proposedPlans: readonly {
+        readonly id: string;
+        readonly turnId: (string & import("effect/Brand").Brand<"TurnId">) | null;
+        readonly planMarkdown: string;
+        readonly implementedAt: string | null;
+        readonly implementationThreadId: (string & import("effect/Brand").Brand<"ThreadId">) | null;
+        readonly createdAt: string;
+        readonly updatedAt: string;
+    }[];
+    readonly activities: readonly {
+        readonly id: string & import("effect/Brand").Brand<"EventId">;
+        readonly tone: "error" | "info" | "tool" | "approval";
+        readonly kind: string;
+        readonly summary: string;
+        readonly payload: unknown;
+        readonly turnId: (string & import("effect/Brand").Brand<"TurnId">) | null;
+        readonly createdAt: string;
+        readonly sequence?: number | undefined;
+    }[];
+    readonly checkpoints: readonly {
+        readonly turnId: string & import("effect/Brand").Brand<"TurnId">;
+        readonly checkpointTurnCount: number;
+        readonly checkpointRef: string & import("effect/Brand").Brand<"CheckpointRef">;
+        readonly status: "error" | "ready" | "missing";
+        readonly files: readonly {
+            readonly path: string;
+            readonly kind: string;
+            readonly additions: number;
+            readonly deletions: number;
+        }[];
+        readonly assistantMessageId: (string & import("effect/Brand").Brand<"MessageId">) | null;
+        readonly completedAt: string;
+    }[];
+    readonly session: {
+        readonly threadId: string & import("effect/Brand").Brand<"ThreadId">;
+        readonly status: "error" | "idle" | "starting" | "running" | "ready" | "interrupted" | "stopped";
+        readonly providerName: string | null;
+        readonly runtimeMode: "approval-required" | "auto-accept-edits" | "full-access";
+        readonly activeTurnId: (string & import("effect/Brand").Brand<"TurnId">) | null;
+        readonly lastError: string | null;
+        readonly updatedAt: string;
+        readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
+    } | null;
+}, ThreadSessionError | import("../rpc/error.ts").RpcError, never>;