t3code-cli 0.8.0 → 0.9.0

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

@@ -2,6 +2,17 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import { T3Application } from "./service.ts";
 export declare const makeT3Application: () => Effect.Effect<{
+    approveThread: (input: {
+        readonly threadId: string;
+        readonly requestId: string;
+        readonly decision: import("#t3tools/contracts").ProviderApprovalDecision;
+    }) => Effect.Effect<{
+        threadId: string;
+        requestId: string;
+        dispatch: {
+            readonly sequence: number;
+        };
+    }, import("../rpc/error.ts").RpcError, never>;
     archiveThread: (threadId: string) => Effect.Effect<{
         readonly sequence: number;
     }, import("../rpc/error.ts").RpcError, never>;
@@ -198,6 +209,17 @@ export declare const makeT3Application: () => Effect.Effect<{
             readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
         } | null;
     }, import("../rpc/error.ts").RpcError, never>;
+    respondToThread: (input: {
+        readonly threadId: string;
+        readonly requestId: string;
+        readonly answers: import("#t3tools/contracts").ProviderUserInputAnswers;
+    }) => Effect.Effect<{
+        threadId: string;
+        requestId: string;
+        dispatch: {
+            readonly sequence: number;
+        };
+    }, import("../rpc/error.ts").RpcError, never>;
     sendThread: (input: import("./service.ts").SendThreadInput, policy?: {
         readonly until: "dispatch" | "visible" | "complete";
     } | undefined) => Effect.Effect<{
@@ -313,6 +335,7 @@ export declare const makeT3Application: () => Effect.Effect<{
             } | null;
         };
     }, import("../domain/error.ts").ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
+    showThread: (threadId: string) => Effect.Effect<import("./threads.ts").ThreadShow, import("../rpc/error.ts").RpcError, never>;
     startThread: (startInput: import("./service.ts").StartThreadInput, policy?: {
         readonly until: "dispatch" | "visible" | "complete";
     } | undefined) => Effect.Effect<{
@@ -833,5 +856,5 @@ export declare const makeT3Application: () => Effect.Effect<{
             readonly output: string | null;
         };
     }[], import("../rpc/error.ts").RpcError, never>;
-}, never, import("../orchestration/service.ts").T3Orchestration | import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto>;
-export declare const T3ApplicationLive: Layer.Layer<T3Application, never, import("../orchestration/service.ts").T3Orchestration | import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto>;
+}, never, import("../environment/service.ts").Environment | import("../orchestration/service.ts").T3Orchestration | import("effect/Path").Path | import("effect/Crypto").Crypto>;
+export declare const T3ApplicationLive: Layer.Layer<T3Application, never, import("../environment/service.ts").Environment | import("../orchestration/service.ts").T3Orchestration | import("effect/Path").Path | import("effect/Crypto").Crypto>;

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

@@ -142,4 +142,4 @@ export declare const makeProjectApplication: () => Effect.Effect<{
             } | null | undefined;
         };
     }, ProjectCreateVisibilityError | import("../rpc/error.ts").RpcError, never>;
-}, never, T3Orchestration | Environment | Path.Path | Crypto.Crypto>;
+}, never, Environment | T3Orchestration | Path.Path | Crypto.Crypto>;

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

@@ -1,8 +1,9 @@
 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 { DispatchResult, ModelSelection, OrchestrationMessage, OrchestrationProjectShell, OrchestrationShellSnapshot, OrchestrationThread, OrchestrationThreadShell, ProviderUserInputAnswers, ServerProvider } from "#t3tools/contracts";
 import type { ApplicationError } from "./error.ts";
+import type { ThreadShow } from "./threads.ts";
 export type StartThreadInput = {
     readonly projectRef?: string;
     readonly message: string;
@@ -57,6 +58,25 @@ declare const T3Application_base: Context.ServiceClass<T3Application, "t3cli/T3A
         readonly threads: ReadonlyArray<OrchestrationThreadShell>;
     }, ApplicationError>;
     readonly getThreadMessages: (threadId: string) => Effect.Effect<OrchestrationThread, ApplicationError>;
+    readonly showThread: (threadId: string) => Effect.Effect<ThreadShow, ApplicationError>;
+    readonly approveThread: (input: {
+        readonly threadId: string;
+        readonly requestId: string;
+        readonly decision: "accept" | "decline" | "cancel";
+    }) => Effect.Effect<{
+        readonly threadId: string;
+        readonly requestId: string;
+        readonly dispatch: DispatchResult;
+    }, ApplicationError>;
+    readonly respondToThread: (input: {
+        readonly threadId: string;
+        readonly requestId: string;
+        readonly answers: ProviderUserInputAnswers;
+    }) => Effect.Effect<{
+        readonly threadId: string;
+        readonly requestId: string;
+        readonly dispatch: DispatchResult;
+    }, ApplicationError>;
     readonly archiveThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
     readonly startThread: (input: StartThreadInput, policy?: StartThreadPolicy) => Effect.Effect<{
         readonly dispatch: DispatchResult;

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

@@ -1,6 +1,6 @@
 import * as Crypto from "effect/Crypto";
 import * as Effect from "effect/Effect";
-import { type ModelSelection, type OrchestrationProjectShell } from "#t3tools/contracts";
+import { type ModelSelection, type OrchestrationProjectShell, type ProviderApprovalDecision, type ProviderUserInputAnswers } from "#t3tools/contracts";
 import type { ServerConfigForCli } from "../orchestration/service.ts";
 import type { SendThreadInput, StartThreadInput } from "./service.ts";
 export declare const makeThreadStartCommands: (input: {
@@ -82,3 +82,29 @@ export declare const makeThreadArchiveCommand: (threadId: string) => Effect.Effe
     commandId: string & import("effect/Brand").Brand<"CommandId">;
     threadId: string & import("effect/Brand").Brand<"ThreadId">;
 }, never, Crypto.Crypto>;
+export declare const makeThreadApprovalRespondCommand: (input: {
+    readonly threadId: string;
+    readonly requestId: string;
+    readonly decision: ProviderApprovalDecision;
+}) => Effect.Effect<{
+    type: "thread.approval.respond";
+    commandId: string & import("effect/Brand").Brand<"CommandId">;
+    threadId: string & import("effect/Brand").Brand<"ThreadId">;
+    requestId: string & import("effect/Brand").Brand<"ApprovalRequestId">;
+    decision: "accept" | "acceptForSession" | "decline" | "cancel";
+    createdAt: string;
+}, never, Crypto.Crypto>;
+export declare const makeThreadUserInputRespondCommand: (input: {
+    readonly threadId: string;
+    readonly requestId: string;
+    readonly answers: ProviderUserInputAnswers;
+}) => Effect.Effect<{
+    type: "thread.user-input.respond";
+    commandId: string & import("effect/Brand").Brand<"CommandId">;
+    threadId: string & import("effect/Brand").Brand<"ThreadId">;
+    requestId: string & import("effect/Brand").Brand<"ApprovalRequestId">;
+    answers: {
+        readonly [x: string]: unknown;
+    };
+    createdAt: string;
+}, never, Crypto.Crypto>;

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

@@ -6,7 +6,22 @@ import { T3Orchestration } from "../orchestration/service.ts";
 import { ProjectLookupError, ThreadSessionError } from "../domain/error.ts";
 import { type StartThreadInput } from "./service.ts";
 import type { SendThreadInput, CallbackThreadInput } from "./service.ts";
+import { derivePendingApprovals, derivePendingUserInputs } from "../domain/thread-activities.ts";
+import { type ThreadLifecycleStatus } from "../domain/thread-lifecycle.ts";
+import type { OrchestrationThread } from "#t3tools/contracts";
+import type { ProviderApprovalDecision, ProviderUserInputAnswers } from "#t3tools/contracts";
 export declare const makeThreadApplication: () => Effect.Effect<{
+    approveThread: (input: {
+        readonly threadId: string;
+        readonly requestId: string;
+        readonly decision: ProviderApprovalDecision;
+    }) => Effect.Effect<{
+        threadId: string;
+        requestId: string;
+        dispatch: {
+            readonly sequence: number;
+        };
+    }, import("../rpc/error.ts").RpcError, never>;
     archiveThread: (threadId: string) => Effect.Effect<{
         readonly sequence: number;
     }, import("../rpc/error.ts").RpcError, never>;
@@ -203,6 +218,17 @@ export declare const makeThreadApplication: () => Effect.Effect<{
             readonly providerInstanceId?: (string & import("effect/Brand").Brand<"ProviderInstanceId">) | undefined;
         } | null;
     }, import("../rpc/error.ts").RpcError, never>;
+    respondToThread: (input: {
+        readonly threadId: string;
+        readonly requestId: string;
+        readonly answers: ProviderUserInputAnswers;
+    }) => Effect.Effect<{
+        threadId: string;
+        requestId: string;
+        dispatch: {
+            readonly sequence: number;
+        };
+    }, import("../rpc/error.ts").RpcError, never>;
     sendThread: (input: SendThreadInput, policy?: {
         readonly until: "dispatch" | "visible" | "complete";
     } | undefined) => Effect.Effect<{
@@ -318,6 +344,7 @@ export declare const makeThreadApplication: () => Effect.Effect<{
             } | null;
         };
     }, ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
+    showThread: (threadId: string) => Effect.Effect<ThreadShow, import("../rpc/error.ts").RpcError, never>;
     startThread: (startInput: StartThreadInput, policy?: {
         readonly until: "dispatch" | "visible" | "complete";
     } | undefined) => Effect.Effect<{
@@ -611,4 +638,26 @@ export declare const makeThreadApplication: () => Effect.Effect<{
         };
         targetThreadId: string;
     }, ThreadSessionError | import("../rpc/error.ts").RpcError, never>;
-}, never, T3Orchestration | Environment | Path.Path | Crypto.Crypto>;
+}, never, Environment | T3Orchestration | Path.Path | Crypto.Crypto>;
+export type ThreadShow = {
+    readonly id: string;
+    readonly projectId: string;
+    readonly title: string;
+    readonly status: ThreadLifecycleStatus;
+    readonly session: OrchestrationThread["session"];
+    readonly latestTurn: OrchestrationThread["latestTurn"];
+    readonly modelSelection: OrchestrationThread["modelSelection"];
+    readonly runtimeMode: OrchestrationThread["runtimeMode"];
+    readonly interactionMode: OrchestrationThread["interactionMode"];
+    readonly branch: OrchestrationThread["branch"];
+    readonly worktreePath: OrchestrationThread["worktreePath"];
+    readonly archivedAt: OrchestrationThread["archivedAt"];
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly messageCount: number;
+    readonly hasPendingApprovals: boolean;
+    readonly hasPendingUserInput: boolean;
+    readonly hasActionableProposedPlan: boolean;
+    readonly pendingApprovals: ReturnType<typeof derivePendingApprovals>;
+    readonly pendingUserInputs: ReturnType<typeof derivePendingUserInputs>;
+};

package/dist/src/domain/thread-activities.d.ts

@@ -0,0 +1,14 @@
+import { ApprovalRequestId, type OrchestrationThreadActivity, type UserInputQuestion } from "#t3tools/contracts";
+export type PendingApproval = {
+    readonly requestId: ApprovalRequestId;
+    readonly requestKind: "command" | "file-read" | "file-change";
+    readonly createdAt: string;
+    readonly detail?: string;
+};
+export type PendingUserInput = {
+    readonly requestId: ApprovalRequestId;
+    readonly createdAt: string;
+    readonly questions: ReadonlyArray<UserInputQuestion>;
+};
+export declare function derivePendingApprovals(activities: ReadonlyArray<OrchestrationThreadActivity>): ReadonlyArray<PendingApproval>;
+export declare function derivePendingUserInputs(activities: ReadonlyArray<OrchestrationThreadActivity>): ReadonlyArray<PendingUserInput>;

