t3code-cli 0.12.0 → 0.14.0

package/src/rpc/layer.ts

@@ -1,24 +1,25 @@
+import type { ConnectionAttemptError } from "@t3tools/client-runtime/connection";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
 import * as Schedule from "effect/Schedule";
 import * as Scope from "effect/Scope";
 import * as SynchronizedRef from "effect/SynchronizedRef";
-import { HttpClientRequest } from "effect/unstable/http";
-import { RpcClient, RpcSerialization } from "effect/unstable/rpc";
-import * as Socket from "effect/unstable/socket/Socket";
 
-import { T3AuthTransport } from "../auth/transport.ts";
-import { T3CodeConnectionProvider } from "../connection/service.ts";
-import { normalizeHttpBaseUrl, toWebSocketEndpointUrl } from "../config/url/url.ts";
-import { CliWsRpcGroup } from "./ws-group.ts";
+import { T3CodeConnectionError } from "../connection/error.ts";
+import { T3PreparedConnectionProvider } from "../connection/prepared.ts";
 import { RpcError } from "./error.ts";
+import { T3RpcSessionFactory } from "./session.ts";
 import { T3Rpc, type WsClient } from "./service.ts";
 
-const makeClient = RpcClient.make(CliWsRpcGroup);
-const connectionRetrySchedule = Schedule.exponential("100 millis").pipe(Schedule.take(4));
+const connectionRetrySchedule = Schedule.exponential("100 millis").pipe(
+  Schedule.setInputType<ConnectionAttemptError | T3CodeConnectionError>(),
+  Schedule.upTo({ times: 4 }),
+  Schedule.while((metadata) => Predicate.isTagged(metadata.input, "ConnectionTransientError")),
+);
 
 type Connection = {
   readonly scope: Scope.Closeable;
@@ -26,23 +27,19 @@ type Connection = {
 };
 
 export const makeT3RpcLayer = Effect.fn("makeT3RpcLayer")(function* () {
-  const connectionProvider = yield* T3CodeConnectionProvider;
-  const authTransport = yield* T3AuthTransport;
-  const webSocketConstructor = yield* Socket.WebSocketConstructor;
+  const preparedConnectionProvider = yield* T3PreparedConnectionProvider;
+  const sessions = yield* T3RpcSessionFactory;
   const parentScope = yield* Scope.Scope;
   const connection = yield* SynchronizedRef.make(Option.none<Connection>());
   const openConnection = Effect.fn("T3RpcLive.openConnection")(function* () {
     const scope = yield* Scope.fork(parentScope);
     return yield* Effect.gen(function* () {
-      const url = yield* makeWsUrl({ authTransport, connectionProvider });
-      const protocol = yield* Layer.buildWithScope(
-        makeProtocolLayer(url, webSocketConstructor),
-        scope,
-      );
-      const client = yield* makeClient.pipe(
-        Effect.provide(protocol),
-        Effect.provideService(Scope.Scope, scope),
-      );
+      const prepared = yield* preparedConnectionProvider.get;
+      const session = yield* sessions
+        .connect(prepared)
+        .pipe(Effect.provideService(Scope.Scope, scope));
+      yield* session.ready;
+      const client: WsClient = session.client;
       return { scope, client } satisfies Connection;
     }).pipe(
       Effect.retry(connectionRetrySchedule),
@@ -74,36 +71,6 @@ export const makeT3RpcLayer = Effect.fn("makeT3RpcLayer")(function* () {
   };
 });
 
-const makeWsUrl = Effect.fn("makeWsUrl")(function* (input: {
-  readonly authTransport: T3AuthTransport["Service"];
-  readonly connectionProvider: T3CodeConnectionProvider["Service"];
-}) {
-  const connection = yield* input.connectionProvider.get;
-  const origin = yield* normalizeHttpBaseUrl(connection.origin.url);
-  const wsTicket = yield* input.authTransport.issueWebSocketTicket({
-    url: origin,
-    token: connection.auth.token,
-  });
-  const wsUrl = yield* toWebSocketEndpointUrl(origin, "/ws");
-  const request = HttpClientRequest.get(wsUrl).pipe(
-    HttpClientRequest.setUrlParam("wsTicket", wsTicket.ticket),
-  );
-  return Option.getOrThrow(HttpClientRequest.toUrl(request)).toString();
-});
-
-function makeProtocolLayer(
-  url: string,
-  webSocketConstructor: Socket.WebSocketConstructor["Service"],
-) {
-  const socketLayer = Socket.layerWebSocket(url).pipe(
-    Layer.provide(Layer.succeed(Socket.WebSocketConstructor, webSocketConstructor)),
-  );
-  return RpcClient.layerProtocolSocket({ retryTransientErrors: true }).pipe(
-    Layer.provide(socketLayer),
-    Layer.provide(RpcSerialization.layerJson),
-  );
-}
-
 export const T3RpcLive = Layer.effectContext(
   makeT3RpcLayer().pipe(Effect.map((rpc) => Context.make(T3Rpc, rpc))),
 );

package/src/rpc/operation.ts

@@ -1,3 +1,12 @@
+import type {
+  EnvironmentAuthorizationError,
+  KeybindingsConfigError,
+  OrchestrationDispatchCommandError,
+  OrchestrationGetSnapshotError,
+  PreviewAutomationError,
+  ServerSettingsError,
+  TerminalError,
+} from "@t3tools/contracts";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
@@ -8,15 +17,21 @@ import { RpcClientError } from "effect/unstable/rpc";
 
 import { RpcError } from "./error.ts";
 import { T3Rpc, type WsClient } from "./service.ts";
-import type { CliRpcRequestError } from "./ws-group.ts";
 
-export type CliRpcOperationError = CliRpcRequestError | RpcClientError.RpcClientError;
+export type CliRpcOperationError =
+  | EnvironmentAuthorizationError
+  | KeybindingsConfigError
+  | OrchestrationDispatchCommandError
+  | OrchestrationGetSnapshotError
+  | PreviewAutomationError
+  | RpcClientError.RpcClientError
+  | ServerSettingsError
+  | TerminalError;
 
 export const rpcRetrySchedule = Schedule.exponential("100 millis").pipe(
-  Schedule.take(4),
-  Schedule.collectWhile((metadata: Schedule.Metadata) =>
-    Predicate.isTagged(metadata.input, "RpcClientError"),
-  ),
+  Schedule.setInputType<CliRpcOperationError | RpcError>(),
+  Schedule.upTo({ times: 4 }),
+  Schedule.while((metadata) => Predicate.isTagged(metadata.input, "RpcClientError")),
 );
 
 export type T3RpcOperationsService = {

package/src/rpc/service.ts

@@ -1,8 +1,9 @@
 import * as Context from "effect/Context";
 import type * as Effect from "effect/Effect";
 import type { RpcClient, RpcClientError } from "effect/unstable/rpc";
-import type { CliWsRpcGroup } from "./ws-group.ts";
+
 import type { RpcError } from "./error.ts";
+import type { CliWsRpcGroup } from "./ws-group.ts";
 
 export type WsClient = RpcClient.FromGroup<typeof CliWsRpcGroup, RpcClientError.RpcClientError>;
 

package/src/rpc/session.ts

@@ -0,0 +1,168 @@
+import {
+  ConnectionBlockedError,
+  type ConnectionAttemptError,
+  ConnectionTransientError,
+  type PreparedConnection,
+} from "@t3tools/client-runtime/connection";
+import { WS_METHODS } from "@t3tools/contracts";
+import * as Context from "effect/Context";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schedule from "effect/Schedule";
+import type * as Scope from "effect/Scope";
+import * as RpcClient from "effect/unstable/rpc/RpcClient";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+import * as Socket from "effect/unstable/socket/Socket";
+
+import type { WsClient as CliWsClient } from "./service.ts";
+import type { CliServerConfig } from "./ws-group.ts";
+import { CliWsRpcGroup } from "./ws-group.ts";
+
+interface T3RpcSession {
+  readonly client: CliWsClient;
+  readonly initialConfig: Effect.Effect<CliServerConfig, ConnectionAttemptError>;
+  readonly ready: Effect.Effect<void, ConnectionAttemptError>;
+  readonly probe: Effect.Effect<void, ConnectionAttemptError>;
+  readonly closed: Effect.Effect<never, ConnectionTransientError>;
+}
+
+export class T3RpcSessionFactory extends Context.Service<
+  T3RpcSessionFactory,
+  {
+    readonly connect: (
+      connection: PreparedConnection,
+    ) => Effect.Effect<T3RpcSession, ConnectionAttemptError, Scope.Scope>;
+  }
+>()("t3cli/T3RpcSessionFactory") {}
+
+type SessionRpcError =
+  | Effect.Error<ReturnType<CliWsClient[typeof WS_METHODS.serverGetConfig]>>
+  | Effect.Error<ReturnType<CliWsClient[typeof WS_METHODS.serverProbe]>>;
+
+const makeClient = RpcClient.make(CliWsRpcGroup);
+
+const makeT3RpcSessionFactory = Effect.fn("makeT3RpcSessionFactory")(function* () {
+  const webSocketConstructor = yield* Socket.WebSocketConstructor;
+
+  const connect: T3RpcSessionFactory["Service"]["connect"] = Effect.fnUntraced(function* (
+    connection: PreparedConnection,
+  ) {
+    yield* Effect.annotateCurrentSpan({
+      "connection.environment.id": connection.environmentId,
+    });
+
+    const connected = yield* Deferred.make<void>();
+    const disconnected = yield* Deferred.make<never, ConnectionTransientError>();
+    const hooks = RpcClient.ConnectionHooks.of({
+      onConnect: Deferred.succeed(connected, undefined).pipe(Effect.asVoid),
+      onDisconnect: Deferred.isDone(connected).pipe(
+        Effect.flatMap((wasConnected) =>
+          Deferred.fail(
+            disconnected,
+            new ConnectionTransientError({
+              reason: "transport",
+              detail: wasConnected
+                ? `${connection.label} disconnected.`
+                : `${connection.label} could not establish a WebSocket connection.`,
+            }),
+          ),
+        ),
+        Effect.asVoid,
+      ),
+    });
+    const socketLayer = Socket.layerWebSocket(connection.socketUrl, {
+      openTimeout: "15 seconds",
+    }).pipe(Layer.provide(Layer.succeed(Socket.WebSocketConstructor, webSocketConstructor)));
+    const protocolLayer = Layer.effect(
+      RpcClient.Protocol,
+      RpcClient.makeProtocolSocket({
+        retryTransientErrors: false,
+        retryPolicy: Schedule.recurs(0),
+      }),
+    ).pipe(
+      Layer.provide(
+        Layer.mergeAll(
+          socketLayer,
+          RpcSerialization.layerJson,
+          Layer.succeed(RpcClient.ConnectionHooks, hooks),
+        ),
+      ),
+    );
+    const protocolContext = yield* Layer.build(protocolLayer).pipe(
+      Effect.withSpan("environment.websocket.connect"),
+    );
+    const client = yield* makeClient.pipe(Effect.provide(protocolContext));
+    const initialConfig = yield* Effect.cached(
+      client[WS_METHODS.serverGetConfig]({}).pipe(
+        catchSessionRpcErrors,
+        Effect.withSpan("environment.initialSync"),
+      ),
+    );
+    const probe = initialConfig.pipe(
+      Effect.flatMap((config) =>
+        Effect.gen(function* () {
+          if (config.environment.capabilities.connectionProbe) {
+            return yield* client[WS_METHODS.serverProbe]({});
+          }
+          return yield* client[WS_METHODS.serverGetConfig]({});
+        }).pipe(catchSessionRpcErrors),
+      ),
+      Effect.asVoid,
+      Effect.withSpan("clientRuntime.connection.rpcSession.probe"),
+    );
+
+    return {
+      client,
+      initialConfig,
+      ready: Deferred.await(connected).pipe(
+        Effect.andThen(initialConfig),
+        Effect.asVoid,
+        Effect.raceFirst(Deferred.await(disconnected)),
+      ),
+      probe,
+      closed: Deferred.await(disconnected),
+    } satisfies T3RpcSession;
+  });
+
+  return T3RpcSessionFactory.of({ connect });
+});
+
+export const T3RpcSessionFactoryLive = Layer.effect(T3RpcSessionFactory, makeT3RpcSessionFactory());
+
+function catchSessionRpcErrors<A, R>(
+  effect: Effect.Effect<A, SessionRpcError, R>,
+): Effect.Effect<A, ConnectionAttemptError, R> {
+  return effect.pipe(
+    Effect.catchTags({
+      EnvironmentAuthorizationError: (error) =>
+        Effect.fail(
+          new ConnectionBlockedError({
+            reason: "permission",
+            detail: error.message,
+          }),
+        ),
+      KeybindingsConfigParseError: (error) =>
+        Effect.fail(
+          new ConnectionTransientError({
+            reason: "remote-unavailable",
+            detail: error.message,
+          }),
+        ),
+      ServerSettingsError: (error) =>
+        Effect.fail(
+          new ConnectionTransientError({
+            reason: "remote-unavailable",
+            detail: error.message,
+          }),
+        ),
+      RpcClientError: (error) =>
+        Effect.fail(
+          new ConnectionTransientError({
+            reason: "transport",
+            detail: error.message,
+          }),
+        ),
+    }),
+  );
+}

package/src/rpc/ws-group.ts

@@ -1,16 +1,17 @@
 import {
   EnvironmentAuthorizationError,
   KeybindingsConfigError,
-  OrchestrationDispatchCommandError,
-  OrchestrationGetSnapshotError,
-  ServerConfig,
   ServerProviders,
   ServerSettingsError,
-  TerminalCwdError,
-  TerminalHistoryError,
-  TerminalNotRunningError,
-  TerminalSessionLookupError,
   WS_METHODS,
+  WsOrchestrationDispatchCommandRpc,
+  WsOrchestrationGetArchivedShellSnapshotRpc,
+  WsOrchestrationSubscribeShellRpc,
+  WsOrchestrationSubscribeThreadRpc,
+  WsPreviewAutomationConnectRpc,
+  WsPreviewAutomationFocusHostRpc,
+  WsPreviewAutomationRespondRpc,
+  WsServerProbeRpc,
   WsSubscribeTerminalEventsRpc,
   WsSubscribeTerminalMetadataRpc,
   WsTerminalAttachRpc,
@@ -18,20 +19,18 @@ import {
   WsTerminalOpenRpc,
   WsTerminalResizeRpc,
   WsTerminalWriteRpc,
-  WsOrchestrationDispatchCommandRpc,
-  WsOrchestrationGetArchivedShellSnapshotRpc,
-  WsOrchestrationSubscribeShellRpc,
-  WsOrchestrationSubscribeThreadRpc,
 } from "@t3tools/contracts";
 import * as Schema from "effect/Schema";
 import { Rpc, RpcGroup } from "effect/unstable/rpc";
 
-export const FallbackServerConfig = Schema.Struct({
+export const CliServerConfig = Schema.Struct({
+  environment: Schema.Struct({
+    capabilities: Schema.Struct({
+      connectionProbe: Schema.Boolean,
+    }),
+  }),
   providers: ServerProviders,
 });
-export type FallbackServerConfig = typeof FallbackServerConfig.Type;
-
-export const CliServerConfig = Schema.Union([ServerConfig, FallbackServerConfig]);
 export type CliServerConfig = typeof CliServerConfig.Type;
 
 export const WsServerGetConfigRpc = Rpc.make(WS_METHODS.serverGetConfig, {
@@ -52,16 +51,9 @@ export const CliWsRpcGroup = RpcGroup.make(
   WsOrchestrationGetArchivedShellSnapshotRpc,
   WsOrchestrationSubscribeShellRpc,
   WsOrchestrationSubscribeThreadRpc,
+  WsPreviewAutomationConnectRpc,
+  WsPreviewAutomationRespondRpc,
+  WsPreviewAutomationFocusHostRpc,
+  WsServerProbeRpc,
   WsServerGetConfigRpc,
 );
-
-export type CliRpcRequestError =
-  | EnvironmentAuthorizationError
-  | KeybindingsConfigError
-  | OrchestrationDispatchCommandError
-  | OrchestrationGetSnapshotError
-  | TerminalCwdError
-  | TerminalHistoryError
-  | TerminalNotRunningError
-  | TerminalSessionLookupError
-  | ServerSettingsError;

package/src/runtime/index.ts

@@ -10,4 +10,5 @@ export {
   T3LocalAuthOriginLayer,
   T3LocalAuthTokenLayer,
   T3OrchestrationLayer,
+  T3PreviewAutomationLayer,
 } from "./layer.ts";

package/src/runtime/layer.ts

@@ -14,10 +14,13 @@ import * as Config from "../config/config.ts";
 import * as Credential from "../config/credential/service.ts";
 import * as Selection from "../config/selection/service.ts";
 import { T3CodeConnectionError } from "../connection/error.ts";
+import { T3PreparedConnectionProviderLive } from "../connection/prepared.ts";
 import { T3CodeConnectionProvider, makeT3CodeConnectionProvider } from "../connection/service.ts";
 import { T3OrchestrationLive } from "../orchestration/layer.ts";
+import { T3PreviewAutomationLive } from "../preview/service.ts";
 import { T3RpcLive } from "../rpc/layer.ts";
 import { T3RpcOperationsLive } from "../rpc/operation.ts";
+import { T3RpcSessionFactoryLive } from "../rpc/session.ts";
 import { NodeSqlClientFactoryLive } from "../sql/node-sqlite-client.ts";
 import { NodeCliPathLayer } from "../cli-path/layer.ts";
 
@@ -63,14 +66,18 @@ const T3ConfigConnectionProviderLayer = Layer.effect(
 const T3RpcLayer = T3RpcLive.pipe(
   Layer.provide(
     Layer.mergeAll(
-      T3ConfigConnectionProviderLayer,
-      T3AuthTransportLayer,
-      NodeSocket.layerWebSocketConstructor,
+      T3PreparedConnectionProviderLive.pipe(
+        Layer.provide(Layer.mergeAll(T3ConfigConnectionProviderLayer, NodeHttpClient.layerUndici)),
+      ),
+      T3RpcSessionFactoryLive.pipe(Layer.provide(NodeSocket.layerWebSocketConstructor)),
     ),
   ),
 );
 const T3RpcOperationsLayer = T3RpcOperationsLive.pipe(Layer.provide(T3RpcLayer));
 export const T3OrchestrationLayer = T3OrchestrationLive.pipe(Layer.provide(T3RpcOperationsLayer));
+export const T3PreviewAutomationLayer = T3PreviewAutomationLive.pipe(
+  Layer.provide(T3RpcOperationsLayer),
+);
 const T3ApplicationLayer = T3ApplicationLive.pipe(
   Layer.provide(Layer.mergeAll(T3RpcOperationsLayer, T3OrchestrationLayer)),
 );
@@ -81,6 +88,7 @@ export const BaseAppLayer = Layer.mergeAll(
   T3RpcLayer,
   T3RpcOperationsLayer,
   T3OrchestrationLayer,
+  T3PreviewAutomationLayer,
   T3ApplicationLayer,
   NodeCliPathLayer,
 );

package/src/sql/node-sqlite-client.ts

@@ -91,6 +91,9 @@ export const makeNodeSqliteClient = Effect.fn("makeNodeSqliteClient")(function*
     executeValues(sql, params) {
       return runValues(sql, params);
     },
+    executeValuesUnprepared(sql, params) {
+      return runValues(sql, params);
+    },
     executeUnprepared(sql, params, rowTransform) {
       const effect = runRows(sql, params);
       return rowTransform === undefined ? effect : Effect.map(effect, rowTransform);

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

@@ -1,25 +0,0 @@
-import * as Crypto from "effect/Crypto";
-import * as Effect from "effect/Effect";
-import * as Path from "effect/Path";
-import { type OrchestrationProjectShell, type ProjectScript } from "@t3tools/contracts";
-import { T3Orchestration } from "../orchestration/service.ts";
-import { T3TerminalApplication, type AddProjectActionInput, type ProjectActionSelector, type UpdateProjectActionInput } from "./service.ts";
-export declare const makeActionApplication: () => Effect.Effect<{
-    addAction: (input: AddProjectActionInput) => Effect.Effect<import("./service.ts").ProjectActionMutationResult, import("./error.ts").ApplicationError>;
-    deleteAction: (input: {
-        readonly projectRef: string;
-        readonly selector: ProjectActionSelector;
-    }) => Effect.Effect<import("./service.ts").ProjectActionDeleteResult, import("./error.ts").ApplicationError>;
-    listActions: (projectRef: string) => Effect.Effect<{
-        readonly project: OrchestrationProjectShell;
-        readonly actions: ReadonlyArray<ProjectScript>;
-    }, import("./error.ts").ApplicationError>;
-    runAction: (input: {
-        readonly threadId: string;
-        readonly selector: ProjectActionSelector;
-        readonly terminalId?: string;
-    }) => Effect.Effect<import("./service.ts").ProjectActionRunResult, import("./error.ts").ApplicationError>;
-    updateAction: (input: UpdateProjectActionInput) => Effect.Effect<import("./service.ts").ProjectActionMutationResult, import("./error.ts").ApplicationError>;
-}, never, T3Orchestration | Path.Path | Crypto.Crypto | T3TerminalApplication>;
-export declare function nextProjectScriptId(name: string, existingIds: Iterable<string>): string;
-export declare function resolveActionBySelector(scripts: ReadonlyArray<ProjectScript>, selector: ProjectActionSelector, projectId: string): ProjectScript;

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

@@ -1,3 +0,0 @@
-import type { DomainError } from "../domain/error.ts";
-import type { RpcError } from "../rpc/error.ts";
-export type ApplicationError = DomainError | RpcError;

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

@@ -1,4 +0,0 @@
-export { T3ActionApplication, T3Application, T3ModelApplication, T3ProjectApplication, T3TerminalApplication, T3ThreadApplication, } from "./service.ts";
-export { makeT3Application, T3ActionApplicationLive, T3ApplicationLive, T3ApplicationSlicesLive, T3ModelApplicationLive, T3ProjectApplicationLive, T3TerminalApplicationLive, T3ThreadApplicationLive, } from "./layer.ts";
-export type { AddProjectActionInput, ProjectActionDeleteResult, ProjectActionMutationResult, ProjectActionRunResult, ProjectActionSelector, SendThreadInput, StartThreadInput, StartThreadPolicy, T3ActionApplicationService, UpdateProjectActionInput, UpdateThreadInput, WaitEvent, } from "./service.ts";
-export type { ApplicationError } from "./error.ts";

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

@@ -1,117 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import { T3ActionApplication, T3Application, T3ModelApplication, T3ProjectApplication, T3TerminalApplication, T3ThreadApplication } from "./service.ts";
-export declare const makeT3Application: () => Effect.Effect<{
-    listThreads: (projectRef: string, options?: {
-        readonly include?: import("./service.ts").ListThreadsInclude;
-    }) => Effect.Effect<{
-        readonly project: import("@t3tools/contracts").OrchestrationProjectShell;
-        readonly threads: ReadonlyArray<import("@t3tools/contracts").OrchestrationThreadShell>;
-    }, import("./error.ts").ApplicationError>;
-    getThreadMessages: (threadId: string) => Effect.Effect<import("@t3tools/contracts").OrchestrationThread, import("./error.ts").ApplicationError>;
-    showThread: (threadId: string) => Effect.Effect<import("./threads.ts").ThreadShow, import("./error.ts").ApplicationError>;
-    approveThread: (input: {
-        readonly threadId: string;
-        readonly requestId: string;
-        readonly decision: "accept" | "decline" | "cancel";
-    }) => Effect.Effect<{
-        readonly threadId: string;
-        readonly requestId: string;
-        readonly dispatch: import("@t3tools/contracts").DispatchResult;
-    }, import("./error.ts").ApplicationError>;
-    respondToThread: (input: {
-        readonly threadId: string;
-        readonly requestId: string;
-        readonly answers: import("@t3tools/contracts").ProviderUserInputAnswers;
-    }) => Effect.Effect<{
-        readonly threadId: string;
-        readonly requestId: string;
-        readonly dispatch: import("@t3tools/contracts").DispatchResult;
-    }, import("./error.ts").ApplicationError>;
-    archiveThread: (threadId: string) => Effect.Effect<import("@t3tools/contracts").DispatchResult, import("./error.ts").ApplicationError>;
-    interruptThread: (threadId: string) => Effect.Effect<import("@t3tools/contracts").DispatchResult, import("./error.ts").ApplicationError>;
-    unarchiveThread: (threadId: string) => Effect.Effect<import("@t3tools/contracts").DispatchResult, import("./error.ts").ApplicationError>;
-    deleteThread: (threadId: string) => Effect.Effect<{
-        readonly threadId: string;
-        readonly dispatch: import("@t3tools/contracts").DispatchResult;
-    }, import("./error.ts").ApplicationError>;
-    updateThread: (input: import("./service.ts").UpdateThreadInput) => Effect.Effect<import("@t3tools/contracts").DispatchResult, import("./error.ts").ApplicationError>;
-    startThread: (input: import("./service.ts").StartThreadInput, policy?: import("./service.ts").StartThreadPolicy) => Effect.Effect<{
-        readonly dispatch: import("@t3tools/contracts").DispatchResult;
-        readonly project: import("@t3tools/contracts").OrchestrationProjectShell;
-        readonly threadId: string;
-        readonly thread?: import("@t3tools/contracts").OrchestrationThread;
-    }, import("./error.ts").ApplicationError>;
-    sendThread: (input: import("./service.ts").SendThreadInput, policy?: import("./service.ts").StartThreadPolicy) => Effect.Effect<{
-        readonly dispatch: import("@t3tools/contracts").DispatchResult;
-        readonly threadId: string;
-        readonly thread?: import("@t3tools/contracts").OrchestrationThread;
-    }, import("./error.ts").ApplicationError>;
-    watchThread: (threadId: string) => import("effect/Stream").Stream<import("./service.ts").WaitEvent, import("./error.ts").ApplicationError>;
-    waitForThread: (threadId: string) => Effect.Effect<import("@t3tools/contracts").OrchestrationThread, import("./error.ts").ApplicationError>;
-    callbackThread: (input: import("./service.ts").CallbackThreadInput) => Effect.Effect<{
-        readonly dispatch: import("@t3tools/contracts").DispatchResult;
-        readonly targetThreadId: string;
-    }, import("./error.ts").ApplicationError>;
-    listTerminals: (threadId: string) => Effect.Effect<ReadonlyArray<import("@t3tools/contracts").TerminalSummary>, import("./error.ts").ApplicationError>;
-    getTerminal: (terminal: import("./service.ts").TerminalRef) => Effect.Effect<import("@t3tools/contracts").TerminalSummary, import("./error.ts").ApplicationError>;
-    createTerminal: (input: import("./service.ts").CreateTerminalInput) => Effect.Effect<import("@t3tools/contracts").TerminalSessionSnapshot, import("./error.ts").ApplicationError>;
-    attachTerminal: (input: {
-        readonly terminal: import("./service.ts").TerminalAttachTarget;
-        readonly cols?: number;
-        readonly rows?: number;
-    }) => import("effect/Stream").Stream<import("@t3tools/contracts").TerminalAttachStreamEvent, import("./error.ts").ApplicationError>;
-    watchTerminalMetadata: () => import("effect/Stream").Stream<import("@t3tools/contracts").TerminalMetadataStreamEvent, import("./error.ts").ApplicationError>;
-    writeTerminal: (input: {
-        readonly terminal: import("./service.ts").TerminalRef;
-        readonly data: string;
-    }) => Effect.Effect<void, import("./error.ts").ApplicationError>;
-    resizeTerminal: (input: {
-        readonly terminal: import("./service.ts").TerminalRef;
-        readonly cols: number;
-        readonly rows: number;
-    }) => Effect.Effect<void, import("./error.ts").ApplicationError>;
-    destroyTerminal: (terminal: import("./service.ts").TerminalRef) => Effect.Effect<void, import("./error.ts").ApplicationError>;
-    loadShell: () => Effect.Effect<import("@t3tools/contracts").OrchestrationShellSnapshot, import("./error.ts").ApplicationError>;
-    addProject: (input: {
-        readonly path: string;
-        readonly title?: string;
-    }) => Effect.Effect<{
-        readonly dispatch: import("@t3tools/contracts").DispatchResult;
-        readonly project: import("@t3tools/contracts").OrchestrationProjectShell;
-    }, import("./error.ts").ApplicationError>;
-    resolveProject: (projectRef: string) => Effect.Effect<import("@t3tools/contracts").OrchestrationProjectShell, import("./error.ts").ApplicationError>;
-    deleteProject: (input: {
-        readonly projectId: string;
-        readonly force?: boolean;
-    }) => Effect.Effect<{
-        readonly projectId: string;
-        readonly dispatch: import("@t3tools/contracts").DispatchResult;
-    }, import("./error.ts").ApplicationError>;
-    listModels: (input: {
-        readonly all?: boolean;
-        readonly provider?: string;
-    }) => Effect.Effect<ReadonlyArray<import("@t3tools/contracts").ServerProvider>, import("./error.ts").ApplicationError>;
-    listActions: (projectRef: string) => Effect.Effect<{
-        readonly project: import("@t3tools/contracts").OrchestrationProjectShell;
-        readonly actions: ReadonlyArray<import("@t3tools/contracts").ProjectScript>;
-    }, import("./error.ts").ApplicationError>;
-    addAction: (input: import("./service.ts").AddProjectActionInput) => Effect.Effect<import("./service.ts").ProjectActionMutationResult, import("./error.ts").ApplicationError>;
-    updateAction: (input: import("./service.ts").UpdateProjectActionInput) => Effect.Effect<import("./service.ts").ProjectActionMutationResult, import("./error.ts").ApplicationError>;
-    deleteAction: (input: {
-        readonly projectRef: string;
-        readonly selector: import("./service.ts").ProjectActionSelector;
-    }) => Effect.Effect<import("./service.ts").ProjectActionDeleteResult, import("./error.ts").ApplicationError>;
-    runAction: (input: {
-        readonly threadId: string;
-        readonly selector: import("./service.ts").ProjectActionSelector;
-        readonly terminalId?: string;
-    }) => Effect.Effect<import("./service.ts").ProjectActionRunResult, import("./error.ts").ApplicationError>;
-}, never, T3ActionApplication | T3ModelApplication | T3ProjectApplication | T3ThreadApplication | T3TerminalApplication>;
-export declare const T3ModelApplicationLive: Layer.Layer<T3ModelApplication, never, import("../orchestration/service.ts").T3Orchestration>;
-export declare const T3ProjectApplicationLive: Layer.Layer<T3ProjectApplication, never, import("../cli/runtime/service.ts").CliRuntime | import("../orchestration/service.ts").T3Orchestration | import("effect/Path").Path | import("effect/Crypto").Crypto>;
-export declare const T3TerminalApplicationLive: Layer.Layer<T3TerminalApplication, never, import("../orchestration/service.ts").T3Orchestration | import("effect/Crypto").Crypto | import("../rpc/operation.ts").T3RpcOperations>;
-export declare const T3ActionApplicationLive: Layer.Layer<T3ActionApplication, never, import("../orchestration/service.ts").T3Orchestration | import("effect/Path").Path | import("effect/Crypto").Crypto | import("../rpc/operation.ts").T3RpcOperations>;
-export declare const T3ThreadApplicationLive: Layer.Layer<T3ThreadApplication, never, import("../cli/runtime/service.ts").CliRuntime | import("../orchestration/service.ts").T3Orchestration | import("effect/Path").Path | import("effect/Crypto").Crypto>;
-export declare const T3ApplicationSlicesLive: Layer.Layer<T3ActionApplication | T3ModelApplication | T3ProjectApplication | T3ThreadApplication | T3TerminalApplication, never, import("../cli/runtime/service.ts").CliRuntime | import("../orchestration/service.ts").T3Orchestration | import("effect/Path").Path | import("effect/Crypto").Crypto | import("../rpc/operation.ts").T3RpcOperations>;
-export declare const T3ApplicationLive: Layer.Layer<T3Application, never, import("../cli/runtime/service.ts").CliRuntime | import("../orchestration/service.ts").T3Orchestration | import("effect/Path").Path | import("effect/Crypto").Crypto | import("../rpc/operation.ts").T3RpcOperations>;

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

@@ -1,34 +0,0 @@
-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;
-export declare function resolveUpdateModelSelection(input: {
-    readonly current: ModelSelection;
-    readonly provider?: string;
-    readonly model?: string;
-    readonly options?: NonNullable<ModelSelection["options"]>;
-    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>;