feat(mcp): update thread metadata#8690

@@ -376,7 +391,8 @@ orchestration_error
 ## Code Ownership
 
 - Shared schemas: `packages/contracts/src/orchestratorMcp.ts`

@@ -0,0 +1,218 @@
+import {
+  CommandId,
+  OrchestratorMcpFailure,
+  type OrchestrationV2AppThread,
+  type OrchestrationV2Command,
+  type ThreadMetadataMcpAction,
+  type ThreadMetadataMcpUpdateInput,
+  type ThreadMetadataMcpUpdateResult,
+  ThreadId,
+} from "@t3tools/contracts";
+import * as Context from "effect/Context";
+import * as Crypto from "effect/Crypto";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import {
+  ThreadManagementError,
+  ThreadManagementService,
+} from "../orchestration-v2/ThreadManagementService.ts";
+import type { McpInvocationScope } from "./McpInvocationContext.ts";
+
+export class ThreadMetadataMcpService extends Context.Service<
+  ThreadMetadataMcpService,
+  {
+    readonly update: (
+      scope: McpInvocationScope,
+      input: ThreadMetadataMcpUpdateInput,
+    ) => Effect.Effect<ThreadMetadataMcpUpdateResult, OrchestratorMcpFailure>;
+  }
+>()("t3/mcp/ThreadMetadataMcpService") {}
+
+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);
+}
+
+function threadLookupFailure(error: ThreadManagementError): OrchestratorMcpFailure {
+  return error._tag === "ThreadManagementThreadNotFoundError"
+    ? failure("thread_not_found", error.message)
+    : failure("orchestration_error", error.message);
+}
+
+function stablePart(value: string): string {
+  return encodeURIComponent(value);
+}
+
+function commandId(input: {
+  readonly scope: McpInvocationScope;
+  readonly threadId: ThreadId;
+  readonly action: ThreadMetadataMcpAction;
+  readonly requestKey: string;
+}): CommandId {
+  return CommandId.make(
+    [
+      "command",
+      "mcp",
+      stablePart(input.scope.providerSessionId),
+      "thread-update",
+      stablePart(input.threadId),
+      stablePart(input.action),
+      stablePart(input.requestKey),
+    ].join(":"),
+  );
+}
+
+function metadataCommand(input: {
+  readonly commandId: CommandId;
+  readonly threadId: ThreadId;
+  readonly projectId: OrchestrationV2AppThread["projectId"];
+  readonly update: ThreadMetadataMcpUpdateInput;
+}): Extract<OrchestrationV2Command, { readonly type: "thread.metadata.update" }> {
+  switch (input.update.action) {
+    case "rename":
+      return {
+        type: "thread.metadata.update",
+        commandId: input.commandId,
+        threadId: input.threadId,
+        title: input.update.title!,
+      };
+    case "regenerate_title":
+      return {
+        type: "thread.metadata.update",
+        commandId: input.commandId,
+        threadId: input.threadId,
+        regenerateTitle: true,
+      };
+    case "link_pull_request":
+      return {
+        type: "thread.metadata.update",
+        commandId: input.commandId,
+        threadId: input.threadId,
+        linkedPullRequest: {
+          projectId: input.projectId,
+          ...input.update.pullRequest!,
+        },
+      };
+    case "unlink_pull_request":
+      return {
+        type: "thread.metadata.update",
+        commandId: input.commandId,
+        threadId: input.threadId,
+        linkedPullRequest: null,
+      };
+  }
+}
+
+function resultFromThread(input: {
+  readonly action: ThreadMetadataMcpAction;
+  readonly commandId: CommandId;
+  readonly sequence: number;
+  readonly thread: OrchestrationV2AppThread;
+}): ThreadMetadataMcpUpdateResult {
+  return {
+    threadId: input.thread.id,
+    action: input.action,
+    commandId: input.commandId,
+    sequence: input.sequence,
+    title: input.thread.title,
+    titleRegeneration:
+      input.thread.titleRegeneration === undefined || input.thread.titleRegeneration === null
+        ? null
+        : {
+            requestId: input.thread.titleRegeneration.requestId,
+            startedAt: DateTime.formatIso(input.thread.titleRegeneration.startedAt),
+          },
+    linkedPullRequest: input.thread.linkedPullRequest ?? null,
+    updatedAt: DateTime.formatIso(input.thread.updatedAt),
+  };
+}
+
+const make = Effect.gen(function* () {
+  const crypto = yield* Crypto.Crypto;
+  const threadManagement = yield* ThreadManagementService;
+
+  const update = Effect.fn("ThreadMetadataMcpService.update")(function* (
+    scope: McpInvocationScope,
+    input: ThreadMetadataMcpUpdateInput,
+  ) {
+    if (!scope.capabilities.has("orchestration")) {
+      return yield* failure(
+        "capability_denied",
+        "This MCP credential does not grant orchestration capabilities.",
+      );
+    }
+
+    const parent = yield* threadManagement
+      .getThreadProjection(scope.threadId)
+      .pipe(
+        Effect.mapError((error) =>

@@ -0,0 +1,220 @@
+import {
+  CommandId,
+  OrchestratorMcpFailure,
+  type OrchestrationV2AppThread,
+  type OrchestrationV2Command,
+  type ThreadMetadataMcpAction,
+  type ThreadMetadataMcpUpdateInput,
+  type ThreadMetadataMcpUpdateResult,
+  ThreadId,
+} from "@t3tools/contracts";
+import * as Context from "effect/Context";
+import * as Crypto from "effect/Crypto";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import {
+  ThreadManagementError,
+  ThreadManagementService,
+} from "../orchestration-v2/ThreadManagementService.ts";
+import type { McpInvocationScope } from "./McpInvocationContext.ts";
+
+export interface ThreadMetadataMcpServiceShape {
+  readonly update: (
+    scope: McpInvocationScope,
+    input: ThreadMetadataMcpUpdateInput,
+  ) => Effect.Effect<ThreadMetadataMcpUpdateResult, OrchestratorMcpFailure>;
+}
+
+export class ThreadMetadataMcpService extends Context.Service<
+  ThreadMetadataMcpService,
+  ThreadMetadataMcpServiceShape
+>()("t3/mcp/ThreadMetadataMcpService") {}

@@ -190,6 +197,19 @@ export const ThreadReadTool = Tool.make("t3_thread_read", {
   .annotate(Tool.Destructive, false)
   .annotate(Tool.Idempotent, true);
 
+export const ThreadUpdateTool = Tool.make("t3_thread_update", {
+  description:
+    "Update metadata for a thread in the calling project. Omit threadId to update this thread. Use action='rename' with title, action='regenerate_title' with no extra field, action='link_pull_request' with pullRequest, or action='unlink_pull_request'. Workspace and branch changes are intentionally not supported. clientRequestId makes retries idempotent.",
+  parameters: ThreadMetadataMcpUpdateInput,
+  success: ThreadMetadataMcpUpdateResult,
+  failure: OrchestratorMcpFailure,
+  failureMode: "return",
+  dependencies: threadMetadataDependencies,
+})
+  .annotate(Tool.Title, "Update T3 thread metadata")
+  .annotate(Tool.Destructive, true)
+  .annotate(Tool.Idempotent, true);