feat(mcp): expose thread search#8722

@@ -0,0 +1,132 @@
+import {
+  OrchestratorMcpFailure,
+  type OrchestratorMcpThreadSearchInput,
+  type OrchestratorMcpThreadSearchResult,
+} from "@t3tools/contracts";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+
+import { ThreadManagementService } from "../orchestration-v2/ThreadManagementService.ts";
+import {
+  ProjectionSnapshotQuery,
+  ProjectionThreadContentSearchInputError,
+} from "../orchestration/Services/ProjectionSnapshotQuery.ts";
+import type { McpInvocationScope } from "./McpInvocationContext.ts";
+
+const DEFAULT_LIMIT = 20;
+const DEFAULT_SNIPPET_CHARS = 240;
+const isProjectionThreadContentSearchInputError = Schema.is(
+  ProjectionThreadContentSearchInputError,
+);
+
+export interface ThreadSearchMcpServiceShape {
+  readonly search: (
+    scope: McpInvocationScope,
+    input: OrchestratorMcpThreadSearchInput,
+  ) => Effect.Effect<OrchestratorMcpThreadSearchResult, OrchestratorMcpFailure>;
+}
+
+export class ThreadSearchMcpService extends Context.Service<
+  ThreadSearchMcpService,
+  ThreadSearchMcpServiceShape
+>()("t3/mcp/ThreadSearchMcpService") {}
+
+function failure(code: OrchestratorMcpFailure["code"], message: string): OrchestratorMcpFailure {
+  return new OrchestratorMcpFailure({ code, message });
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+const make = Effect.gen(function* () {
+  const threadManagement = yield* ThreadManagementService;
+  const projectionQuery = yield* ProjectionSnapshotQuery;
+
+  const loadShell = (threadId: McpInvocationScope["threadId"]) =>
+    threadManagement.getThreadShell(threadId).pipe(
+      Effect.mapError((error) =>
+        failure("orchestration_error", `Unable to read thread ${threadId}: ${errorMessage(error)}`),
+      ),
+      Effect.flatMap((shell) =>
+        shell === null
+          ? Effect.fail(failure("thread_not_found", `Thread ${threadId} was not found.`))
+          : Effect.succeed(shell),
+      ),
+    );
+
+  return {
+    search: (scope, input) =>
+      Effect.gen(function* () {
+        if (!scope.capabilities.has("orchestration")) {
+          return yield* failure(
+            "capability_denied",
+            "This MCP credential does not grant orchestration capabilities.",
+          );
+        }
+
+        const caller = yield* loadShell(scope.threadId);
+        if (input.threadId !== undefined) {
+          const target = yield* loadShell(input.threadId);
+          if (target.projectId !== caller.projectId) {
+            return yield* failure(
+              "thread_not_found",
+              `Thread ${input.threadId} was not found in this project.`,
+            );
+          }
+        }
+
+        const page = yield* projectionQuery

@@ -0,0 +1,127 @@
+import {
+  OrchestratorMcpFailure,
+  type OrchestratorMcpThreadSearchInput,
+  type OrchestratorMcpThreadSearchResult,
+} from "@t3tools/contracts";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import { ThreadManagementService } from "../orchestration-v2/ThreadManagementService.ts";
+import {
+  ProjectionSnapshotQuery,
+  ProjectionThreadContentSearchInputError,
+} from "../orchestration/Services/ProjectionSnapshotQuery.ts";
+import type { McpInvocationScope } from "./McpInvocationContext.ts";
+
+const DEFAULT_LIMIT = 20;
+const DEFAULT_SNIPPET_CHARS = 240;
+
+export interface ThreadSearchMcpServiceShape {
+  readonly search: (
+    scope: McpInvocationScope,
+    input: OrchestratorMcpThreadSearchInput,
+  ) => Effect.Effect<OrchestratorMcpThreadSearchResult, OrchestratorMcpFailure>;
+}
+
+export class ThreadSearchMcpService extends Context.Service<
+  ThreadSearchMcpService,
+  ThreadSearchMcpServiceShape
+>()("t3/mcp/ThreadSearchMcpService") {}

@@ -301,14 +302,86 @@ export const OrchestratorMcpThreadListResult = Schema.Struct({
 });
 export type OrchestratorMcpThreadListResult = typeof OrchestratorMcpThreadListResult.Type;
 
+export const OrchestratorMcpThreadSearchInput = Schema.Struct({
+  query: TrimmedString.check(Schema.isMinLength(2), Schema.isMaxLength(200)).annotate({
+    description: "Literal text to find; %, _, and ! are ordinary characters.",
+  }),
+  threadId: Schema.optional(
+    ThreadId.annotate({ description: "Optional thread in the calling project to search." }),
+  ),
+  includeArchived: Schema.optional(
+    Schema.Boolean.annotate({
+      description: "Include archived threads. Defaults to false; deleted threads stay excluded.",
+    }),
+  ),
+  cursor: Schema.optional(
+    NonNegativeInt.check(Schema.isLessThanOrEqualTo(10_000)).annotate({
+      description: "Live-query continuation cursor returned by the previous page.",
+    }),
+  ),
+  limit: Schema.optional(PositiveInt.check(Schema.isLessThanOrEqualTo(50))),
+  snippetChars: Schema.optional(
+    PositiveInt.check(Schema.isBetween({ minimum: 64, maximum: 1_000 })).annotate({
+      description: "Maximum Unicode characters in each returned snippet. Defaults to 240.",
+    }),
+  ),
+});
+export type OrchestratorMcpThreadSearchInput = typeof OrchestratorMcpThreadSearchInput.Type;
+
+export const OrchestratorMcpThreadReadAnchor = Schema.Struct({
+  sourceThreadId: ThreadId,
+  messageId: MessageId,
+});
+export type OrchestratorMcpThreadReadAnchor = typeof OrchestratorMcpThreadReadAnchor.Type;
+
+export const OrchestratorMcpThreadSearchHit = Schema.Struct({
+  threadId: ThreadId,
+  projectId: ProjectId,
+  threadTitle: Schema.String,
+  threadTitleTruncated: Schema.Boolean,
+  archived: Schema.Boolean,
+  source: Schema.Literals(["title", "user", "assistant"]),
+  origin: Schema.Literals(["legacy", "v2"]),
+  snippet: Schema.String.check(Schema.isMaxLength(1_000)),