t3code-cli 0.5.1 → 0.7.0

package/dist/url-SlsaG8nY.js

@@ -0,0 +1,165 @@
+import { On as dual } from "./Context-DueQ9iMH.js";
+import { H as fromResult, Tt as succeed, b as catchTags, cn as IllegalArgumentError, j as flatMap, k as fail, mi as try_ } from "./Path-D8WPdPwR.js";
+import { n as UrlError } from "./error-BHRnjLux.js";
+//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/unstable/http/Url.js
+/**
+* Immutable helpers for parsing and editing platform `URL` values.
+*
+* This module keeps the WHATWG `URL` object as the URL representation used by
+* HTTP clients and servers, then adds safe parsing and pipeable setters for
+* credentials, host, path, protocol, query, and hash components. Query strings
+* can be read, replaced, or transformed through `UrlParams` so repeated keys and
+* key/value encoding stay explicit.
+*
+* **Mental model**
+*
+* `fromString` returns a `Result` instead of throwing when URL construction
+* fails. Setters never mutate the original `URL`; each one clones the input and
+* assigns the requested component on the clone. Use `mutate` when several
+* component assignments should happen on the same clone.
+*
+* **Common tasks**
+*
+* - Parse absolute URLs, or resolve relative URL strings against a base URL.
+* - Pipe setters to adjust host, protocol, path, credentials, search, or hash.
+* - Extract query parameters with `urlParams`.
+* - Replace or transform query parameters with `setUrlParams` and
+*   `modifyUrlParams`.
+*
+* **Gotchas**
+*
+* Relative input needs an explicit base. Component assignment and serialization
+* follow platform `URL` rules, so values may be normalized or percent-encoded.
+* `setPassword` accepts `Redacted` input, but the resulting `URL` still contains
+* the actual credential and should be treated as sensitive when serialized.
+*
+* @since 4.0.0
+*/
+/**
+* Parses a URL string safely into a `URL` object, returning a `Result` type for
+* error handling.
+*
+* **Details**
+*
+* This function converts a string into a `URL` object, enabling safe URL
+* parsing with built-in error handling. If the string is invalid or fails to
+* parse, this function does not throw an error; instead, it wraps the error in
+* a `IllegalArgumentError` and returns it as the `Failure` value of an
+* `Result`. The `Success` value contains the successfully parsed `URL`.
+*
+* An optional `base` parameter can be provided to resolve relative URLs. If
+* specified, the function interprets the input `url` as relative to this
+* `base`. This is especially useful when dealing with URLs that might not be
+* fully qualified.
+*
+* **Example** (Parsing absolute and relative URLs)
+*
+* ```ts
+* import { Result } from "effect"
+* import { Url } from "effect/unstable/http"
+*
+* // Parse an absolute URL
+* //
+* //      ┌─── Result<URL, IllegalArgumentError>
+* //      ▼
+* const parsed = Url.fromString("https://example.com/path")
+*
+* if (Result.isSuccess(parsed)) {
+*   console.log("Parsed URL:", parsed.success.toString())
+* } else {
+*   console.log("Error:", parsed.failure.message)
+* }
+* // Output: Parsed URL: https://example.com/path
+*
+* // Parse a relative URL with a base
+* const relativeParsed = Url.fromString("/relative-path", "https://example.com")
+*
+* if (Result.isSuccess(relativeParsed)) {
+*   console.log("Parsed relative URL:", relativeParsed.success.toString())
+* } else {
+*   console.log("Error:", relativeParsed.failure.message)
+* }
+* // Output: Parsed relative URL: https://example.com/relative-path
+* ```
+*
+* @category constructors
+* @since 4.0.0
+*/
+const fromString = (url, base) => try_({
+	try: () => new URL(url, base),
+	catch: () => new IllegalArgumentError(`Invalid URL: "${url}"${base !== void 0 ? ` with base "${base}"` : ""}`)
+});
+/**
+* Updates a cloned `URL` with a callback, allowing multiple changes at once.
+*
+* **Example** (Mutating URL credentials)
+*
+* ```ts
+* import { Url } from "effect/unstable/http"
+*
+* const myUrl = new URL("https://example.com")
+*
+* const mutatedUrl = Url.mutate(myUrl, (url) => {
+*   url.username = "user"
+*   url.password = "pass"
+* })
+*
+* console.log("Mutated:", mutatedUrl.toString())
+* // Output: Mutated: https://user:pass@example.com/
+* ```
+*
+* @category modifiers
+* @since 4.0.0
+*/
+const mutate = /*#__PURE__*/ dual(2, (self, f) => {
+	const copy = new URL(self);
+	f(copy);
+	return copy;
+});
+//#endregion
+//#region src/config/url.ts
+function normalizeHttpBaseUrl(value) {
+	return parseUrl(value).pipe(flatMap((url) => succeed(normalizeBaseUrl(url))));
+}
+function toHttpEndpointUrl(httpBaseUrl, pathname) {
+	return parseUrl(httpBaseUrl).pipe(flatMap((url) => succeed(withPathname(url, pathname).toString())));
+}
+function toWebSocketEndpointUrl(httpBaseUrl, pathname) {
+	return parseUrl(httpBaseUrl).pipe(flatMap((url) => {
+		if (url.protocol === "http:") return succeed(withPathname(url, pathname, "ws:").toString());
+		if (url.protocol === "https:") return succeed(withPathname(url, pathname, "wss:").toString());
+		return fail(new UrlError({
+			message: `unsupported server url protocol: ${url.protocol}`,
+			protocol: url.protocol
+		}));
+	}));
+}
+function parseUrl(value) {
+	return fromResult(fromString(value)).pipe(catchTags({ IllegalArgumentError: (error) => fail(new UrlError({
+		message: "invalid url",
+		cause: error
+	})) }));
+}
+function normalizeBaseUrl(url) {
+	return mutate(url, (current) => {
+		current.hash = "";
+		current.search = "";
+		current.pathname = normalizePathname(current.pathname);
+	}).toString().replace(/\/$/, "");
+}
+function withPathname(url, pathname, protocol) {
+	return mutate(url, (current) => {
+		if (protocol !== void 0) current.protocol = protocol;
+		current.pathname = appendPathname(current.pathname, pathname);
+		current.search = "";
+		current.hash = "";
+	});
+}
+function normalizePathname(pathname) {
+	return pathname === "/" ? "" : pathname.replace(/\/+$/u, "");
+}
+function appendPathname(basePathname, pathname) {
+	return `${normalizePathname(basePathname)}${pathname.startsWith("/") ? pathname : `/${pathname}`}`;
+}
+//#endregion
+export { mutate as a, fromString as i, toHttpEndpointUrl as n, toWebSocketEndpointUrl as r, normalizeHttpBaseUrl as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "t3code-cli",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "CLI for t3code",
   "keywords": [
     "claude",
@@ -37,6 +37,54 @@
     ".": {
       "types": "./dist/src/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./application": {
+      "types": "./dist/src/application/index.d.ts",
+      "default": "./dist/application.js"
+    },
+    "./auth": {
+      "types": "./dist/src/auth/index.d.ts",
+      "default": "./dist/auth.js"
+    },
+    "./cli": {
+      "types": "./dist/src/cli/index.d.ts",
+      "default": "./dist/cli.js"
+    },
+    "./config": {
+      "types": "./dist/src/config/index.d.ts",
+      "default": "./dist/config.js"
+    },
+    "./connection": {
+      "types": "./dist/src/connection/index.d.ts",
+      "default": "./dist/connection.js"
+    },
+    "./contracts": {
+      "types": "./dist/src/contracts/index.d.ts",
+      "default": "./dist/contracts.js"
+    },
+    "./t3tools": {
+      "types": "./dist/upstream-t3code/packages/contracts/src/index.d.ts",
+      "default": "./dist/t3tools.js"
+    },
+    "./layout": {
+      "types": "./dist/src/layout/index.d.ts",
+      "default": "./dist/layout.js"
+    },
+    "./orchestration": {
+      "types": "./dist/src/orchestration/index.d.ts",
+      "default": "./dist/orchestration.js"
+    },
+    "./rpc": {
+      "types": "./dist/src/rpc/index.d.ts",
+      "default": "./dist/rpc.js"
+    },
+    "./runtime": {
+      "types": "./dist/src/runtime/index.d.ts",
+      "default": "./dist/runtime.js"
+    },
+    "./scope": {
+      "types": "./dist/src/scope/index.d.ts",
+      "default": "./dist/scope.js"
     }
   },
   "dependencies": {
@@ -45,13 +93,15 @@
   },
   "devDependencies": {
     "@changesets/cli": "^2.31.0",
+    "@effect/vitest": "4.0.0-beta.78",
+    "@total-typescript/shoehorn": "^0.1.2",
     "@types/node": "^25.9.1",
     "typescript": "^6.0.3",
     "vite-plus": "^0.1.24",
     "@t3tools/contracts": "0.0.24"
   },
   "engines": {
-    "node": "^24.0.0"
+    "node": ">=24.0.0"
   },
   "scripts": {
     "build": "vp pack && tsc -p tsconfig.dts.json",
@@ -60,7 +110,9 @@
     "format:check": "vp fmt --check",
     "lint": "vp lint",
     "lint:fix": "vp lint --fix",
+    "test": "vp test run",
     "changeset": "changeset",
+    "release:version": "changeset version && pnpm format",
     "release:check": "pnpm check && pnpm typecheck && pnpm pack --dry-run",
     "release:publish": "changeset publish",
     "typecheck": "tsc --noEmit"

package/src/application/index.ts

@@ -0,0 +1,3 @@
+export { T3Application } from "./service.ts";
+export type { SendThreadInput, StartThreadInput, StartThreadPolicy, WaitEvent } from "./service.ts";
+export type { ApplicationError } from "./error.ts";

package/src/application/service.ts

@@ -15,7 +15,7 @@ import type {
 import type { ApplicationError } from "./error.ts";
 
 export type StartThreadInput = {
-  readonly projectRef: string;
+  readonly projectRef?: string;
   readonly message: string;
   readonly title?: string;
   readonly provider?: string;

package/src/application/threads.ts

@@ -4,8 +4,8 @@ import * as Path from "effect/Path";
 
 import { Environment } from "../environment/service.ts";
 import { T3Orchestration } from "../orchestration/service.ts";
-import { ThreadSessionError } from "../domain/error.ts";
-import { resolveProject } from "../domain/helpers.ts";
+import { ProjectLookupError, ThreadSessionError } from "../domain/error.ts";
+import { resolveProjectScope } from "../domain/helpers.ts";
 import { type StartThreadInput } from "./service.ts";
 import type { SendThreadInput } from "./service.ts";
 import { mergeModelOptions } from "./model-selection.ts";
@@ -27,10 +27,17 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
   const environment = yield* Environment;
   const listThreads = Effect.fn("T3ApplicationLive.listThreads")(function* (projectRef: string) {
     const snapshot = yield* orchestration.getShellSnapshot();
-    const project = resolveProject(snapshot, projectRef, path, environment.cwd);
+    const scope = yield* resolveProjectScope(snapshot, {
+      ref: projectRef,
+    }).pipe(Effect.provideService(Path.Path, path));
+    if (scope === undefined) {
+      return yield* Effect.fail(
+        new ProjectLookupError({ message: `project not found: ${projectRef}`, ref: projectRef }),
+      );
+    }
     return {
-      project,
-      threads: snapshot.threads.filter((thread) => thread.projectId === project.id),
+      project: scope.project,
+      threads: snapshot.threads.filter((thread) => thread.projectId === scope.project.id),
     };
   });
   const getThreadMessages = Effect.fn("T3ApplicationLive.getThreadMessages")(function* (
@@ -51,11 +58,31 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
     },
   ) {
     const snapshot = yield* orchestration.getShellSnapshot();
-    const project = resolveProject(snapshot, startInput.projectRef, path, environment.cwd);
+    const projectRef = startInput.projectRef;
+    if (projectRef === undefined) {
+      return yield* Effect.fail(
+        new ProjectLookupError({
+          message: "project is required",
+          ref: environment.cwd,
+        }),
+      );
+    }
+    const scope = yield* resolveProjectScope(snapshot, {
+      ref: projectRef,
+    }).pipe(Effect.provideService(Path.Path, path));
+    if (scope === undefined) {
+      return yield* Effect.fail(
+        new ProjectLookupError({ message: `project not found: ${projectRef}`, ref: projectRef }),
+      );
+    }
+    const worktreePath = startInput.worktreePath ?? scope.inferredWorktreePath;
     const serverConfig = yield* orchestration.getServerConfig();
     const commands = yield* makeThreadStartCommands({
-      start: startInput,
-      project,
+      start: {
+        ...startInput,
+        ...(worktreePath !== undefined ? { worktreePath } : {}),
+      },
+      project: scope.project,
       serverConfig,
     }).pipe(Effect.provideService(Crypto.Crypto, crypto));
     const createDispatch = yield* orchestration.dispatch(commands.createCommand);
@@ -67,7 +94,7 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
     const threadId = commands.threadId;
     const until = policy?.until ?? "dispatch";
     if (until === "dispatch") {
-      return { dispatch, project, threadId };
+      return { dispatch, project: scope.project, threadId };
     }
     yield* waitForShellSequence({
       orchestration,
@@ -80,14 +107,14 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
           return opened.snapshot;
         }),
       );
-      return { dispatch, project, threadId, thread };
+      return { dispatch, project: scope.project, threadId, thread };
     }
     const thread = yield* waitForThreadUntilComplete({
       orchestration,
       threadId,
     });
     yield* failIfThreadError(thread);
-    return { dispatch, project, threadId, thread };
+    return { dispatch, project: scope.project, threadId, thread };
   });
   const sendThread = Effect.fn("T3ApplicationLive.sendThread")(function* (
     input: SendThreadInput,

package/src/auth/index.ts

@@ -0,0 +1,28 @@
+export { T3Auth } from "./service.ts";
+export { T3AuthLive, makeT3Auth } from "./layer.ts";
+export { T3LocalAuth, T3LocalAuthLive, makeT3LocalAuth } from "./local.ts";
+export { T3LocalAuthOrigin, T3LocalAuthOriginLive, makeT3LocalAuthOrigin } from "./local-origin.ts";
+export { T3LocalAuthToken, T3LocalAuthTokenLive, makeT3LocalAuthToken } from "./local-token.ts";
+export { T3AuthPairing, T3AuthPairingLive, makeT3AuthPairing, parsePairingUrl } from "./pairing.ts";
+export {
+  AuthConfigError,
+  AuthLocalDatabaseError,
+  AuthLocalError,
+  AuthLocalSecretError,
+  AuthLocalSigningError,
+  AuthPairingUrlError,
+  AuthTransportError,
+} from "./error.ts";
+export type { AuthError } from "./error.ts";
+export type { AuthSessionState, AuthWebSocketTicketResult } from "./schema.ts";
+export type {
+  AuthConfigInput,
+  AuthSessionRole,
+  LocalAuthInput,
+  LocalAuthOriginInput,
+  LocalAuthResult,
+  LocalAuthTokenInput,
+  LocalAuthTokenResult,
+  PairingUrl,
+  PairResult,
+} from "./type.ts";

package/src/auth/layer.ts

@@ -46,12 +46,19 @@ export const makeT3Auth = Effect.fn("makeT3Auth")(function* () {
           Effect.fail(new AuthConfigError({ message: "auth config failed", cause: error })),
       }),
     );
-    yield* config.writeStored({ ...existing, url: input.url, token: input.token }).pipe(
-      Effect.catchTags({
-        ConfigError: (error) =>
-          Effect.fail(new AuthConfigError({ message: "auth config failed", cause: error })),
-      }),
-    );
+    yield* config
+      .writeStored({
+        ...existing,
+        url: input.url,
+        token: input.token,
+        ...(input.local !== undefined ? { local: input.local } : {}),
+      })
+      .pipe(
+        Effect.catchTags({
+          ConfigError: (error) =>
+            Effect.fail(new AuthConfigError({ message: "auth config failed", cause: error })),
+        }),
+      );
   });
 
   return {

package/src/auth/local-base-dir.ts

@@ -1,22 +1,18 @@
-import type * as Path from "effect/Path";
+import * as Effect from "effect/Effect";
 
-import type { EnvironmentShape } from "../environment/service.ts";
+import { Environment } from "../environment/service.ts";
+import { resolveT3BaseDir } from "../layout/base-dir.ts";
 
-export function resolveLocalBaseDir(input: {
-  readonly baseDir: string | undefined;
-  readonly environment: EnvironmentShape;
-  readonly path: Path.Path;
+export const resolveLocalBaseDir = Effect.fn("resolveLocalBaseDir")(function* (input: {
+  readonly baseDir?: string | undefined;
 }) {
-  const envBaseDir = input.environment.env["T3CODE_HOME"];
-  const raw = input.baseDir ?? envBaseDir;
-  if (raw === undefined || raw.length === 0) {
-    return input.path.join(input.environment.homeDir, ".t3");
-  }
-  if (raw === "~") {
-    return input.environment.homeDir;
-  }
-  if (raw.startsWith("~/") || raw.startsWith("~\\")) {
-    return input.path.join(input.environment.homeDir, raw.slice(2));
-  }
-  return input.path.resolve(input.environment.cwd, raw);
-}
+  const environment = yield* Environment;
+  return yield* resolveT3BaseDir({
+    layout: {
+      cwd: environment.cwd,
+      homeDir: environment.homeDir,
+      t3codeHome: environment.env["T3CODE_HOME"],
+    },
+    baseDir: input.baseDir,
+  });
+});

package/src/auth/local-origin.ts

@@ -26,7 +26,10 @@ export const makeT3LocalAuthOrigin = Effect.fn("makeT3LocalAuthOrigin")(function
   const resolve = Effect.fn("T3LocalAuthOriginLive.resolve")(function* (
     input?: LocalAuthOriginInput,
   ) {
-    const baseDir = resolveLocalBaseDir({ baseDir: input?.baseDir, environment, path });
+    const baseDir = yield* resolveLocalBaseDir({ baseDir: input?.baseDir }).pipe(
+      Effect.provideService(Environment, environment),
+      Effect.provideService(Path.Path, path),
+    );
     if (input?.origin !== undefined) {
       return yield* normalizeLocalOrigin(input.origin);
     }

package/src/auth/local-token.ts

@@ -185,7 +185,10 @@ export const makeT3LocalAuthToken = Effect.fn("makeT3LocalAuthToken")(function*
       );
     }
 
-    const baseDir = resolveLocalBaseDir({ baseDir: input.baseDir, environment, path });
+    const baseDir = yield* resolveLocalBaseDir({ baseDir: input.baseDir }).pipe(
+      Effect.provideService(Environment, environment),
+      Effect.provideService(Path.Path, path),
+    );
     const session = yield* issueLocalDatabaseSession({
       dbPath: path.join(baseDir, "userdata", "state.sqlite"),
       secretsDir: path.join(baseDir, "userdata", "secrets"),

package/src/auth/type.ts

@@ -10,6 +10,7 @@ export type PairingUrl = {
 export type AuthConfigInput = {
   readonly url: string;
   readonly token: string;
+  readonly local?: boolean;
 };
 
 export type PairResult = {

package/src/bin.ts

@@ -10,7 +10,7 @@ import { NodeEnvironmentLive } from "./environment/layer.ts";
 import { T3InputLive } from "./cli/input/layer.ts";
 import { T3OutputLive } from "./cli/output/layer.ts";
 import { T3Output } from "./cli/output/service.ts";
-import { AppLayer } from "./runtime.ts";
+import { AppLayer } from "./runtime/layer.ts";
 import { T3VersionBundledLive, T3VersionPackageJsonLive } from "./version/layer.ts";
 import { T3Version } from "./version/service.ts";
 

package/src/cli/app.ts

@@ -1,18 +1,18 @@
 import { Command } from "effect/unstable/cli";
 
 import { createAuthCommand } from "./auth.ts";
-import { createModelsCommand } from "./models.ts";
-import { createProjectsCommand } from "./projects.ts";
-import { createThreadsCommand } from "./threads.ts";
+import { createModelCommand } from "./model.ts";
+import { createProjectCommand } from "./project.ts";
+import { createThreadCommand } from "./thread.ts";
 
 export function createCliCommand() {
   return Command.make("t3cli").pipe(
     Command.withDescription("non-interactive cli for running t3code server"),
     Command.withSubcommands([
       createAuthCommand(),
-      createModelsCommand(),
-      createProjectsCommand(),
-      createThreadsCommand(),
+      createModelCommand(),
+      createProjectCommand(),
+      createThreadCommand(),
     ]),
   );
 }

package/src/cli/auth-format.ts

@@ -25,6 +25,7 @@ export function formatAuthStatusHuman(input: {
 }) {
   return [
     `url: ${input.config.url}`,
+    `local: ${input.config.local ? "yes" : "no"}`,
     `authenticated: ${input.result.authenticated ? "yes" : "no"}`,
     ...(input.result.role !== undefined ? [`role: ${input.result.role}`] : []),
     ...(input.result.expiresAt !== undefined ? [`expires: ${input.result.expiresAt}`] : []),
@@ -39,5 +40,6 @@ export function formatAuthStatusJson(input: {
     ...input.result,
     url: input.config.url,
     source: input.config.source,
+    local: input.config.local,
   };
 }

package/src/cli/auth.ts

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
-import { Argument, Command, Flag } from "effect/unstable/cli";
+import { Command, Flag } from "effect/unstable/cli";
 
 import {
   formatAuthLocalHuman,
@@ -12,7 +12,8 @@ import {
 import { T3Auth } from "../auth/service.ts";
 import { T3Config } from "../config/service.ts";
 import { Environment } from "../environment/service.ts";
-import { humanJsonFormatChoices, resolveOutputFormat } from "./output-format.ts";
+import { formatFlag } from "./flags.ts";
+import { resolveOutputFormat } from "./output-format.ts";
 import { T3Output } from "./output/service.ts";
 
 export function createAuthCommand() {
@@ -25,17 +26,22 @@ export function createAuthCommand() {
 const pairCommand = Command.make(
   "pair",
   {
-    url: Argument.string("url"),
-    format: Flag.choice("format", humanJsonFormatChoices).pipe(Flag.withDefault("auto")),
+    url: Flag.string("url"),
+    local: Flag.boolean("local"),
+    format: formatFlag,
   },
-  ({ url, format }) =>
+  ({ url, local, format }) =>
     Effect.gen(function* () {
       const auth = yield* T3Auth;
       const environment = yield* Environment;
       const output = yield* T3Output;
       const resolvedFormat = resolveOutputFormat(format, environment, "json");
       const result = yield* auth.pair(url);
-      yield* auth.writeConfig(result);
+      yield* auth.writeConfig({
+        url: result.url,
+        token: result.token,
+        local,
+      });
       if (resolvedFormat === "json") {
         yield* output.printJson(result);
       } else {
@@ -52,7 +58,7 @@ const localCommand = Command.make(
     role: Flag.choice("role", ["owner", "client"] as const).pipe(Flag.withDefault("owner")),
     label: Flag.string("label").pipe(Flag.withDefault("t3cli")),
     subject: Flag.string("subject").pipe(Flag.withDefault("t3cli-local")),
-    format: Flag.choice("format", humanJsonFormatChoices).pipe(Flag.withDefault("auto")),
+    format: formatFlag,
   },
   ({ baseDir, origin, role, label, subject, format }) =>
     Effect.gen(function* () {
@@ -67,7 +73,11 @@ const localCommand = Command.make(
         ...(Option.isSome(baseDir) ? { baseDir: baseDir.value } : {}),
         ...(Option.isSome(origin) ? { origin: origin.value } : {}),
       });
-      yield* auth.writeConfig(result);
+      yield* auth.writeConfig({
+        url: result.url,
+        token: result.token,
+        local: true,
+      });
       if (resolvedFormat === "json") {
         yield* output.printJson(formatAuthLocalJson(result));
       } else {
@@ -79,7 +89,7 @@ const localCommand = Command.make(
 const statusCommand = Command.make(
   "status",
   {
-    format: Flag.choice("format", humanJsonFormatChoices).pipe(Flag.withDefault("auto")),
+    format: formatFlag,
   },
   ({ format }) =>
     Effect.gen(function* () {

package/src/cli/error.ts

@@ -14,3 +14,10 @@ export class InvalidLimitError extends Schema.TaggedErrorClass<InvalidLimitError
     value: Schema.String,
   },
 ) {}
+
+export class MissingThreadError extends Schema.TaggedErrorClass<MissingThreadError>()(
+  "MissingThreadError",
+  {
+    message: Schema.String,
+  },
+) {}