t3code-cli 0.1.1 → 0.1.3

package/src/orchestration/layer.ts

@@ -4,34 +4,35 @@ import * as Option from "effect/Option";
 import * as Schedule from "effect/Schedule";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
-import { RpcClientError } from "effect/unstable/rpc";
-
-import { type ClientOrchestrationCommand } from "../domain/command-schema.ts";
 import {
   ORCHESTRATION_WS_METHODS,
-  type ShellStreamItem,
-  type ThreadStreamItem,
+  ThreadId,
   WS_METHODS,
-} from "../protocol/schema.ts";
+  type ClientOrchestrationCommand,
+  type OrchestrationShellStreamItem,
+  type OrchestrationThreadStreamItem,
+} from "@t3tools/contracts";
+import { RpcClientError } from "effect/unstable/rpc";
+
 import { RpcError } from "../rpc/error.ts";
 import { T3Rpc, type WsClient } from "../rpc/service.ts";
+import type { CliRpcRequestError } from "../rpc/ws-group.ts";
 import { T3Orchestration, type OpenThread } from "./service.ts";
 
-type ReconnectableRpcError = RpcClientError.RpcClientError | RpcError;
+type RpcRequestError = RpcClientError.RpcClientError | CliRpcRequestError;
 
 const rpcRetrySchedule = Schedule.exponential("100 millis").pipe(
   Schedule.take(4),
   Schedule.collectWhile(
-    (metadata: Schedule.Metadata<unknown, ReconnectableRpcError>) =>
-      metadata.input instanceof RpcClientError.RpcClientError,
+    (metadata: Schedule.Metadata) => metadata.input instanceof RpcClientError.RpcClientError,
   ),
 );
 
 function runRpc<A>(
   rpc: T3Rpc["Service"],
   method: string,
-  f: (client: WsClient) => Effect.Effect<A, ReconnectableRpcError>,
-) {
+  f: (client: WsClient) => Effect.Effect<A, RpcRequestError>,
+): Effect.Effect<A, RpcError> {
   return Effect.gen(function* () {
     const client = yield* rpc.getClient;
     return yield* f(client);
@@ -41,15 +42,13 @@ function runRpc<A>(
     ),
     Effect.retry(rpcRetrySchedule),
     Effect.catchTags({
-      RpcClientError: (error) =>
-        Effect.fail(
-          new RpcError({
-            message: error.message,
-            method,
-            cause: error,
-          }),
-        ),
       RpcError: (error) => Effect.fail(error),
+      EnvironmentAuthorizationError: (error) => Effect.fail(toRpcRequestError(error, method)),
+      RpcClientError: (error) => Effect.fail(toRpcRequestError(error, method)),
+      KeybindingsConfigParseError: (error) => Effect.fail(toRpcRequestError(error, method)),
+      OrchestrationDispatchCommandError: (error) => Effect.fail(toRpcRequestError(error, method)),
+      OrchestrationGetSnapshotError: (error) => Effect.fail(toRpcRequestError(error, method)),
+      ServerSettingsError: (error) => Effect.fail(toRpcRequestError(error, method)),
     }),
   );
 }
@@ -57,23 +56,21 @@ function runRpc<A>(
 function subscribeRpc<A>(
   rpc: T3Rpc["Service"],
   method: string,
-  f: (client: WsClient) => Stream.Stream<A, ReconnectableRpcError>,
-) {
+  f: (client: WsClient) => Stream.Stream<A, RpcRequestError>,
+): Stream.Stream<A, RpcError> {
   return Stream.unwrap(Effect.map(rpc.getClient, f)).pipe(
     Stream.tapError((error) =>
       error instanceof RpcClientError.RpcClientError ? rpc.disconnect : Effect.void,
     ),
     Stream.retry(rpcRetrySchedule),
     Stream.catchTags({
-      RpcClientError: (error) =>
-        Stream.fail(
-          new RpcError({
-            message: error.message,
-            method,
-            cause: error,
-          }),
-        ),
       RpcError: (error) => Stream.fail(error),
+      EnvironmentAuthorizationError: (error) => Stream.fail(toRpcRequestError(error, method)),
+      RpcClientError: (error) => Stream.fail(toRpcRequestError(error, method)),
+      KeybindingsConfigParseError: (error) => Stream.fail(toRpcRequestError(error, method)),
+      OrchestrationDispatchCommandError: (error) => Stream.fail(toRpcRequestError(error, method)),
+      OrchestrationGetSnapshotError: (error) => Stream.fail(toRpcRequestError(error, method)),
+      ServerSettingsError: (error) => Stream.fail(toRpcRequestError(error, method)),
     }),
   );
 }
@@ -83,20 +80,8 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
   const dispatch = Effect.fn("T3OrchestrationLive.dispatch")(function* (
     command: ClientOrchestrationCommand,
   ) {
-    const client = yield* rpc.getClient;
-    return yield* client[ORCHESTRATION_WS_METHODS.dispatchCommand](command).pipe(
-      Effect.tapErrorTag("RpcClientError", () => rpc.disconnect),
-      Effect.catchTags({
-        RpcClientError: (error) =>
-          Effect.fail(
-            new RpcError({
-              message: error.message,
-              method: ORCHESTRATION_WS_METHODS.dispatchCommand,
-              cause: error,
-            }),
-          ),
-        RpcError: (error) => Effect.fail(error),
-      }),
+    return yield* runRpc(rpc, ORCHESTRATION_WS_METHODS.dispatchCommand, (client) =>
+      client[ORCHESTRATION_WS_METHODS.dispatchCommand](command),
     );
   });
   const getServerConfig = Effect.fn("T3OrchestrationLive.getServerConfig")(function* () {
@@ -126,7 +111,7 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
   ) {
     const item = yield* Stream.runHead(
       subscribeRpc(rpc, ORCHESTRATION_WS_METHODS.subscribeThread, (client) =>
-        client[ORCHESTRATION_WS_METHODS.subscribeThread]({ threadId }),
+        client[ORCHESTRATION_WS_METHODS.subscribeThread]({ threadId: ThreadId.make(threadId) }),
       ),
     );
     const value = Option.getOrUndefined(item);
@@ -144,17 +129,17 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
     subscribeRpc(rpc, ORCHESTRATION_WS_METHODS.subscribeShell, (client) =>
       client[ORCHESTRATION_WS_METHODS.subscribeShell]({}),
     ).pipe(
-      Stream.map((item: ShellStreamItem) =>
+      Stream.map((item: OrchestrationShellStreamItem) =>
         item.kind === "snapshot" ? item.snapshot.snapshotSequence : item.sequence,
       ),
     );
   const watchThreadItems = (threadId: string) =>
     subscribeRpc(rpc, ORCHESTRATION_WS_METHODS.subscribeThread, (client) =>
-      client[ORCHESTRATION_WS_METHODS.subscribeThread]({ threadId }),
+      client[ORCHESTRATION_WS_METHODS.subscribeThread]({ threadId: ThreadId.make(threadId) }),
     );
   const openThread = Effect.fn("T3OrchestrationLive.openThread")(function* (threadId: string) {
     return yield* watchThreadItems(threadId).pipe(
-      Stream.peel(Sink.head<ThreadStreamItem>()),
+      Stream.peel(Sink.head<OrchestrationThreadStreamItem>()),
       Effect.flatMap(([item, rest]) => {
         const value = Option.getOrUndefined(item);
         if (value === undefined || value.kind !== "snapshot") {
@@ -169,7 +154,7 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
           snapshot: value.snapshot.thread,
           events: rest.pipe(
             Stream.filter(
-              (next): next is Extract<ThreadStreamItem, { readonly kind: "event" }> =>
+              (next): next is Extract<OrchestrationThreadStreamItem, { readonly kind: "event" }> =>
                 next.kind === "event",
             ),
             Stream.map((next) => next.event),
@@ -191,3 +176,11 @@ export const makeT3Orchestration = Effect.fn("makeT3Orchestration")(function* ()
 });
 
 export const T3OrchestrationLive = Layer.effect(T3Orchestration, makeT3Orchestration());
+
+function toRpcRequestError(error: RpcRequestError, method: string) {
+  return new RpcError({
+    message: error.message,
+    method,
+    cause: error,
+  });
+}

package/src/orchestration/service.ts

@@ -2,33 +2,42 @@ import * as Context from "effect/Context";
 import type * as Effect from "effect/Effect";
 import type * as Scope from "effect/Scope";
 import type * as Stream from "effect/Stream";
+import type {
+  ClientOrchestrationCommand,
+  DispatchResult,
+  OrchestrationEvent,
+  OrchestrationShellSnapshot,
+  OrchestrationThread,
+  OrchestrationThreadStreamItem,
+  ServerProviders,
+} from "@t3tools/contracts";
 
-import type { ClientOrchestrationCommand, DispatchResult } from "../domain/command-schema.ts";
-import type { ServerConfig, ShellSnapshot, ThreadDetail, ThreadEvent } from "../domain/schema.ts";
 import type { RpcError } from "../rpc/error.ts";
 
 export type OrchestrationError = RpcError;
 
 export type OpenThread = {
-  readonly snapshot: ThreadDetail;
-  readonly events: Stream.Stream<ThreadEvent, OrchestrationError>;
+  readonly snapshot: OrchestrationThread;
+  readonly events: Stream.Stream<OrchestrationEvent, OrchestrationError>;
 };
 
-export type ThreadStreamItem =
-  | { readonly kind: "snapshot"; readonly snapshot: { readonly thread: ThreadDetail } }
-  | { readonly kind: "event"; readonly event: ThreadEvent };
+export type ServerConfigForCli = {
+  readonly providers: ServerProviders;
+};
 
 export type Orchestration = {
   readonly dispatch: (
     command: ClientOrchestrationCommand,
   ) => Effect.Effect<DispatchResult, OrchestrationError>;
-  readonly getServerConfig: () => Effect.Effect<ServerConfig, OrchestrationError>;
-  readonly getShellSnapshot: () => Effect.Effect<ShellSnapshot, OrchestrationError>;
-  readonly getThreadSnapshot: (threadId: string) => Effect.Effect<ThreadDetail, OrchestrationError>;
+  readonly getServerConfig: () => Effect.Effect<ServerConfigForCli, OrchestrationError>;
+  readonly getShellSnapshot: () => Effect.Effect<OrchestrationShellSnapshot, OrchestrationError>;
+  readonly getThreadSnapshot: (
+    threadId: string,
+  ) => Effect.Effect<OrchestrationThread, OrchestrationError>;
   readonly watchShellSequence: () => Stream.Stream<number, OrchestrationError, Scope.Scope>;
   readonly watchThreadItems: (
     threadId: string,
-  ) => Stream.Stream<ThreadStreamItem, OrchestrationError, Scope.Scope>;
+  ) => Stream.Stream<OrchestrationThreadStreamItem, OrchestrationError, Scope.Scope>;
   readonly openThread: (
     threadId: string,
   ) => Effect.Effect<OpenThread, OrchestrationError, Scope.Scope>;

package/src/rpc/error.ts

@@ -1,4 +1,11 @@
 import * as Schema from "effect/Schema";
+import {
+  EnvironmentAuthorizationError,
+  KeybindingsConfigError,
+  OrchestrationDispatchCommandError,
+  OrchestrationGetSnapshotError,
+  ServerSettingsError,
+} from "@t3tools/contracts";
 import { HttpClientError } from "effect/unstable/http";
 import { RpcClientError } from "effect/unstable/rpc";
 
@@ -12,6 +19,11 @@ import { ConfigError, UrlError } from "../config/error.ts";
 
 const RpcErrorCauseSchema = Schema.Union([
   RpcClientError.RpcClientError,
+  EnvironmentAuthorizationError,
+  KeybindingsConfigError,
+  OrchestrationDispatchCommandError,
+  OrchestrationGetSnapshotError,
+  ServerSettingsError,
   AuthConfigError,
   AuthLocalError,
   AuthPairingUrlError,

package/src/rpc/layer.ts

@@ -14,11 +14,11 @@ import * as Socket from "effect/unstable/socket/Socket";
 import { T3Auth } from "../auth/service.ts";
 import { T3Config } from "../config/service.ts";
 import { toWebSocketBaseUrl } from "../config/url.ts";
-import { WsRpcGroup } from "../protocol/schema.ts";
+import { CliWsRpcGroup } from "./ws-group.ts";
 import { RpcError } from "./error.ts";
 import { T3Rpc, type WsClient } from "./service.ts";
 
-const makeClient = RpcClient.make(WsRpcGroup);
+const makeClient = RpcClient.make(CliWsRpcGroup);
 const connectionRetrySchedule = Schedule.exponential("100 millis").pipe(Schedule.take(4));
 
 type Connection = {

package/src/rpc/service.ts

@@ -1,11 +1,10 @@
 import * as Context from "effect/Context";
 import type * as Effect from "effect/Effect";
 import type { RpcClient, RpcClientError } from "effect/unstable/rpc";
-
-import type { WsRpcGroup } from "../protocol/schema.ts";
+import type { CliWsRpcGroup } from "./ws-group.ts";
 import type { RpcError } from "./error.ts";
 
-export type WsClient = RpcClient.FromGroup<typeof WsRpcGroup, RpcClientError.RpcClientError>;
+export type WsClient = RpcClient.FromGroup<typeof CliWsRpcGroup, RpcClientError.RpcClientError>;
 
 export type T3RpcService = {
   readonly getClient: Effect.Effect<WsClient, RpcError>;

package/src/rpc/ws-group.ts

@@ -0,0 +1,43 @@
+import {
+  EnvironmentAuthorizationError,
+  KeybindingsConfigError,
+  OrchestrationDispatchCommandError,
+  OrchestrationGetSnapshotError,
+  ServerConfig,
+  ServerProviders,
+  ServerSettingsError,
+  WS_METHODS,
+  WsOrchestrationDispatchCommandRpc,
+  WsOrchestrationSubscribeShellRpc,
+  WsOrchestrationSubscribeThreadRpc,
+} from "@t3tools/contracts";
+import * as Schema from "effect/Schema";
+import { Rpc, RpcGroup } from "effect/unstable/rpc";
+
+export const FallbackServerConfig = Schema.Struct({
+  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, {
+  payload: Schema.Struct({}),
+  success: CliServerConfig,
+  error: Schema.Union([KeybindingsConfigError, ServerSettingsError, EnvironmentAuthorizationError]),
+});
+
+export const CliWsRpcGroup = RpcGroup.make(
+  WsOrchestrationDispatchCommandRpc,
+  WsOrchestrationSubscribeShellRpc,
+  WsOrchestrationSubscribeThreadRpc,
+  WsServerGetConfigRpc,
+);
+
+export type CliRpcRequestError =
+  | EnvironmentAuthorizationError
+  | KeybindingsConfigError
+  | OrchestrationDispatchCommandError
+  | OrchestrationGetSnapshotError
+  | ServerSettingsError;

package/src/domain/command-schema.ts

@@ -1,82 +0,0 @@
-import * as Schema from "effect/Schema";
-
-import { ModelSelectionSchema } from "./schema.ts";
-
-export const DispatchResultSchema = Schema.Struct({
-  sequence: Schema.Number,
-});
-export type DispatchResult = typeof DispatchResultSchema.Type;
-
-export const ProjectCreateCommandSchema = Schema.Struct({
-  type: Schema.Literal("project.create"),
-  commandId: Schema.String,
-  projectId: Schema.String,
-  title: Schema.String,
-  workspaceRoot: Schema.String,
-  createdAt: Schema.String,
-});
-export type ProjectCreateCommand = typeof ProjectCreateCommandSchema.Type;
-
-export const ThreadCreateCommandSchema = Schema.Struct({
-  type: Schema.Literal("thread.create"),
-  commandId: Schema.String,
-  threadId: Schema.String,
-  projectId: Schema.String,
-  title: Schema.String,
-  modelSelection: ModelSelectionSchema,
-  runtimeMode: Schema.Literal("full-access"),
-  interactionMode: Schema.Literal("default"),
-  branch: Schema.Null,
-  worktreePath: Schema.NullOr(Schema.String),
-  createdAt: Schema.String,
-});
-export type ThreadCreateCommand = typeof ThreadCreateCommandSchema.Type;
-
-export const ThreadTurnStartCommandSchema = Schema.Struct({
-  type: Schema.Literal("thread.turn.start"),
-  commandId: Schema.String,
-  threadId: Schema.String,
-  message: Schema.Struct({
-    messageId: Schema.String,
-    role: Schema.Literal("user"),
-    text: Schema.String,
-    attachments: Schema.Array(Schema.Never),
-  }),
-  modelSelection: Schema.optionalKey(ModelSelectionSchema),
-  titleSeed: Schema.optionalKey(Schema.String),
-  runtimeMode: Schema.Literal("full-access"),
-  interactionMode: Schema.Literal("default"),
-  bootstrap: Schema.optionalKey(
-    Schema.Struct({
-      createThread: Schema.optionalKey(
-        Schema.Struct({
-          projectId: Schema.String,
-          title: Schema.String,
-          modelSelection: ModelSelectionSchema,
-          runtimeMode: Schema.Literal("full-access"),
-          interactionMode: Schema.Literal("default"),
-          branch: Schema.Null,
-          worktreePath: Schema.NullOr(Schema.String),
-          createdAt: Schema.String,
-        }),
-      ),
-    }),
-  ),
-  createdAt: Schema.String,
-});
-export type ThreadTurnStartCommand = typeof ThreadTurnStartCommandSchema.Type;
-
-export const ThreadArchiveCommandSchema = Schema.Struct({
-  type: Schema.Literal("thread.archive"),
-  commandId: Schema.String,
-  threadId: Schema.String,
-});
-export type ThreadArchiveCommand = typeof ThreadArchiveCommandSchema.Type;
-
-export const ClientOrchestrationCommandSchema = Schema.Union([
-  ProjectCreateCommandSchema,
-  ThreadArchiveCommandSchema,
-  ThreadCreateCommandSchema,
-  ThreadTurnStartCommandSchema,
-]);
-export type ClientOrchestrationCommand = typeof ClientOrchestrationCommandSchema.Type;

package/src/domain/schema.ts

@@ -1,162 +0,0 @@
-import * as Schema from "effect/Schema";
-
-export type Format = "human" | "json" | "ndjson";
-
-export const FormatSchema = Schema.Literals(["human", "json", "ndjson"]);
-
-export const ModelSelectionSchema = Schema.Struct({
-  instanceId: Schema.String,
-  model: Schema.String,
-  options: Schema.optionalKey(
-    Schema.Array(
-      Schema.Struct({
-        id: Schema.String,
-        value: Schema.Unknown,
-      }),
-    ),
-  ),
-});
-export type ModelSelection = typeof ModelSelectionSchema.Type;
-
-export const ProjectShellSchema = Schema.Struct({
-  id: Schema.String,
-  title: Schema.String,
-  workspaceRoot: Schema.String,
-  defaultModelSelection: Schema.NullOr(ModelSelectionSchema),
-  createdAt: Schema.String,
-  updatedAt: Schema.String,
-});
-export type ProjectShell = typeof ProjectShellSchema.Type;
-
-export const ThreadMessageSchema = Schema.Struct({
-  id: Schema.optionalKey(Schema.String),
-  messageId: Schema.optionalKey(Schema.String),
-  role: Schema.Literals(["user", "assistant", "system"]),
-  text: Schema.String,
-  streaming: Schema.optionalKey(Schema.Boolean),
-  turnId: Schema.optionalKey(Schema.NullOr(Schema.String)),
-  createdAt: Schema.String,
-  updatedAt: Schema.String,
-});
-export type ThreadMessage = typeof ThreadMessageSchema.Type;
-
-export const ThreadSessionSchema = Schema.Struct({
-  threadId: Schema.String,
-  status: Schema.Literals([
-    "idle",
-    "starting",
-    "running",
-    "ready",
-    "interrupted",
-    "stopped",
-    "error",
-  ]),
-  lastError: Schema.NullOr(Schema.String),
-  updatedAt: Schema.String,
-});
-export type ThreadSession = typeof ThreadSessionSchema.Type;
-
-export const ThreadShellSchema = Schema.Struct({
-  id: Schema.String,
-  projectId: Schema.String,
-  title: Schema.String,
-  modelSelection: ModelSelectionSchema,
-  runtimeMode: Schema.String,
-  interactionMode: Schema.String,
-  branch: Schema.NullOr(Schema.String),
-  worktreePath: Schema.NullOr(Schema.String),
-  latestTurn: Schema.NullOr(Schema.Struct({ state: Schema.String })),
-  createdAt: Schema.String,
-  updatedAt: Schema.String,
-  session: Schema.NullOr(ThreadSessionSchema),
-  latestUserMessageAt: Schema.optionalKey(Schema.NullOr(Schema.String)),
-});
-export type ThreadShell = typeof ThreadShellSchema.Type;
-
-export const ThreadDetailSchema = Schema.Struct({
-  id: Schema.String,
-  projectId: Schema.String,
-  title: Schema.String,
-  modelSelection: ModelSelectionSchema,
-  runtimeMode: Schema.String,
-  interactionMode: Schema.String,
-  branch: Schema.NullOr(Schema.String),
-  worktreePath: Schema.NullOr(Schema.String),
-  latestTurn: Schema.NullOr(Schema.Struct({ state: Schema.String })),
-  createdAt: Schema.String,
-  updatedAt: Schema.String,
-  session: Schema.NullOr(ThreadSessionSchema),
-  latestUserMessageAt: Schema.optionalKey(Schema.NullOr(Schema.String)),
-  messages: Schema.Array(ThreadMessageSchema),
-  activities: Schema.optionalKey(Schema.Array(Schema.Unknown)),
-});
-export type ThreadDetail = typeof ThreadDetailSchema.Type;
-
-export const ShellSnapshotSchema = Schema.Struct({
-  snapshotSequence: Schema.Number,
-  projects: Schema.Array(ProjectShellSchema),
-  threads: Schema.Array(ThreadShellSchema),
-  updatedAt: Schema.String,
-});
-export type ShellSnapshot = typeof ShellSnapshotSchema.Type;
-
-export const ServerProviderSchema = Schema.Struct({
-  instanceId: Schema.String,
-  displayName: Schema.optionalKey(Schema.String),
-  enabled: Schema.Boolean,
-  installed: Schema.Boolean,
-  status: Schema.Literals(["ready", "warning", "error", "disabled"]),
-  auth: Schema.Struct({
-    status: Schema.Literals(["authenticated", "unauthenticated", "unknown"]),
-  }),
-  models: Schema.Array(
-    Schema.Struct({
-      slug: Schema.String,
-      name: Schema.String,
-    }),
-  ),
-});
-export type ServerProvider = typeof ServerProviderSchema.Type;
-export type ServerProviderModel = NonNullable<ServerProvider["models"]>[number];
-
-export const ServerConfigSchema = Schema.Struct({
-  providers: Schema.optionalKey(Schema.Array(ServerProviderSchema)),
-});
-export type ServerConfig = typeof ServerConfigSchema.Type;
-
-export const ThreadMessageSentEventSchema = Schema.Struct({
-  type: Schema.Literal("thread.message-sent"),
-  payload: Schema.Struct({
-    messageId: Schema.String,
-    role: Schema.Literals(["user", "assistant", "system"]),
-    text: Schema.String,
-    turnId: Schema.NullOr(Schema.String),
-    streaming: Schema.optionalKey(Schema.Boolean),
-    createdAt: Schema.String,
-    updatedAt: Schema.String,
-  }),
-});
-export type ThreadMessageSentEvent = typeof ThreadMessageSentEventSchema.Type;
-
-export const ThreadSessionSetEventSchema = Schema.Struct({
-  type: Schema.Literal("thread.session-set"),
-  payload: Schema.Struct({
-    session: Schema.NullOr(ThreadSessionSchema),
-  }),
-});
-export type ThreadSessionSetEvent = typeof ThreadSessionSetEventSchema.Type;
-
-export const UnknownThreadEventSchema = Schema.Struct({
-  type: Schema.String,
-  payload: Schema.Record(Schema.String, Schema.Unknown),
-});
-export type UnknownThreadEvent = typeof UnknownThreadEventSchema.Type;
-
-export const ThreadEventSchema = Schema.Union([
-  ThreadMessageSentEventSchema,
-  ThreadSessionSetEventSchema,
-  UnknownThreadEventSchema,
-]);
-export type ThreadEvent = typeof ThreadEventSchema.Type;
-
-export const decodeModelSelection = Schema.decodeUnknownSync(ModelSelectionSchema);

package/src/protocol/schema.ts

@@ -1,105 +0,0 @@
-import * as Schema from "effect/Schema";
-import { Rpc, RpcGroup } from "effect/unstable/rpc";
-
-import {
-  ClientOrchestrationCommandSchema,
-  DispatchResultSchema,
-} from "../domain/command-schema.ts";
-import {
-  ProjectShellSchema,
-  ServerConfigSchema,
-  ShellSnapshotSchema,
-  ThreadDetailSchema,
-  ThreadEventSchema,
-  ThreadShellSchema,
-} from "../domain/schema.ts";
-import { RpcError } from "../rpc/error.ts";
-
-export const ORCHESTRATION_WS_METHODS = {
-  dispatchCommand: "orchestration.dispatchCommand",
-  subscribeShell: "orchestration.subscribeShell",
-  subscribeThread: "orchestration.subscribeThread",
-} as const;
-
-export const WS_METHODS = {
-  serverGetConfig: "server.getConfig",
-} as const;
-
-export const ThreadStreamItemSchema = Schema.Union([
-  Schema.Struct({
-    kind: Schema.Literal("snapshot"),
-    snapshot: Schema.Struct({ thread: ThreadDetailSchema }),
-  }),
-  Schema.Struct({
-    kind: Schema.Literal("event"),
-    event: ThreadEventSchema,
-  }),
-]);
-export type ThreadStreamItem = typeof ThreadStreamItemSchema.Type;
-
-export const ShellStreamItemSchema = Schema.Union([
-  Schema.Struct({
-    kind: Schema.Literal("snapshot"),
-    snapshot: ShellSnapshotSchema,
-  }),
-  Schema.Struct({
-    kind: Schema.Literal("project-upserted"),
-    sequence: Schema.Number,
-    project: ProjectShellSchema,
-  }),
-  Schema.Struct({
-    kind: Schema.Literal("project-removed"),
-    sequence: Schema.Number,
-    projectId: Schema.String,
-  }),
-  Schema.Struct({
-    kind: Schema.Literal("thread-upserted"),
-    sequence: Schema.Number,
-    thread: ThreadShellSchema,
-  }),
-  Schema.Struct({
-    kind: Schema.Literal("thread-removed"),
-    sequence: Schema.Number,
-    threadId: Schema.String,
-  }),
-]);
-export type ShellStreamItem = typeof ShellStreamItemSchema.Type;
-
-export const WsOrchestrationDispatchCommandRpc = Rpc.make(
-  ORCHESTRATION_WS_METHODS.dispatchCommand,
-  {
-    payload: ClientOrchestrationCommandSchema,
-    success: DispatchResultSchema,
-    error: RpcError,
-  },
-);
-
-export const WsOrchestrationSubscribeShellRpc = Rpc.make(ORCHESTRATION_WS_METHODS.subscribeShell, {
-  payload: Schema.Struct({}),
-  success: ShellStreamItemSchema,
-  error: RpcError,
-  stream: true,
-});
-
-export const WsOrchestrationSubscribeThreadRpc = Rpc.make(
-  ORCHESTRATION_WS_METHODS.subscribeThread,
-  {
-    payload: Schema.Struct({ threadId: Schema.String }),
-    success: ThreadStreamItemSchema,
-    error: RpcError,
-    stream: true,
-  },
-);
-
-export const WsServerGetConfigRpc = Rpc.make(WS_METHODS.serverGetConfig, {
-  payload: Schema.Struct({}),
-  success: ServerConfigSchema,
-  error: RpcError,
-});
-
-export const WsRpcGroup = RpcGroup.make(
-  WsOrchestrationDispatchCommandRpc,
-  WsOrchestrationSubscribeShellRpc,
-  WsOrchestrationSubscribeThreadRpc,
-  WsServerGetConfigRpc,
-);