package/dist/src/domain/thread-lifecycle.d.ts

@@ -1,5 +1,6 @@
 import { type OrchestrationEvent, type OrchestrationMessage as OrchestrationMessageType, type OrchestrationThread, type OrchestrationThreadShell } from "#t3tools/contracts";
 export declare function isThreadActive(thread: OrchestrationThreadShell | OrchestrationThread): boolean;
+export type ThreadLifecycleStatus = ReturnType<typeof threadStatus>;
 export declare function threadStatus(thread: OrchestrationThreadShell | OrchestrationThread): "unknown" | "error" | "idle" | "starting" | "running" | "ready" | "interrupted" | "stopped" | "completed" | "pending";
 export declare function latestAssistantMessage(thread: OrchestrationThread): {
     readonly id: string & import("effect/Brand").Brand<"MessageId">;

package/dist/src/runtime/layer.d.ts

@@ -8,4 +8,4 @@ export declare const T3AuthPairingLayer: Layer.Layer<import("../auth/pairing.ts"
 export declare const T3AuthLayer: Layer.Layer<import("../auth/service.ts").T3Auth, never, import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("effect/FileSystem").FileSystem>;
 export declare const T3OrchestrationLayer: Layer.Layer<import("../orchestration/service.ts").T3Orchestration, never, import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/FileSystem").FileSystem>;
 export declare const AuthAppLayer: Layer.Layer<T3Config | import("../auth/service.ts").T3Auth, never, import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("effect/FileSystem").FileSystem>;
-export declare const AppLayer: Layer.Layer<import("../index.ts").T3Application | import("../orchestration/service.ts").T3Orchestration | T3Config | import("../auth/service.ts").T3Auth | import("../rpc/service.ts").T3Rpc | import("../cli-path/service.ts").CliPath, never, import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("effect/FileSystem").FileSystem>;
+export declare const AppLayer: Layer.Layer<import("../orchestration/service.ts").T3Orchestration | import("../index.ts").T3Application | T3Config | import("../auth/service.ts").T3Auth | import("../rpc/service.ts").T3Rpc | import("../cli-path/service.ts").CliPath, never, import("../environment/service.ts").Environment | import("effect/Path").Path | import("effect/Crypto").Crypto | import("effect/FileSystem").FileSystem>;

package/dist/t3tools.js

@@ -1,2 +1,2 @@
-import { $ as WsVcsRefreshStatusRpc, $a as DesktopSshPasswordPromptCancelledResultSchema, $c as ProviderOptionDescriptorType, $i as ThreadTokenUsageSnapshot, $l as ExecutionEnvironmentPlatformOs, $n as ServerLifecycleStreamReadyEvent, $o as EnvironmentScopeRequiredError, $r as DEFAULT_SIDEBAR_PROJECT_SORT_ORDER, $s as PROVIDER_SEND_TURN_MAX_ATTACHMENTS, $t as VcsStatusResult, $u as EnvironmentId, A as WsServerUpsertKeybindingRpc, Aa as TerminalSummary, Ac as ThreadMetaUpdatedPayload, Ai as KeybindingsConfig, An as VcsListRemotesResult, Ao as EnvironmentAuthInvalidReason, Ar as ServerSignalProcessInput, As as OrchestrationMessageRole, At as GitPreparePullRequestThreadInput, Au as AuthPairingCredentialResult, B as WsSubscribeVcsStatusRpc, Ba as DesktopRuntimeArchSchema, Bc as ThreadTurnStartRequestedPayload, Bi as ResolvedKeybindingsConfig, Bn as ServerConfig, Bo as EnvironmentHttpCommonError, Br as ServerUpsertKeybindingResult, Bs as OrchestrationSessionStatus, Bt as VcsCreateRefResult, Bu as AuthTokenExchangeGrantType, C as WsServerGetSettingsRpc, Ca as TerminalNotRunningError, Cc as ThreadDeletedPayload, Ci as LaunchEditorInput, Cn as SourceControlRepositoryVisibility, Co as RelayClientInstallProgressStageSchema, Cr as ServerProviderUpdateStatus, Cs as OrchestrationGetFullThreadDiffResult, Ct as GitActionProgressEvent, Cu as AuthClientSession, D as WsServerSignalProcessRpc, Da as TerminalSessionLookupError, Dc as ThreadGoalUpdatedPayload, Di as KeybindingValue, Dn as VcsError, Do as AuthPairingLinkRevokeResult, Dr as ServerProviders, Ds as OrchestrationGetTurnDiffResult, Dt as GitCommandError, Du as AuthEnvironmentScopes, E as WsServerRemoveKeybindingRpc, Ea as TerminalRestartInput, Ec as ThreadGoalRequestedPayload, Ei as KeybindingShortcut, En as VcsDriverKind, Eo as AuthOtherClientSessionsRevokeResult, Er as ServerProviderVersionAdvisoryStatus, Es as OrchestrationGetTurnDiffInput, Et as GitActionProgressStream, Eu as AuthEnvironmentScope, F as WsSubscribeAuthAccessRpc, Fa as DesktopAppStageLabelSchema, Fc as ThreadSessionStopRequestedPayload, Fi as MAX_SCRIPT_ID_LENGTH, Fn as VcsProcessTimeoutError, Fo as EnvironmentCloudPreferencesRequest, Fr as ServerTraceDiagnosticsRecentFailure, Fs as OrchestrationReadModel, Ft as GitRunStackedActionResult, Fu as AuthRevokeClientSessionInput, G as WsTerminalResizeRpc, Ga as DesktopSshBearerRequestInputSchema, Gc as DEFAULT_GIT_TEXT_GENERATION_MODEL_BY_PROVIDER, Gi as CanonicalRequestType, Gn as ServerConfigStreamEvent, Go as EnvironmentInternalError, Gr as CodexSettings, Gs as OrchestrationThread, Gt as VcsListRefsResult, Gu as ServerAuthDescriptor, H as WsTerminalClearRpc, Ha as DesktopServerExposureModeSchema, Hc as TurnCountRange, Hi as THREAD_JUMP_KEYBINDING_COMMANDS, Hn as ServerConfigKeybindingsUpdatedPayload, Ho as EnvironmentHttpForbiddenError, Hr as ClaudeSettings, Hs as OrchestrationShellStreamEvent, Ht as VcsCreateWorktreeResult, Hu as AuthWebSocketTicketResult, I as WsSubscribeServerConfigRpc, Ia as DesktopCloudAuthFetchInputSchema, Ic as ThreadTurnDiff, Ii as MAX_WHEN_EXPRESSION_DEPTH, In as VcsRemote, Io as EnvironmentCloudRelayConfigResult, Ir as ServerTraceDiagnosticsResult, Is as OrchestrationReplayEventsError, It as GitRunStackedActionToastRunAction, Iu as AuthRevokePairingLinkInput, J as WsVcsCreateRefRpc, Ja as DesktopSshEnvironmentEnsureOptionsSchema, Jc as MODEL_SLUG_ALIASES_BY_PROVIDER, Ji as ProviderRuntimeEventV2, Jl as EnvironmentConnectionState, Jn as ServerConfigStreamSettingsUpdatedEvent, Jo as EnvironmentOperationForbiddenError, Jr as DEFAULT_AUTOMATIC_GIT_FETCH_INTERVAL, Js as OrchestrationThreadDetailSnapshot, Jt as VcsRef, K as WsTerminalRestartRpc, Ka as DesktopSshEnvironmentBootstrapSchema, Kc as DEFAULT_MODEL, Ki as ItemLifecyclePayload, Kn as ServerConfigStreamKeybindingsUpdatedEvent, Ko as EnvironmentInternalErrorReason, Kr as ContextMenuStyle, Ks as OrchestrationThreadActivity, Kt as VcsPullInput, Ku as ServerAuthPolicy, L as WsSubscribeServerLifecycleRpc, La as DesktopCloudAuthFetchResultSchema, Lc as ThreadTurnDiffCompletedPayload, Li as MODEL_PICKER_JUMP_KEYBINDING_COMMANDS, Ln as VcsRepositoryDetectionError, Lo as EnvironmentConnectHttpApi, Lr as ServerTraceDiagnosticsSpanOccurrence, Ls as OrchestrationReplayEventsInput, Lt as GitStackedAction, Lu as AuthSessionState, M as WsSourceControlCloneRepositoryRpc, Ma as TerminalWriteInput, Mc as ThreadRevertedPayload, Mi as MAX_KEYBINDINGS_COUNT, Mn as VcsOutputDecodeError, Mo as EnvironmentAuthenticatedPrincipal, Mr as ServerTraceDiagnosticsErrorKind, Ms as OrchestrationProjectShell, Mt as GitPullRequestRefInput, Mu as AuthRelayReadScope, N as WsSourceControlLookupRepositoryRpc, Na as ContextMenuItemSchema, Nc as ThreadRuntimeModeSetPayload, Ni as MAX_KEYBINDING_VALUE_LENGTH, Nn as VcsProcessExitError, No as EnvironmentCloudEndpointUnavailableError, Nr as ServerTraceDiagnosticsFailureSummary, Ns as OrchestrationProposedPlan, Nt as GitResolvePullRequestResult, Nu as AuthRelayWriteScope, O as WsServerUpdateProviderRpc, Oa as TerminalSessionSnapshot, Oc as ThreadInteractionModeSetPayload, Oi as KeybindingWhen, On as VcsFreshness, Oo as EnvironmentAuthHttpApi, Or as ServerRemoveKeybindingInput, Os as OrchestrationLatestTurn, Ot as GitManagerError, Ou as AuthOrchestrationOperateScope, P as WsSourceControlPublishRepositoryRpc, Pa as DesktopAppBrandingSchema, Pc as ThreadSessionSetPayload, Pi as MAX_KEYBINDING_WHEN_LENGTH, Pn as VcsProcessSpawnError, Po as EnvironmentCloudLinkStateResult, Pr as ServerTraceDiagnosticsLogEvent, Ps as OrchestrationProposedPlanId, Pt as GitRunStackedActionInput, Pu as AuthReviewWriteScope, Q as WsVcsPullRpc, Qa as DesktopSshHttpBaseUrlInputSchema, Qc as ProviderOptionDescriptor, Qi as TOOL_LIFECYCLE_ITEM_TYPES, Ql as ExecutionEnvironmentPlatformArch, Qn as ServerLifecycleStreamEvent, Qo as EnvironmentRequestInvalidReason, Qr as DEFAULT_SIDEBAR_PROJECT_GROUPING_MODE, Qs as OrchestrationThreadStreamItem, Qt as VcsStatusRemoteResult, Qu as CommandId, R as WsSubscribeTerminalEventsRpc, Ra as DesktopDiscoveredSshHostSchema, Rc as ThreadTurnInterruptRequestedPayload, Ri as MODEL_PICKER_KEYBINDING_COMMANDS, Rn as VcsRepositoryIdentity, Ro as EnvironmentHttpApi, Rr as ServerTraceDiagnosticsSpanSummary, Rs as OrchestrationRpcSchemas, Rt as TextGenerationError, Ru as AuthStandardClientScopes, S as WsServerGetProcessResourceHistoryRpc, Sa as TerminalMetadataStreamEvent, Sc as ThreadCreatedPayload, Si as ExternalLauncherError, Sn as SourceControlRepositoryLookupInput, So as RelayClientInstallProgressEventSchema, Sr as ServerProviderUpdateState, Ss as OrchestrationGetFullThreadDiffInput, St as ProjectWriteFileResult, Su as AuthClientPresentationMetadata, T as WsServerRefreshProvidersRpc, Ta as TerminalResizeInput, Tc as ThreadGoalRequest, Ti as KeybindingRule, Tn as VcsDriverCapabilities, To as AuthClientSessionRevokeResult, Tr as ServerProviderVersionAdvisory, Ts as OrchestrationGetTurnDiffError, Tt as GitActionProgressPhase, Tu as AuthEnvironmentBootstrapTokenType, U as WsTerminalCloseRpc, Ua as DesktopServerExposureStateSchema, Uc as BooleanProviderOptionDescriptor, Ui as THREAD_KEYBINDING_COMMANDS, Un as ServerConfigProviderStatusesPayload, Uo as EnvironmentHttpInternalServerError, Ur as ClientSettingsPatch, Us as OrchestrationShellStreamItem, Ut as VcsInitInput, Uu as EnvironmentAuthorizationError, V as WsTerminalAttachRpc, Va as DesktopRuntimeInfoSchema, Vc as ThreadUnarchivedPayload, Vi as SCRIPT_RUN_COMMAND_PATTERN, Vn as ServerConfigIssue, Vo as EnvironmentHttpConflictError, Vr as isProviderAvailable, Vs as OrchestrationShellSnapshot, Vt as VcsCreateWorktreeInput, Vu as AuthTokenExchangeRequest, W as WsTerminalOpenRpc, Wa as DesktopSshBearerBootstrapInputSchema, Wc as DEFAULT_GIT_TEXT_GENERATION_MODEL, Wi as CanonicalItemType, Wn as ServerConfigSettingsUpdatedPayload, Wo as EnvironmentHttpUnauthorizedError, Wr as ClientSettingsSchema, Ws as OrchestrationSubscribeThreadInput, Wt as VcsListRefsInput, Wu as ServerAuthBootstrapMethod, X as WsVcsInitRpc, Xa as DesktopSshEnvironmentTargetSchema, Xc as PROVIDER_DISPLAY_NAMES, Xi as ProviderRuntimeTurnStatus, Xl as ExecutionEnvironmentDescriptor, Xn as ServerConfigUpdatedPayload, Xo as EnvironmentOrchestrationHttpApi, Xr as DEFAULT_CONTEXT_MENU_STYLE, Xs as OrchestrationThreadGoalStatus, Xt as VcsStatusInput, Xu as AuthSessionId, Y as WsVcsCreateWorktreeRpc, Ya as DesktopSshEnvironmentEnsureResultSchema, Yc as ModelCapabilities, Yi as ProviderRuntimeThreadGoalStatus, Yl as ExecutionEnvironmentCapabilities, Yn as ServerConfigStreamSnapshotEvent, Yo as EnvironmentOperationForbiddenReason, Yr as DEFAULT_CLIENT_SETTINGS, Ys as OrchestrationThreadGoal, Yt as VcsRemoveWorktreeInput, Yu as ApprovalRequestId, Z as WsVcsListRefsRpc, Za as DesktopSshHostSourceSchema, Zc as ProviderOptionChoice, Zi as RuntimeEventRaw, Zl as ExecutionEnvironmentPlatform, Zn as ServerLifecycleReadyPayload, Zo as EnvironmentRequestInvalidError, Zr as DEFAULT_SERVER_SETTINGS, Zs as OrchestrationThreadShell, Zt as VcsStatusLocalResult, Zu as CheckpointRef, _ as WsReviewGetDiffPreviewRpc, _a as TerminalCloseInput, _c as RuntimeMode, _i as TimestampFormat, _n as SourceControlPublishRepositoryResult, _o as AdvertisedEndpointSource, _r as ServerProviderSlashCommand, _s as OrchestrationDispatchCommandError, _t as ProjectSearchEntriesError, _u as AuthAdministrativeScopes, a as WsGitPreparePullRequestThreadRpc, aa as ProviderInterruptTurnInput, ac as ProjectMetaUpdatedPayload, ad as PositiveInt, ai as MAX_SIDEBAR_THREAD_PREVIEW_COUNT, al as ProviderInstanceConfig, an as SourceControlCloneProtocol, ao as DesktopUpdateChannelSchema, ar as ServerProcessResourceHistoryBucket, as as DEFAULT_PROVIDER_INTERACTION_MODE, au as AuthAccessReadScope, b as WsServerGetConfigRpc, ba as TerminalEvent, bc as ThreadArchivedPayload, bi as EditorId, bn as SourceControlRepositoryError, bo as RelayClientInstallFailedError, br as ServerProviderUpdateError, bs as OrchestrationEventType, bt as ProjectWriteFileError, bu as AuthClientMetadata, c as WsOrchestrationDispatchCommandRpc, ca as ProviderSendTurnInput, cc as ProjectionPendingApprovalDecision, cd as RuntimeItemId, ci as OpenCodeSettings, cl as ProviderInstanceEnvironmentVariable, cn as SourceControlDiscoveryResult, co as DesktopUpdateStatusSchema, cr as ServerProcessResourceHistorySummary, cs as ModelSelection, ct as ReviewDiffPreviewInput, cu as AuthAccessStreamClientUpsertedEvent, d as WsOrchestrationGetTurnDiffRpc, da as ProviderStopSessionInput, dc as ProviderApprovalPolicy, dd as RuntimeTaskId, di as ServerSettingsPatch, dl as ProviderInstanceRef, dn as SourceControlProviderAuthStatus, do as AdvertisedEndpoint, dr as ServerProviderAuth, ds as OrchestrationAggregateKind, dt as ReviewDiffPreviewSourceKind, du as AuthAccessStreamPairingLinkRemovedEvent, ea as ToolLifecycleItemType, ec as PROVIDER_SEND_TURN_MAX_IMAGE_BYTES, ed as EventId, ei as DEFAULT_SIDEBAR_THREAD_PREVIEW_COUNT, el as ProviderOptionSelection, en as VcsStatusStreamEvent, eo as DesktopSshPasswordPromptCancelledType, er as ServerLifecycleStreamWelcomeEvent, es as AssistantDeliveryMode, et as WsVcsRemoveWorktreeRpc, eu as RepositoryIdentity, f as WsOrchestrationReplayEventsRpc, fa as ProviderTurnStartResult, fc as ProviderInteractionMode, fd as ThreadId, fi as SidebarProjectGroupingMode, fl as defaultInstanceIdForDriver, fn as SourceControlProviderDiscoveryItem, fo as AdvertisedEndpointCompatibility, fr as ServerProviderAuthStatus, fs as OrchestrationCheckpointFile, ft as FilesystemBrowseEntry, fu as AuthAccessStreamPairingLinkUpsertedEvent, g as WsProjectsWriteFileRpc, ga as TerminalClearInput, gc as ProviderUserInputAnswers, gi as ThreadEnvMode, gn as SourceControlPublishRepositoryInput, go as AdvertisedEndpointReachability, gr as ServerProviderSkill, gs as OrchestrationCommandReceiptStatus, gt as ProjectEntry, gu as AuthAccessWriteScope, h as WsProjectsSearchEntriesRpc, ha as TerminalAttachStreamEvent, hc as ProviderSessionRuntimeStatus, hd as TurnId, hi as SidebarThreadSortOrder, hn as SourceControlProviderKind, ho as AdvertisedEndpointProviderKind, hr as ServerProviderModel, hs as OrchestrationCommand, ht as FilesystemBrowseResult, hu as AuthAccessTokenType, i as WsFilesystemBrowseRpc, ia as ProviderGoalRequestInput, ic as ProjectDeletedPayload, id as PortSchema, ii as GrokSettings, il as ProviderDriverKind, in as ChangeRequestState, io as DesktopUpdateActionResultSchema, ir as ServerProcessDiagnosticsResult, is as CorrelationId, iu as ScopedThreadSessionRef, j as WsShellOpenInEditorRpc, ja as TerminalThreadInput, jc as ThreadProposedPlanUpsertedPayload, ji as KeybindingsConfigError, jn as VcsListWorkspaceFilesResult, jo as EnvironmentAuthenticatedAuth, jr as ServerSignalProcessResult, js as OrchestrationProject, jt as GitPreparePullRequestThreadResult, ju as AuthPairingLink, k as WsServerUpdateSettingsRpc, ka as TerminalSessionStatus, kc as ThreadMessageSentPayload, ki as KeybindingWhenNode, kn as VcsFreshnessSource, ko as EnvironmentAuthInvalidError, kr as ServerRemoveKeybindingResult, ks as OrchestrationMessage, kt as GitManagerServiceError, ku as AuthOrchestrationReadScope, l as WsOrchestrationGetArchivedShellSnapshotRpc, la as ProviderSession, lc as ProjectionPendingApprovalStatus, ld as RuntimeRequestId, li as ServerSettings, ll as ProviderInstanceEnvironmentVariableName, ln as SourceControlDiscoveryStatus, lo as PersistedSavedEnvironmentRecordSchema, lr as ServerProcessSignal, ls as ORCHESTRATION_WS_METHODS, lt as ReviewDiffPreviewResult, lu as AuthAccessStreamError, m as WsOrchestrationSubscribeThreadRpc, ma as TerminalAttachInput, mc as ProviderSandboxMode, md as TrimmedString, mi as SidebarThreadPreviewCount, mn as SourceControlProviderInfo, mo as AdvertisedEndpointProvider, mr as ServerProviderContinuation, ms as OrchestrationCheckpointSummary, mt as FilesystemBrowseInput, mu as AuthAccessTokenResult, n as WsCloudGetRelayClientStatusRpc, na as isToolLifecycleItemType, nc as ProjectCreateCommand, nd as MessageId, ni as DEFAULT_TIMESTAMP_FORMAT, nl as ProviderOptionSelections, nn as VcsSwitchRefResult, no as DesktopSshPasswordPromptResolutionInputSchema, nr as ServerObservability, ns as ChatImageAttachment, nu as ScopedProjectRef, o as WsGitResolvePullRequestRpc, oa as ProviderRespondToRequestInput, oc as ProjectScript, od as ProjectId, oi as MIN_SIDEBAR_THREAD_PREVIEW_COUNT, ol as ProviderInstanceConfigMap, on as SourceControlCloneRepositoryInput, oo as DesktopUpdateCheckResultSchema, or as ServerProcessResourceHistoryInput, os as DEFAULT_RUNTIME_MODE, ou as AuthAccessSnapshot, p as WsOrchestrationSubscribeShellRpc, pa as DEFAULT_TERMINAL_ID, pc as ProviderRequestKind, pd as TrimmedNonEmptyString, pi as SidebarProjectSortOrder, pl as isProviderDriverKind, pn as SourceControlProviderError, po as AdvertisedEndpointHostedHttpsCompatibility, pr as ServerProviderAvailability, ps as OrchestrationCheckpointStatus, pt as FilesystemBrowseError, pu as AuthAccessStreamSnapshotEvent, q as WsTerminalWriteRpc, qa as DesktopSshEnvironmentEnsureInputSchema, qc as DEFAULT_MODEL_BY_PROVIDER, qi as ProviderRuntimeEvent, qn as ServerConfigStreamProviderStatusesEvent, qo as EnvironmentMetadataHttpApi, qr as CursorSettings, qs as OrchestrationThreadActivityTone, qt as VcsPullResult, qu as ServerAuthSessionMethod, r as WsCloudInstallRelayClientRpc, ra as ProviderEvent, rc as ProjectCreatedPayload, rd as NonNegativeInt, ri as DEFAULT_UNIFIED_SETTINGS, rl as SelectProviderOptionDescriptor, rn as ChangeRequest, ro as DesktopThemeSchema, rr as ServerProcessDiagnosticsEntry, rs as ClientOrchestrationCommand, ru as ScopedThreadRef, s as WsGitRunStackedActionRpc, sa as ProviderRespondToUserInputInput, sc as ProjectScriptIcon, sd as ProviderItemId, si as ObservabilitySettings, sl as ProviderInstanceEnvironment, sn as SourceControlCloneRepositoryResult, so as DesktopUpdateStateSchema, sr as ServerProcessResourceHistoryResult, ss as DispatchResult, st as ReviewDiffPreviewError, su as AuthAccessStreamClientRemovedEvent, t as WS_METHODS, ta as UserInputQuestion, tc as PROVIDER_SEND_TURN_MAX_INPUT_CHARS, td as IsoDateTime, ti as DEFAULT_SIDEBAR_THREAD_SORT_ORDER, tl as ProviderOptionSelectionValue, tn as VcsSwitchRefInput, to as DesktopSshPasswordPromptRequestSchema, tr as ServerLifecycleWelcomePayload, ts as ChatAttachment, tt as WsVcsSwitchRefRpc, tu as RepositoryIdentityLocator, u as WsOrchestrationGetFullThreadDiffRpc, ua as ProviderSessionStartInput, uc as ProviderApprovalDecision, ud as RuntimeSessionId, ui as ServerSettingsError, ul as ProviderInstanceId, un as SourceControlProviderAuth, uo as PickFolderOptionsSchema, ur as ServerProvider, us as OrchestrationActorKind, ut as ReviewDiffPreviewSource, uu as AuthAccessStreamEvent, v as WsRpcGroup, va as TerminalCwdError, vc as ThreadActivityAppendedPayload, vi as makeProviderSettingsSchema, vn as SourceControlPublishStatus, vo as AdvertisedEndpointStatus, vr as ServerProviderSlashCommandInput, vs as OrchestrationEvent, vt as ProjectSearchEntriesInput, vu as AuthBrowserSessionRequest, w as WsServerGetTraceDiagnosticsRpc, wa as TerminalOpenInput, wc as ThreadGoalClearedPayload, wi as KeybindingCommand, wn as VcsDiscoveryItem, wo as RelayClientStatusSchema, wr as ServerProviderUpdatedPayload, ws as OrchestrationGetSnapshotError, wt as GitActionProgressKind, wu as AuthCreatePairingCredentialInput, x as WsServerGetProcessDiagnosticsRpc, xa as TerminalHistoryError, xc as ThreadCheckpointRevertRequestedPayload, xi as EditorLaunchStyle, xn as SourceControlRepositoryInfo, xo as RelayClientInstallFailureReasonSchema, xr as ServerProviderUpdateInput, xs as OrchestrationGetFullThreadDiffError, xt as ProjectWriteFileInput, xu as AuthClientMetadataDeviceType, y as WsServerDiscoverSourceControlRpc, ya as TerminalError, yc as ThreadApprovalResponseRequestedPayload, yi as EDITORS, yn as SourceControlRepositoryCloneUrls, yo as DesktopBackendBootstrap, yr as ServerProviderState, ys as OrchestrationEventMetadata, yt as ProjectSearchEntriesResult, yu as AuthBrowserSessionResult, z as WsSubscribeTerminalMetadataRpc, za as DesktopEnvironmentBootstrapSchema, zc as ThreadTurnStartCommand, zi as ResolvedKeybindingRule, zn as VcsUnsupportedOperationError, zo as EnvironmentHttpBadRequestError, zr as ServerUpsertKeybindingInput, zs as OrchestrationSession, zt as VcsCreateRefInput, zu as AuthTerminalOperateScope } from "./src-aiFPmAG7.js";
+import { $ as WsCloudInstallRelayClientRpc, $a as ProviderSendTurnInput, $c as ProjectionPendingApprovalDecision, $i as OpenCodeSettings, $l as ProviderInstanceEnvironmentVariable, $n as SourceControlDiscoveryResult, $o as DesktopUpdateStatusSchema, $r as ServerProcessResourceHistorySummary, $s as ModelSelection, $t as ReviewDiffPreviewInput, $u as AuthWebSocketTicketResult, Aa as ResolvedKeybindingRule, Ac as OrchestrationSession, Ai as ServerUpsertKeybindingInput, Al as ThreadTurnStartCommand, An as VcsCreateRefInput, Ao as DesktopEnvironmentBootstrapSchema, Ar as VcsUnsupportedOperationError, As as EnvironmentHttpBadRequestError, At as WsSourceControlPublishRepositoryRpc, Au as AuthBrowserSessionResult, Ba as ProviderRuntimeThreadGoalStatus, Bc as OrchestrationThreadGoal, Bi as DEFAULT_CLIENT_SETTINGS, Bl as ModelCapabilities, Bn as VcsRemoveWorktreeInput, Bo as DesktopSshEnvironmentEnsureResultSchema, Br as ServerConfigStreamSnapshotEvent, Bs as EnvironmentOperationForbiddenReason, Bt as WsTerminalOpenRpc, Bu as AuthOrchestrationReadScope, Ca as MAX_KEYBINDINGS_COUNT, Cc as OrchestrationProjectShell, Cd as TrimmedNonEmptyString, Ci as ServerTraceDiagnosticsErrorKind, Cl as ThreadRevertedPayload, Cn as GitPullRequestRefInput, Co as TerminalWriteInput, Cr as VcsOutputDecodeError, Cs as EnvironmentAuthenticatedPrincipal, Ct as WsServerSignalProcessRpc, Cu as AuthAccessStreamPairingLinkUpsertedEvent, Da as MAX_WHEN_EXPRESSION_DEPTH, Dc as OrchestrationReplayEventsError, Di as ServerTraceDiagnosticsResult, Dl as ThreadTurnDiff, Dn as GitRunStackedActionToastRunAction, Do as DesktopCloudAuthFetchInputSchema, Dr as VcsRemote, Ds as EnvironmentCloudRelayConfigResult, Dt as WsShellOpenInEditorRpc, Du as AuthAccessWriteScope, Ea as MAX_SCRIPT_ID_LENGTH, Ec as OrchestrationReadModel, Ei as ServerTraceDiagnosticsRecentFailure, El as ThreadSessionStopRequestedPayload, En as GitRunStackedActionResult, Eo as DesktopAppStageLabelSchema, Er as VcsProcessTimeoutError, Es as EnvironmentCloudPreferencesRequest, Et as WsServerUpsertKeybindingRpc, Eu as AuthAccessTokenType, Fa as CanonicalItemType, Fc as OrchestrationSubscribeThreadInput, Fi as ClientSettingsSchema, Fl as DEFAULT_GIT_TEXT_GENERATION_MODEL, Fn as VcsListRefsInput, Fo as DesktopSshBearerBootstrapInputSchema, Fr as ServerConfigSettingsUpdatedPayload, Fs as EnvironmentHttpUnauthorizedError, Ft as WsSubscribeTerminalMetadataRpc, Fu as AuthCreatePairingCredentialInput, Ga as ToolLifecycleItemType, Gc as PROVIDER_SEND_TURN_MAX_IMAGE_BYTES, Gi as DEFAULT_SIDEBAR_THREAD_PREVIEW_COUNT, Gl as ProviderOptionSelection, Gn as VcsStatusStreamEvent, Go as DesktopSshPasswordPromptCancelledType, Gr as ServerLifecycleStreamWelcomeEvent, Gs as AssistantDeliveryMode, Gt as WsVcsCreateWorktreeRpc, Gu as AuthReviewWriteScope, Ha as RuntimeEventRaw, Hc as OrchestrationThreadShell, Hi as DEFAULT_SERVER_SETTINGS, Hl as ProviderOptionChoice, Hn as VcsStatusLocalResult, Ho as DesktopSshHostSourceSchema, Hr as ServerLifecycleReadyPayload, Hs as EnvironmentRequestInvalidError, Ht as WsTerminalRestartRpc, Hu as AuthPairingLink, Ia as CanonicalRequestType, Ic as OrchestrationThread, Ii as CodexSettings, Il as DEFAULT_GIT_TEXT_GENERATION_MODEL_BY_PROVIDER, In as VcsListRefsResult, Io as DesktopSshBearerRequestInputSchema, Ir as ServerConfigStreamEvent, Is as EnvironmentInternalError, It as WsSubscribeVcsStatusRpc, Iu as AuthEnvironmentBootstrapTokenType, Ja as ProviderEvent, Jc as ProjectCreatedPayload, Ji as DEFAULT_UNIFIED_SETTINGS, Jl as SelectProviderOptionDescriptor, Jn as ChangeRequest, Jo as DesktopThemeSchema, Jr as ServerProcessDiagnosticsEntry, Js as ClientOrchestrationCommand, Jt as WsVcsPullRpc, Ju as AuthSessionState, Ka as UserInputQuestion, Kc as PROVIDER_SEND_TURN_MAX_INPUT_CHARS, Ki as DEFAULT_SIDEBAR_THREAD_SORT_ORDER, Kl as ProviderOptionSelectionValue, Kn as VcsSwitchRefInput, Ko as DesktopSshPasswordPromptRequestSchema, Kr as ServerLifecycleWelcomePayload, Ks as ChatAttachment, Kt as WsVcsInitRpc, Ku as AuthRevokeClientSessionInput, La as ItemLifecyclePayload, Lc as OrchestrationThreadActivity, Li as ContextMenuStyle, Ll as DEFAULT_MODEL, Ln as VcsPullInput, Lo as DesktopSshEnvironmentBootstrapSchema, Lr as ServerConfigStreamKeybindingsUpdatedEvent, Ls as EnvironmentInternalErrorReason, Lt as WsTerminalAttachRpc, Lu as AuthEnvironmentScope, Ma as SCRIPT_RUN_COMMAND_PATTERN, Mc as OrchestrationShellSnapshot, Mi as isProviderAvailable, Ml as ThreadUnarchivedPayload, Mn as VcsCreateWorktreeInput, Mo as DesktopRuntimeInfoSchema, Mr as ServerConfigIssue, Ms as EnvironmentHttpConflictError, Mt as WsSubscribeServerConfigRpc, Mu as AuthClientMetadataDeviceType, Na as THREAD_JUMP_KEYBINDING_COMMANDS, Nc as OrchestrationShellStreamEvent, Ni as ClaudeSettings, Nl as TurnCountRange, Nn as VcsCreateWorktreeResult, No as DesktopServerExposureModeSchema, Nr as ServerConfigKeybindingsUpdatedPayload, Ns as EnvironmentHttpForbiddenError, Nt as WsSubscribeServerLifecycleRpc, Nu as AuthClientPresentationMetadata, Oa as MODEL_PICKER_JUMP_KEYBINDING_COMMANDS, Oc as OrchestrationReplayEventsInput, Oi as ServerTraceDiagnosticsSpanOccurrence, Ol as ThreadTurnDiffCompletedPayload, On as GitStackedAction, Oo as DesktopCloudAuthFetchResultSchema, Or as VcsRepositoryDetectionError, Os as EnvironmentConnectHttpApi, Ot as WsSourceControlCloneRepositoryRpc, Ou as AuthAdministrativeScopes, Pa as THREAD_KEYBINDING_COMMANDS, Pc as OrchestrationShellStreamItem, Pi as ClientSettingsPatch, Pl as BooleanProviderOptionDescriptor, Pn as VcsInitInput, Po as DesktopServerExposureStateSchema, Pr as ServerConfigProviderStatusesPayload, Ps as EnvironmentHttpInternalServerError, Pt as WsSubscribeTerminalEventsRpc, Pu as AuthClientSession, Q as WsCloudGetRelayClientStatusRpc, Qa as ProviderRespondToUserInputInput, Qc as ProjectScriptIcon, Qi as ObservabilitySettings, Ql as ProviderInstanceEnvironment, Qn as SourceControlCloneRepositoryResult, Qo as DesktopUpdateStateSchema, Qr as ServerProcessResourceHistoryResult, Qs as DispatchResult, Qt as ReviewDiffPreviewError, Qu as AuthTokenExchangeRequest, Ra as ProviderRuntimeEvent, Rc as OrchestrationThreadActivityTone, Ri as CursorSettings, Rl as DEFAULT_MODEL_BY_PROVIDER, Rn as VcsPullResult, Ro as DesktopSshEnvironmentEnsureInputSchema, Rr as ServerConfigStreamProviderStatusesEvent, Rs as EnvironmentMetadataHttpApi, Rt as WsTerminalClearRpc, Ru as AuthEnvironmentScopes, Sa as KeybindingsConfigError, Sc as OrchestrationProject, Sd as ThreadId, Si as ServerSignalProcessResult, Sl as ThreadProposedPlanUpsertedPayload, Sn as GitPreparePullRequestThreadResult, So as TerminalThreadInput, Sr as VcsListWorkspaceFilesResult, Ss as EnvironmentAuthenticatedAuth, St as WsServerRemoveKeybindingRpc, Su as AuthAccessStreamPairingLinkRemovedEvent, Ta as MAX_KEYBINDING_WHEN_LENGTH, Tc as OrchestrationProposedPlanId, Td as TurnId, Ti as ServerTraceDiagnosticsLogEvent, Tl as ThreadSessionSetPayload, Tn as GitRunStackedActionInput, To as DesktopAppBrandingSchema, Tr as VcsProcessSpawnError, Ts as EnvironmentCloudLinkStateResult, Tt as WsServerUpdateSettingsRpc, Tu as AuthAccessTokenResult, Ua as TOOL_LIFECYCLE_ITEM_TYPES, Uc as OrchestrationThreadStreamItem, Ui as DEFAULT_SIDEBAR_PROJECT_GROUPING_MODE, Ul as ProviderOptionDescriptor, Un as VcsStatusRemoteResult, Uo as DesktopSshHttpBaseUrlInputSchema, Ur as ServerLifecycleStreamEvent, Us as EnvironmentRequestInvalidReason, Ut as WsTerminalWriteRpc, Uu as AuthRelayReadScope, Va as ProviderRuntimeTurnStatus, Vc as OrchestrationThreadGoalStatus, Vi as DEFAULT_CONTEXT_MENU_STYLE, Vl as PROVIDER_DISPLAY_NAMES, Vn as VcsStatusInput, Vo as DesktopSshEnvironmentTargetSchema, Vr as ServerConfigUpdatedPayload, Vs as EnvironmentOrchestrationHttpApi, Vt as WsTerminalResizeRpc, Vu as AuthPairingCredentialResult, Wa as ThreadTokenUsageSnapshot, Wc as PROVIDER_SEND_TURN_MAX_ATTACHMENTS, Wi as DEFAULT_SIDEBAR_PROJECT_SORT_ORDER, Wl as ProviderOptionDescriptorType, Wn as VcsStatusResult, Wo as DesktopSshPasswordPromptCancelledResultSchema, Wr as ServerLifecycleStreamReadyEvent, Ws as EnvironmentScopeRequiredError, Wt as WsVcsCreateRefRpc, Wu as AuthRelayWriteScope, Xa as ProviderInterruptTurnInput, Xc as ProjectMetaUpdatedPayload, Xi as MAX_SIDEBAR_THREAD_PREVIEW_COUNT, Xl as ProviderInstanceConfig, Xn as SourceControlCloneProtocol, Xo as DesktopUpdateChannelSchema, Xr as ServerProcessResourceHistoryBucket, Xs as DEFAULT_PROVIDER_INTERACTION_MODE, Xt as WsVcsRemoveWorktreeRpc, Xu as AuthTerminalOperateScope, Ya as ProviderGoalRequestInput, Yc as ProjectDeletedPayload, Yi as GrokSettings, Yl as ProviderDriverKind, Yn as ChangeRequestState, Yo as DesktopUpdateActionResultSchema, Yr as ServerProcessDiagnosticsResult, Ys as CorrelationId, Yt as WsVcsRefreshStatusRpc, Yu as AuthStandardClientScopes, Z as WS_METHODS, Za as ProviderRespondToRequestInput, Zc as ProjectScript, Zi as MIN_SIDEBAR_THREAD_PREVIEW_COUNT, Zl as ProviderInstanceConfigMap, Zn as SourceControlCloneRepositoryInput, Zo as DesktopUpdateCheckResultSchema, Zr as ServerProcessResourceHistoryInput, Zs as DEFAULT_RUNTIME_MODE, Zt as WsVcsSwitchRefRpc, Zu as AuthTokenExchangeGrantType, _a as KeybindingShortcut, _c as OrchestrationGetTurnDiffInput, _d as ProviderItemId, _i as ServerProviderVersionAdvisoryStatus, _l as ThreadGoalRequestedPayload, _n as GitActionProgressStream, _o as TerminalRestartInput, _r as VcsDriverKind, _s as AuthOtherClientSessionsRevokeResult, _t as WsServerGetProcessDiagnosticsRpc, _u as AuthAccessSnapshot, aa as SidebarThreadPreviewCount, ac as OrchestrationCheckpointSummary, ad as ApprovalRequestId, ai as ServerProviderContinuation, al as ProviderSandboxMode, an as FilesystemBrowseInput, ao as TerminalAttachInput, ar as SourceControlProviderInfo, as as AdvertisedEndpointProvider, at as WsOrchestrationGetArchivedShellSnapshotRpc, au as EnvironmentConnectionState, ba as KeybindingWhenNode, bc as OrchestrationMessage, bd as RuntimeSessionId, bi as ServerRemoveKeybindingResult, bl as ThreadMessageSentPayload, bn as GitManagerServiceError, bo as TerminalSessionStatus, br as VcsFreshnessSource, bs as EnvironmentAuthInvalidError, bt as WsServerGetTraceDiagnosticsRpc, bu as AuthAccessStreamError, ca as TimestampFormat, cc as OrchestrationDispatchCommandError, cd as CommandId, ci as ServerProviderSlashCommand, cl as RuntimeMode, cn as ProjectSearchEntriesError, co as TerminalCloseInput, cr as SourceControlPublishRepositoryResult, cs as AdvertisedEndpointSource, ct as WsOrchestrationReplayEventsRpc, cu as ExecutionEnvironmentPlatform, da as EditorId, dc as OrchestrationEventType, dd as IsoDateTime, di as ServerProviderUpdateError, dl as ThreadArchivedPayload, dn as ProjectWriteFileError, do as TerminalEvent, dr as SourceControlRepositoryError, ds as RelayClientInstallFailedError, dt as WsProjectsSearchEntriesRpc, du as RepositoryIdentity, ea as ServerSettings, ec as ORCHESTRATION_WS_METHODS, ed as EnvironmentAuthorizationError, ei as ServerProcessSignal, el as ProjectionPendingApprovalStatus, en as ReviewDiffPreviewResult, eo as ProviderSession, er as SourceControlDiscoveryStatus, es as PersistedSavedEnvironmentRecordSchema, et as WsFilesystemBrowseRpc, eu as ProviderInstanceEnvironmentVariableName, fa as EditorLaunchStyle, fc as OrchestrationGetFullThreadDiffError, fd as MessageId, fi as ServerProviderUpdateInput, fl as ThreadCheckpointRevertRequestedPayload, fn as ProjectWriteFileInput, fo as TerminalHistoryError, fr as SourceControlRepositoryInfo, fs as RelayClientInstallFailureReasonSchema, ft as WsProjectsWriteFileRpc, fu as RepositoryIdentityLocator, ga as KeybindingRule, gc as OrchestrationGetTurnDiffError, gd as ProjectId, gi as ServerProviderVersionAdvisory, gl as ThreadGoalRequest, gn as GitActionProgressPhase, go as TerminalResizeInput, gr as VcsDriverCapabilities, gs as AuthClientSessionRevokeResult, gt as WsServerGetConfigRpc, gu as AuthAccessReadScope, ha as KeybindingCommand, hc as OrchestrationGetSnapshotError, hd as PositiveInt, hi as ServerProviderUpdatedPayload, hl as ThreadGoalClearedPayload, hn as GitActionProgressKind, ho as TerminalOpenInput, hr as VcsDiscoveryItem, hs as RelayClientStatusSchema, ht as WsServerDiscoverSourceControlRpc, hu as ScopedThreadSessionRef, ia as SidebarProjectSortOrder, ic as OrchestrationCheckpointStatus, id as ServerAuthSessionMethod, ii as ServerProviderAvailability, il as ProviderRequestKind, in as FilesystemBrowseError, io as DEFAULT_TERMINAL_ID, ir as SourceControlProviderError, is as AdvertisedEndpointHostedHttpsCompatibility, it as WsOrchestrationDispatchCommandRpc, iu as isProviderDriverKind, ja as ResolvedKeybindingsConfig, jc as OrchestrationSessionStatus, ji as ServerUpsertKeybindingResult, jl as ThreadTurnStartRequestedPayload, jn as VcsCreateRefResult, jo as DesktopRuntimeArchSchema, jr as ServerConfig, js as EnvironmentHttpCommonError, jt as WsSubscribeAuthAccessRpc, ju as AuthClientMetadata, ka as MODEL_PICKER_KEYBINDING_COMMANDS, kc as OrchestrationRpcSchemas, ki as ServerTraceDiagnosticsSpanSummary, kl as ThreadTurnInterruptRequestedPayload, kn as TextGenerationError, ko as DesktopDiscoveredSshHostSchema, kr as VcsRepositoryIdentity, ks as EnvironmentHttpApi, kt as WsSourceControlLookupRepositoryRpc, ku as AuthBrowserSessionRequest, la as makeProviderSettingsSchema, lc as OrchestrationEvent, ld as EnvironmentId, li as ServerProviderSlashCommandInput, ll as ThreadActivityAppendedPayload, ln as ProjectSearchEntriesInput, lo as TerminalCwdError, lr as SourceControlPublishStatus, ls as AdvertisedEndpointStatus, lt as WsOrchestrationSubscribeShellRpc, lu as ExecutionEnvironmentPlatformArch, ma as LaunchEditorInput, mc as OrchestrationGetFullThreadDiffResult, md as PortSchema, mi as ServerProviderUpdateStatus, ml as ThreadDeletedPayload, mn as GitActionProgressEvent, mo as TerminalNotRunningError, mr as SourceControlRepositoryVisibility, ms as RelayClientInstallProgressStageSchema, mt as WsRpcGroup, mu as ScopedThreadRef, na as ServerSettingsPatch, nc as OrchestrationAggregateKind, nd as ServerAuthDescriptor, ni as ServerProviderAuth, nl as ProviderApprovalPolicy, nn as ReviewDiffPreviewSourceKind, no as ProviderStopSessionInput, nr as SourceControlProviderAuthStatus, ns as AdvertisedEndpoint, nt as WsGitResolvePullRequestRpc, nu as ProviderInstanceRef, oa as SidebarThreadSortOrder, oc as OrchestrationCommand, od as AuthSessionId, oi as ServerProviderModel, ol as ProviderSessionRuntimeStatus, on as FilesystemBrowseResult, oo as TerminalAttachStreamEvent, or as SourceControlProviderKind, os as AdvertisedEndpointProviderKind, ot as WsOrchestrationGetFullThreadDiffRpc, ou as ExecutionEnvironmentCapabilities, pa as ExternalLauncherError, pc as OrchestrationGetFullThreadDiffInput, pd as NonNegativeInt, pi as ServerProviderUpdateState, pl as ThreadCreatedPayload, pn as ProjectWriteFileResult, po as TerminalMetadataStreamEvent, pr as SourceControlRepositoryLookupInput, ps as RelayClientInstallProgressEventSchema, pt as WsReviewGetDiffPreviewRpc, pu as ScopedProjectRef, qa as isToolLifecycleItemType, qc as ProjectCreateCommand, qi as DEFAULT_TIMESTAMP_FORMAT, ql as ProviderOptionSelections, qn as VcsSwitchRefResult, qo as DesktopSshPasswordPromptResolutionInputSchema, qr as ServerObservability, qs as ChatImageAttachment, qt as WsVcsListRefsRpc, qu as AuthRevokePairingLinkInput, ra as SidebarProjectGroupingMode, rc as OrchestrationCheckpointFile, rd as ServerAuthPolicy, ri as ServerProviderAuthStatus, rl as ProviderInteractionMode, rn as FilesystemBrowseEntry, ro as ProviderTurnStartResult, rr as SourceControlProviderDiscoveryItem, rs as AdvertisedEndpointCompatibility, rt as WsGitRunStackedActionRpc, ru as defaultInstanceIdForDriver, sa as ThreadEnvMode, sc as OrchestrationCommandReceiptStatus, sd as CheckpointRef, si as ServerProviderSkill, sl as ProviderUserInputAnswers, sn as ProjectEntry, so as TerminalClearInput, sr as SourceControlPublishRepositoryInput, ss as AdvertisedEndpointReachability, st as WsOrchestrationGetTurnDiffRpc, su as ExecutionEnvironmentDescriptor, ta as ServerSettingsError, tc as OrchestrationActorKind, td as ServerAuthBootstrapMethod, ti as ServerProvider, tl as ProviderApprovalDecision, tn as ReviewDiffPreviewSource, to as ProviderSessionStartInput, tr as SourceControlProviderAuth, ts as PickFolderOptionsSchema, tt as WsGitPreparePullRequestThreadRpc, tu as ProviderInstanceId, ua as EDITORS, uc as OrchestrationEventMetadata, ud as EventId, ui as ServerProviderState, ul as ThreadApprovalResponseRequestedPayload, un as ProjectSearchEntriesResult, uo as TerminalError, ur as SourceControlRepositoryCloneUrls, us as DesktopBackendBootstrap, ut as WsOrchestrationSubscribeThreadRpc, uu as ExecutionEnvironmentPlatformOs, va as KeybindingValue, vc as OrchestrationGetTurnDiffResult, vd as RuntimeItemId, vi as ServerProviders, vl as ThreadGoalUpdatedPayload, vn as GitCommandError, vo as TerminalSessionLookupError, vr as VcsError, vs as AuthPairingLinkRevokeResult, vt as WsServerGetProcessResourceHistoryRpc, vu as AuthAccessStreamClientRemovedEvent, wa as MAX_KEYBINDING_VALUE_LENGTH, wc as OrchestrationProposedPlan, wd as TrimmedString, wi as ServerTraceDiagnosticsFailureSummary, wl as ThreadRuntimeModeSetPayload, wn as GitResolvePullRequestResult, wo as ContextMenuItemSchema, wr as VcsProcessExitError, ws as EnvironmentCloudEndpointUnavailableError, wt as WsServerUpdateProviderRpc, wu as AuthAccessStreamSnapshotEvent, xa as KeybindingsConfig, xc as OrchestrationMessageRole, xd as RuntimeTaskId, xi as ServerSignalProcessInput, xl as ThreadMetaUpdatedPayload, xn as GitPreparePullRequestThreadInput, xo as TerminalSummary, xr as VcsListRemotesResult, xs as EnvironmentAuthInvalidReason, xt as WsServerRefreshProvidersRpc, xu as AuthAccessStreamEvent, ya as KeybindingWhen, yc as OrchestrationLatestTurn, yd as RuntimeRequestId, yi as ServerRemoveKeybindingInput, yl as ThreadInteractionModeSetPayload, yn as GitManagerError, yo as TerminalSessionSnapshot, yr as VcsFreshness, ys as EnvironmentAuthHttpApi, yt as WsServerGetSettingsRpc, yu as AuthAccessStreamClientUpsertedEvent, za as ProviderRuntimeEventV2, zc as OrchestrationThreadDetailSnapshot, zi as DEFAULT_AUTOMATIC_GIT_FETCH_INTERVAL, zl as MODEL_SLUG_ALIASES_BY_PROVIDER, zn as VcsRef, zo as DesktopSshEnvironmentEnsureOptionsSchema, zr as ServerConfigStreamSettingsUpdatedEvent, zs as EnvironmentOperationForbiddenError, zt as WsTerminalCloseRpc, zu as AuthOrchestrationOperateScope } from "./shared.js";
 export { AdvertisedEndpoint, AdvertisedEndpointCompatibility, AdvertisedEndpointHostedHttpsCompatibility, AdvertisedEndpointProvider, AdvertisedEndpointProviderKind, AdvertisedEndpointReachability, AdvertisedEndpointSource, AdvertisedEndpointStatus, ApprovalRequestId, AssistantDeliveryMode, AuthAccessReadScope, AuthAccessSnapshot, AuthAccessStreamClientRemovedEvent, AuthAccessStreamClientUpsertedEvent, AuthAccessStreamError, AuthAccessStreamEvent, AuthAccessStreamPairingLinkRemovedEvent, AuthAccessStreamPairingLinkUpsertedEvent, AuthAccessStreamSnapshotEvent, AuthAccessTokenResult, AuthAccessTokenType, AuthAccessWriteScope, AuthAdministrativeScopes, AuthBrowserSessionRequest, AuthBrowserSessionResult, AuthClientMetadata, AuthClientMetadataDeviceType, AuthClientPresentationMetadata, AuthClientSession, AuthClientSessionRevokeResult, AuthCreatePairingCredentialInput, AuthEnvironmentBootstrapTokenType, AuthEnvironmentScope, AuthEnvironmentScopes, AuthOrchestrationOperateScope, AuthOrchestrationReadScope, AuthOtherClientSessionsRevokeResult, AuthPairingCredentialResult, AuthPairingLink, AuthPairingLinkRevokeResult, AuthRelayReadScope, AuthRelayWriteScope, AuthReviewWriteScope, AuthRevokeClientSessionInput, AuthRevokePairingLinkInput, AuthSessionId, AuthSessionState, AuthStandardClientScopes, AuthTerminalOperateScope, AuthTokenExchangeGrantType, AuthTokenExchangeRequest, AuthWebSocketTicketResult, BooleanProviderOptionDescriptor, CanonicalItemType, CanonicalRequestType, ChangeRequest, ChangeRequestState, ChatAttachment, ChatImageAttachment, CheckpointRef, ClaudeSettings, ClientOrchestrationCommand, ClientSettingsPatch, ClientSettingsSchema, CodexSettings, CommandId, ContextMenuItemSchema, ContextMenuStyle, CorrelationId, CursorSettings, DEFAULT_AUTOMATIC_GIT_FETCH_INTERVAL, DEFAULT_CLIENT_SETTINGS, DEFAULT_CONTEXT_MENU_STYLE, DEFAULT_GIT_TEXT_GENERATION_MODEL, DEFAULT_GIT_TEXT_GENERATION_MODEL_BY_PROVIDER, DEFAULT_MODEL, DEFAULT_MODEL_BY_PROVIDER, DEFAULT_PROVIDER_INTERACTION_MODE, DEFAULT_RUNTIME_MODE, DEFAULT_SERVER_SETTINGS, DEFAULT_SIDEBAR_PROJECT_GROUPING_MODE, DEFAULT_SIDEBAR_PROJECT_SORT_ORDER, DEFAULT_SIDEBAR_THREAD_PREVIEW_COUNT, DEFAULT_SIDEBAR_THREAD_SORT_ORDER, DEFAULT_TERMINAL_ID, DEFAULT_TIMESTAMP_FORMAT, DEFAULT_UNIFIED_SETTINGS, DesktopAppBrandingSchema, DesktopAppStageLabelSchema, DesktopBackendBootstrap, DesktopCloudAuthFetchInputSchema, DesktopCloudAuthFetchResultSchema, DesktopDiscoveredSshHostSchema, DesktopEnvironmentBootstrapSchema, DesktopRuntimeArchSchema, DesktopRuntimeInfoSchema, DesktopServerExposureModeSchema, DesktopServerExposureStateSchema, DesktopSshBearerBootstrapInputSchema, DesktopSshBearerRequestInputSchema, DesktopSshEnvironmentBootstrapSchema, DesktopSshEnvironmentEnsureInputSchema, DesktopSshEnvironmentEnsureOptionsSchema, DesktopSshEnvironmentEnsureResultSchema, DesktopSshEnvironmentTargetSchema, DesktopSshHostSourceSchema, DesktopSshHttpBaseUrlInputSchema, DesktopSshPasswordPromptCancelledResultSchema, DesktopSshPasswordPromptCancelledType, DesktopSshPasswordPromptRequestSchema, DesktopSshPasswordPromptResolutionInputSchema, DesktopThemeSchema, DesktopUpdateActionResultSchema, DesktopUpdateChannelSchema, DesktopUpdateCheckResultSchema, DesktopUpdateStateSchema, DesktopUpdateStatusSchema, DispatchResult, EDITORS, EditorId, EditorLaunchStyle, EnvironmentAuthHttpApi, EnvironmentAuthInvalidError, EnvironmentAuthInvalidReason, EnvironmentAuthenticatedAuth, EnvironmentAuthenticatedPrincipal, EnvironmentAuthorizationError, EnvironmentCloudEndpointUnavailableError, EnvironmentCloudLinkStateResult, EnvironmentCloudPreferencesRequest, EnvironmentCloudRelayConfigResult, EnvironmentConnectHttpApi, EnvironmentConnectionState, EnvironmentHttpApi, EnvironmentHttpBadRequestError, EnvironmentHttpCommonError, EnvironmentHttpConflictError, EnvironmentHttpForbiddenError, EnvironmentHttpInternalServerError, EnvironmentHttpUnauthorizedError, EnvironmentId, EnvironmentInternalError, EnvironmentInternalErrorReason, EnvironmentMetadataHttpApi, EnvironmentOperationForbiddenError, EnvironmentOperationForbiddenReason, EnvironmentOrchestrationHttpApi, EnvironmentRequestInvalidError, EnvironmentRequestInvalidReason, EnvironmentScopeRequiredError, EventId, ExecutionEnvironmentCapabilities, ExecutionEnvironmentDescriptor, ExecutionEnvironmentPlatform, ExecutionEnvironmentPlatformArch, ExecutionEnvironmentPlatformOs, ExternalLauncherError, FilesystemBrowseEntry, FilesystemBrowseError, FilesystemBrowseInput, FilesystemBrowseResult, GitActionProgressEvent, GitActionProgressKind, GitActionProgressPhase, GitActionProgressStream, GitCommandError, GitManagerError, GitManagerServiceError, GitPreparePullRequestThreadInput, GitPreparePullRequestThreadResult, GitPullRequestRefInput, GitResolvePullRequestResult, GitRunStackedActionInput, GitRunStackedActionResult, GitRunStackedActionToastRunAction, GitStackedAction, GrokSettings, IsoDateTime, ItemLifecyclePayload, KeybindingCommand, KeybindingRule, KeybindingShortcut, KeybindingValue, KeybindingWhen, KeybindingWhenNode, KeybindingsConfig, KeybindingsConfigError, LaunchEditorInput, MAX_KEYBINDINGS_COUNT, MAX_KEYBINDING_VALUE_LENGTH, MAX_KEYBINDING_WHEN_LENGTH, MAX_SCRIPT_ID_LENGTH, MAX_SIDEBAR_THREAD_PREVIEW_COUNT, MAX_WHEN_EXPRESSION_DEPTH, MIN_SIDEBAR_THREAD_PREVIEW_COUNT, MODEL_PICKER_JUMP_KEYBINDING_COMMANDS, MODEL_PICKER_KEYBINDING_COMMANDS, MODEL_SLUG_ALIASES_BY_PROVIDER, MessageId, ModelCapabilities, ModelSelection, NonNegativeInt, ORCHESTRATION_WS_METHODS, ObservabilitySettings, OpenCodeSettings, OrchestrationActorKind, OrchestrationAggregateKind, OrchestrationCheckpointFile, OrchestrationCheckpointStatus, OrchestrationCheckpointSummary, OrchestrationCommand, OrchestrationCommandReceiptStatus, OrchestrationDispatchCommandError, OrchestrationEvent, OrchestrationEventMetadata, OrchestrationEventType, OrchestrationGetFullThreadDiffError, OrchestrationGetFullThreadDiffInput, OrchestrationGetFullThreadDiffResult, OrchestrationGetSnapshotError, OrchestrationGetTurnDiffError, OrchestrationGetTurnDiffInput, OrchestrationGetTurnDiffResult, OrchestrationLatestTurn, OrchestrationMessage, OrchestrationMessageRole, OrchestrationProject, OrchestrationProjectShell, OrchestrationProposedPlan, OrchestrationProposedPlanId, OrchestrationReadModel, OrchestrationReplayEventsError, OrchestrationReplayEventsInput, OrchestrationRpcSchemas, OrchestrationSession, OrchestrationSessionStatus, OrchestrationShellSnapshot, OrchestrationShellStreamEvent, OrchestrationShellStreamItem, OrchestrationSubscribeThreadInput, OrchestrationThread, OrchestrationThreadActivity, OrchestrationThreadActivityTone, OrchestrationThreadDetailSnapshot, OrchestrationThreadGoal, OrchestrationThreadGoalStatus, OrchestrationThreadShell, OrchestrationThreadStreamItem, PROVIDER_DISPLAY_NAMES, PROVIDER_SEND_TURN_MAX_ATTACHMENTS, PROVIDER_SEND_TURN_MAX_IMAGE_BYTES, PROVIDER_SEND_TURN_MAX_INPUT_CHARS, PersistedSavedEnvironmentRecordSchema, PickFolderOptionsSchema, PortSchema, PositiveInt, ProjectCreateCommand, ProjectCreatedPayload, ProjectDeletedPayload, ProjectEntry, ProjectId, ProjectMetaUpdatedPayload, ProjectScript, ProjectScriptIcon, ProjectSearchEntriesError, ProjectSearchEntriesInput, ProjectSearchEntriesResult, ProjectWriteFileError, ProjectWriteFileInput, ProjectWriteFileResult, ProjectionPendingApprovalDecision, ProjectionPendingApprovalStatus, ProviderApprovalDecision, ProviderApprovalPolicy, ProviderDriverKind, ProviderEvent, ProviderGoalRequestInput, ProviderInstanceConfig, ProviderInstanceConfigMap, ProviderInstanceEnvironment, ProviderInstanceEnvironmentVariable, ProviderInstanceEnvironmentVariableName, ProviderInstanceId, ProviderInstanceRef, ProviderInteractionMode, ProviderInterruptTurnInput, ProviderItemId, ProviderOptionChoice, ProviderOptionDescriptor, ProviderOptionDescriptorType, ProviderOptionSelection, ProviderOptionSelectionValue, ProviderOptionSelections, ProviderRequestKind, ProviderRespondToRequestInput, ProviderRespondToUserInputInput, ProviderRuntimeEvent, ProviderRuntimeEventV2, ProviderRuntimeThreadGoalStatus, ProviderRuntimeTurnStatus, ProviderSandboxMode, ProviderSendTurnInput, ProviderSession, ProviderSessionRuntimeStatus, ProviderSessionStartInput, ProviderStopSessionInput, ProviderTurnStartResult, ProviderUserInputAnswers, RelayClientInstallFailedError, RelayClientInstallFailureReasonSchema, RelayClientInstallProgressEventSchema, RelayClientInstallProgressStageSchema, RelayClientStatusSchema, RepositoryIdentity, RepositoryIdentityLocator, ResolvedKeybindingRule, ResolvedKeybindingsConfig, ReviewDiffPreviewError, ReviewDiffPreviewInput, ReviewDiffPreviewResult, ReviewDiffPreviewSource, ReviewDiffPreviewSourceKind, RuntimeEventRaw, RuntimeItemId, RuntimeMode, RuntimeRequestId, RuntimeSessionId, RuntimeTaskId, SCRIPT_RUN_COMMAND_PATTERN, ScopedProjectRef, ScopedThreadRef, ScopedThreadSessionRef, SelectProviderOptionDescriptor, ServerAuthBootstrapMethod, ServerAuthDescriptor, ServerAuthPolicy, ServerAuthSessionMethod, ServerConfig, ServerConfigIssue, ServerConfigKeybindingsUpdatedPayload, ServerConfigProviderStatusesPayload, ServerConfigSettingsUpdatedPayload, ServerConfigStreamEvent, ServerConfigStreamKeybindingsUpdatedEvent, ServerConfigStreamProviderStatusesEvent, ServerConfigStreamSettingsUpdatedEvent, ServerConfigStreamSnapshotEvent, ServerConfigUpdatedPayload, ServerLifecycleReadyPayload, ServerLifecycleStreamEvent, ServerLifecycleStreamReadyEvent, ServerLifecycleStreamWelcomeEvent, ServerLifecycleWelcomePayload, ServerObservability, ServerProcessDiagnosticsEntry, ServerProcessDiagnosticsResult, ServerProcessResourceHistoryBucket, ServerProcessResourceHistoryInput, ServerProcessResourceHistoryResult, ServerProcessResourceHistorySummary, ServerProcessSignal, ServerProvider, ServerProviderAuth, ServerProviderAuthStatus, ServerProviderAvailability, ServerProviderContinuation, ServerProviderModel, ServerProviderSkill, ServerProviderSlashCommand, ServerProviderSlashCommandInput, ServerProviderState, ServerProviderUpdateError, ServerProviderUpdateInput, ServerProviderUpdateState, ServerProviderUpdateStatus, ServerProviderUpdatedPayload, ServerProviderVersionAdvisory, ServerProviderVersionAdvisoryStatus, ServerProviders, ServerRemoveKeybindingInput, ServerRemoveKeybindingResult, ServerSettings, ServerSettingsError, ServerSettingsPatch, ServerSignalProcessInput, ServerSignalProcessResult, ServerTraceDiagnosticsErrorKind, ServerTraceDiagnosticsFailureSummary, ServerTraceDiagnosticsLogEvent, ServerTraceDiagnosticsRecentFailure, ServerTraceDiagnosticsResult, ServerTraceDiagnosticsSpanOccurrence, ServerTraceDiagnosticsSpanSummary, ServerUpsertKeybindingInput, ServerUpsertKeybindingResult, SidebarProjectGroupingMode, SidebarProjectSortOrder, SidebarThreadPreviewCount, SidebarThreadSortOrder, SourceControlCloneProtocol, SourceControlCloneRepositoryInput, SourceControlCloneRepositoryResult, SourceControlDiscoveryResult, SourceControlDiscoveryStatus, SourceControlProviderAuth, SourceControlProviderAuthStatus, SourceControlProviderDiscoveryItem, SourceControlProviderError, SourceControlProviderInfo, SourceControlProviderKind, SourceControlPublishRepositoryInput, SourceControlPublishRepositoryResult, SourceControlPublishStatus, SourceControlRepositoryCloneUrls, SourceControlRepositoryError, SourceControlRepositoryInfo, SourceControlRepositoryLookupInput, SourceControlRepositoryVisibility, THREAD_JUMP_KEYBINDING_COMMANDS, THREAD_KEYBINDING_COMMANDS, TOOL_LIFECYCLE_ITEM_TYPES, TerminalAttachInput, TerminalAttachStreamEvent, TerminalClearInput, TerminalCloseInput, TerminalCwdError, TerminalError, TerminalEvent, TerminalHistoryError, TerminalMetadataStreamEvent, TerminalNotRunningError, TerminalOpenInput, TerminalResizeInput, TerminalRestartInput, TerminalSessionLookupError, TerminalSessionSnapshot, TerminalSessionStatus, TerminalSummary, TerminalThreadInput, TerminalWriteInput, TextGenerationError, ThreadActivityAppendedPayload, ThreadApprovalResponseRequestedPayload, ThreadArchivedPayload, ThreadCheckpointRevertRequestedPayload, ThreadCreatedPayload, ThreadDeletedPayload, ThreadEnvMode, ThreadGoalClearedPayload, ThreadGoalRequest, ThreadGoalRequestedPayload, ThreadGoalUpdatedPayload, ThreadId, ThreadInteractionModeSetPayload, ThreadMessageSentPayload, ThreadMetaUpdatedPayload, ThreadProposedPlanUpsertedPayload, ThreadRevertedPayload, ThreadRuntimeModeSetPayload, ThreadSessionSetPayload, ThreadSessionStopRequestedPayload, ThreadTokenUsageSnapshot, ThreadTurnDiff, ThreadTurnDiffCompletedPayload, ThreadTurnInterruptRequestedPayload, ThreadTurnStartCommand, ThreadTurnStartRequestedPayload, ThreadUnarchivedPayload, TimestampFormat, ToolLifecycleItemType, TrimmedNonEmptyString, TrimmedString, TurnCountRange, TurnId, UserInputQuestion, VcsCreateRefInput, VcsCreateRefResult, VcsCreateWorktreeInput, VcsCreateWorktreeResult, VcsDiscoveryItem, VcsDriverCapabilities, VcsDriverKind, VcsError, VcsFreshness, VcsFreshnessSource, VcsInitInput, VcsListRefsInput, VcsListRefsResult, VcsListRemotesResult, VcsListWorkspaceFilesResult, VcsOutputDecodeError, VcsProcessExitError, VcsProcessSpawnError, VcsProcessTimeoutError, VcsPullInput, VcsPullResult, VcsRef, VcsRemote, VcsRemoveWorktreeInput, VcsRepositoryDetectionError, VcsRepositoryIdentity, VcsStatusInput, VcsStatusLocalResult, VcsStatusRemoteResult, VcsStatusResult, VcsStatusStreamEvent, VcsSwitchRefInput, VcsSwitchRefResult, VcsUnsupportedOperationError, WS_METHODS, WsCloudGetRelayClientStatusRpc, WsCloudInstallRelayClientRpc, WsFilesystemBrowseRpc, WsGitPreparePullRequestThreadRpc, WsGitResolvePullRequestRpc, WsGitRunStackedActionRpc, WsOrchestrationDispatchCommandRpc, WsOrchestrationGetArchivedShellSnapshotRpc, WsOrchestrationGetFullThreadDiffRpc, WsOrchestrationGetTurnDiffRpc, WsOrchestrationReplayEventsRpc, WsOrchestrationSubscribeShellRpc, WsOrchestrationSubscribeThreadRpc, WsProjectsSearchEntriesRpc, WsProjectsWriteFileRpc, WsReviewGetDiffPreviewRpc, WsRpcGroup, WsServerDiscoverSourceControlRpc, WsServerGetConfigRpc, WsServerGetProcessDiagnosticsRpc, WsServerGetProcessResourceHistoryRpc, WsServerGetSettingsRpc, WsServerGetTraceDiagnosticsRpc, WsServerRefreshProvidersRpc, WsServerRemoveKeybindingRpc, WsServerSignalProcessRpc, WsServerUpdateProviderRpc, WsServerUpdateSettingsRpc, WsServerUpsertKeybindingRpc, WsShellOpenInEditorRpc, WsSourceControlCloneRepositoryRpc, WsSourceControlLookupRepositoryRpc, WsSourceControlPublishRepositoryRpc, WsSubscribeAuthAccessRpc, WsSubscribeServerConfigRpc, WsSubscribeServerLifecycleRpc, WsSubscribeTerminalEventsRpc, WsSubscribeTerminalMetadataRpc, WsSubscribeVcsStatusRpc, WsTerminalAttachRpc, WsTerminalClearRpc, WsTerminalCloseRpc, WsTerminalOpenRpc, WsTerminalResizeRpc, WsTerminalRestartRpc, WsTerminalWriteRpc, WsVcsCreateRefRpc, WsVcsCreateWorktreeRpc, WsVcsInitRpc, WsVcsListRefsRpc, WsVcsPullRpc, WsVcsRefreshStatusRpc, WsVcsRemoveWorktreeRpc, WsVcsSwitchRefRpc, defaultInstanceIdForDriver, isProviderAvailable, isProviderDriverKind, isToolLifecycleItemType, makeProviderSettingsSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "t3code-cli",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "CLI for t3code",
   "keywords": [
     "claude",

package/src/application/service.ts

@@ -9,10 +9,12 @@ import type {
   OrchestrationShellSnapshot,
   OrchestrationThread,
   OrchestrationThreadShell,
+  ProviderUserInputAnswers,
   ServerProvider,
 } from "#t3tools/contracts";
 
 import type { ApplicationError } from "./error.ts";
+import type { ThreadShow } from "./threads.ts";
 
 export type StartThreadInput = {
   readonly projectRef?: string;
@@ -71,6 +73,23 @@ export class T3Application extends Context.Service<
     readonly getThreadMessages: (
       threadId: string,
     ) => Effect.Effect<OrchestrationThread, ApplicationError>;
+    readonly showThread: (threadId: string) => Effect.Effect<ThreadShow, ApplicationError>;
+    readonly approveThread: (input: {
+      readonly threadId: string;
+      readonly requestId: string;
+      readonly decision: "accept" | "decline" | "cancel";
+    }) => Effect.Effect<
+      { readonly threadId: string; readonly requestId: string; readonly dispatch: DispatchResult },
+      ApplicationError
+    >;
+    readonly respondToThread: (input: {
+      readonly threadId: string;
+      readonly requestId: string;
+      readonly answers: ProviderUserInputAnswers;
+    }) => Effect.Effect<
+      { readonly threadId: string; readonly requestId: string; readonly dispatch: DispatchResult },
+      ApplicationError
+    >;
     readonly archiveThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
     readonly startThread: (
       input: StartThreadInput,

package/src/application/thread-commands.ts

@@ -2,12 +2,15 @@ import * as Crypto from "effect/Crypto";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import {
+  ApprovalRequestId,
   CommandId,
   MessageId,
   ThreadId,
   type ClientOrchestrationCommand,
   type ModelSelection,
   type OrchestrationProjectShell,
+  type ProviderApprovalDecision,
+  type ProviderUserInputAnswers,
 } from "#t3tools/contracts";
 import type { ServerConfigForCli } from "../orchestration/service.ts";
 import { resolveModelSelection } from "./model-selection.ts";
@@ -97,3 +100,45 @@ export const makeThreadArchiveCommand = Effect.fn("makeThreadArchiveCommand")(fu
     threadId: ThreadId.make(threadId),
   } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.archive" }>;
 });
+
+export const makeThreadApprovalRespondCommand = Effect.fn("makeThreadApprovalRespondCommand")(
+  function* (input: {
+    readonly threadId: string;
+    readonly requestId: string;
+    readonly decision: ProviderApprovalDecision;
+  }) {
+    const crypto = yield* Crypto.Crypto;
+    const createdAt = DateTime.formatIso(yield* DateTime.now);
+    return {
+      type: "thread.approval.respond",
+      commandId: CommandId.make(
+        `t3cli:thread-approve:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+      ),
+      threadId: ThreadId.make(input.threadId),
+      requestId: ApprovalRequestId.make(input.requestId),
+      decision: input.decision,
+      createdAt,
+    } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.approval.respond" }>;
+  },
+);
+
+export const makeThreadUserInputRespondCommand = Effect.fn("makeThreadUserInputRespondCommand")(
+  function* (input: {
+    readonly threadId: string;
+    readonly requestId: string;
+    readonly answers: ProviderUserInputAnswers;
+  }) {
+    const crypto = yield* Crypto.Crypto;
+    const createdAt = DateTime.formatIso(yield* DateTime.now);
+    return {
+      type: "thread.user-input.respond",
+      commandId: CommandId.make(
+        `t3cli:thread-respond:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+      ),
+      threadId: ThreadId.make(input.threadId),
+      requestId: ApprovalRequestId.make(input.requestId),
+      answers: input.answers,
+      createdAt,
+    } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.user-input.respond" }>;
+  },
+);

package/src/application/threads.ts

@@ -9,10 +9,16 @@ import { resolveProjectScope } from "../domain/helpers.ts";
 import { type StartThreadInput } from "./service.ts";
 import type { SendThreadInput, CallbackThreadInput } from "./service.ts";
 import { mergeModelOptions } from "./model-selection.ts";
+import { derivePendingApprovals, derivePendingUserInputs } from "../domain/thread-activities.ts";
+import { threadStatus, type ThreadLifecycleStatus } from "../domain/thread-lifecycle.ts";
+import type { OrchestrationThread } from "#t3tools/contracts";
+import type { ProviderApprovalDecision, ProviderUserInputAnswers } from "#t3tools/contracts";
 import {
+  makeThreadApprovalRespondCommand,
   makeThreadArchiveCommand,
   makeThreadStartCommands,
   makeThreadTurnContinueCommand,
+  makeThreadUserInputRespondCommand,
 } from "./thread-commands.ts";
 import {
   waitForThread as waitForThreadUntilComplete,
@@ -45,6 +51,10 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
   ) {
     return yield* orchestration.getThreadSnapshot(threadId);
   });
+  const showThread = Effect.fn("T3ApplicationLive.showThread")(function* (threadId: string) {
+    const thread = yield* orchestration.getThreadSnapshot(threadId);
+    return projectThreadShow(thread);
+  });
   const archiveThread = Effect.fn("T3ApplicationLive.archiveThread")(function* (threadId: string) {
     const command = yield* makeThreadArchiveCommand(threadId).pipe(
       Effect.provideService(Crypto.Crypto, crypto),
@@ -184,12 +194,37 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
     );
     return { dispatch: result.dispatch, targetThreadId: input.targetThreadId };
   });
+  const approveThread = Effect.fn("T3ApplicationLive.approveThread")(function* (input: {
+    readonly threadId: string;
+    readonly requestId: string;
+    readonly decision: ProviderApprovalDecision;
+  }) {
+    const command = yield* makeThreadApprovalRespondCommand(input).pipe(
+      Effect.provideService(Crypto.Crypto, crypto),
+    );
+    const dispatch = yield* orchestration.dispatch(command);
+    return { threadId: input.threadId, requestId: input.requestId, dispatch };
+  });
+  const respondToThread = Effect.fn("T3ApplicationLive.respondToThread")(function* (input: {
+    readonly threadId: string;
+    readonly requestId: string;
+    readonly answers: ProviderUserInputAnswers;
+  }) {
+    const command = yield* makeThreadUserInputRespondCommand(input).pipe(
+      Effect.provideService(Crypto.Crypto, crypto),
+    );
+    const dispatch = yield* orchestration.dispatch(command);
+    return { threadId: input.threadId, requestId: input.requestId, dispatch };
+  });
 
   return {
+    approveThread,
     archiveThread,
     listThreads,
     getThreadMessages,
+    respondToThread,
     sendThread,
+    showThread,
     startThread,
     watchThread,
     waitForThread,
@@ -197,6 +232,56 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
   };
 });
 
+export type ThreadShow = {
+  readonly id: string;
+  readonly projectId: string;
+  readonly title: string;
+  readonly status: ThreadLifecycleStatus;
+  readonly session: OrchestrationThread["session"];
+  readonly latestTurn: OrchestrationThread["latestTurn"];
+  readonly modelSelection: OrchestrationThread["modelSelection"];
+  readonly runtimeMode: OrchestrationThread["runtimeMode"];
+  readonly interactionMode: OrchestrationThread["interactionMode"];
+  readonly branch: OrchestrationThread["branch"];
+  readonly worktreePath: OrchestrationThread["worktreePath"];
+  readonly archivedAt: OrchestrationThread["archivedAt"];
+  readonly createdAt: string;
+  readonly updatedAt: string;
+  readonly messageCount: number;
+  readonly hasPendingApprovals: boolean;
+  readonly hasPendingUserInput: boolean;
+  readonly hasActionableProposedPlan: boolean;
+  readonly pendingApprovals: ReturnType<typeof derivePendingApprovals>;
+  readonly pendingUserInputs: ReturnType<typeof derivePendingUserInputs>;
+};
+
+function projectThreadShow(thread: OrchestrationThread): ThreadShow {
+  const pendingApprovals = derivePendingApprovals(thread.activities);
+  const pendingUserInputs = derivePendingUserInputs(thread.activities);
+  return {
+    id: thread.id,
+    projectId: thread.projectId,
+    title: thread.title,
+    status: threadStatus(thread),
+    session: thread.session,
+    latestTurn: thread.latestTurn,
+    modelSelection: thread.modelSelection,
+    runtimeMode: thread.runtimeMode,
+    interactionMode: thread.interactionMode,
+    branch: thread.branch,
+    worktreePath: thread.worktreePath,
+    archivedAt: thread.archivedAt,
+    createdAt: thread.createdAt,
+    updatedAt: thread.updatedAt,
+    messageCount: thread.messages.length,
+    hasPendingApprovals: pendingApprovals.length > 0,
+    hasPendingUserInput: pendingUserInputs.length > 0,
+    hasActionableProposedPlan: thread.proposedPlans.some((plan) => plan.implementedAt === null),
+    pendingApprovals,
+    pendingUserInputs,
+  };
+}
+
 function failIfThreadError(thread: {
   readonly id: string;
   readonly session: { readonly status: string; readonly lastError: string | null } | null;

package/src/cli/error.ts

@@ -21,3 +21,18 @@ export class MissingThreadError extends Schema.TaggedErrorClass<MissingThreadErr
     message: Schema.String,
   },
 ) {}
+
+export class SelfArchiveError extends Schema.TaggedErrorClass<SelfArchiveError>()(
+  "SelfArchiveError",
+  {
+    message: Schema.String,
+    threadId: Schema.String,
+  },
+) {}
+
+export class MissingRequestError extends Schema.TaggedErrorClass<MissingRequestError>()(
+  "MissingRequestError",
+  {
+    message: Schema.String,
+  },
+) {}