@opengeni/api-router 0.30.3 → 2.2.0-canary.0

package/src/mcp/company-profile-agent-admin.ts

@@ -0,0 +1,205 @@
+import {
+  AGENT_AUTHORED_COMPANY_PROFILE_CONTENT_MAX_UTF8_BYTES,
+  AGENT_AUTHORED_COMPANY_PROFILE_ENTRY_MAX_CHARS,
+  AGENT_AUTHORED_COMPANY_PROFILE_SCALAR_MAX_CHARS,
+  AGENT_AUTHORED_COMPANY_PROFILE_TOO_LONG_MESSAGE,
+  AgentAuthoredCompanyProfileContent,
+  COMPANY_PROFILE_ENTRY_MAX_COUNT,
+  COMPANY_PROFILE_REASON_MAX_CHARS,
+  COMPANY_PROFILE_STABLE_KEY_MAX_CHARS,
+  normalizeCompanyProfileStableKey,
+  type CompanyProfileAgentAttempt,
+  type CompanyProfileEntry,
+} from "@opengeni/contracts";
+import {
+  CompanyProfileAgentAdminError,
+  createCompanyProfileAgentAdminRouter,
+} from "@opengeni/core";
+import type { Database } from "@opengeni/db";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod/v4";
+
+type JsonResult = (value: unknown) => {
+  content: { type: "text"; text: string }[];
+};
+
+export type RegisterCompanyProfileAgentAdminToolsInput = {
+  server: McpServer;
+  db: Database;
+  attempt: CompanyProfileAgentAttempt;
+  authorize: () => Promise<void>;
+  json: JsonResult;
+  router?: Pick<ReturnType<typeof createCompanyProfileAgentAdminRouter>, "propose" | "confirm">;
+};
+
+// Agent-only bounds. The human `account:admin` route keeps the wider
+// `COMPANY_PROFILE_*` limits; this profile is the largest always-on prompt
+// surface in the product, so an agent gets a much smaller budget for it.
+const scalar = z
+  .string()
+  .trim()
+  .min(1)
+  .max(
+    AGENT_AUTHORED_COMPANY_PROFILE_SCALAR_MAX_CHARS,
+    AGENT_AUTHORED_COMPANY_PROFILE_TOO_LONG_MESSAGE,
+  )
+  .nullable();
+const entry = z.object({
+  key: z.string().trim().min(1).max(COMPANY_PROFILE_STABLE_KEY_MAX_CHARS).optional(),
+  content: z
+    .string()
+    .trim()
+    .min(1)
+    .max(
+      AGENT_AUTHORED_COMPANY_PROFILE_ENTRY_MAX_CHARS,
+      AGENT_AUTHORED_COMPANY_PROFILE_TOO_LONG_MESSAGE,
+    ),
+});
+const entries = z.array(entry).max(COMPANY_PROFILE_ENTRY_MAX_COUNT);
+const DEFAULT_PROPOSAL_REASON = "Activate agent-proposed organization company profile";
+const STABLE_KEY_WORDS = 6;
+
+type EntryInput = z.infer<typeof entry>;
+
+/**
+ * Derive a stable key from entry content: the first few words, normalized into
+ * the company-profile key alphabet and bounded to the stable-key length.
+ */
+export function deriveCompanyProfileStableKey(content: string): string {
+  const words = content
+    .normalize("NFKC")
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}\s._-]+/gu, " ")
+    .trim()
+    .split(/\s+/u)
+    .filter(Boolean)
+    .slice(0, STABLE_KEY_WORDS)
+    .join(" ");
+  const normalized = normalizeCompanyProfileStableKey(words)
+    .replace(/[^a-z0-9._-]+/g, "-")
+    .replace(/-+/g, "-")
+    .slice(0, COMPANY_PROFILE_STABLE_KEY_MAX_CHARS)
+    .replace(/^[._-]+|[._-]+$/g, "");
+  return normalized.length > 0 ? normalized : "entry";
+}
+
+/**
+ * Resolve explicit or derived keys for one list and de-duplicate by suffixing
+ * `-2`, `-3`, ... so the profile passes the unique-key contract.
+ */
+export function resolveCompanyProfileEntries(input: readonly EntryInput[]): CompanyProfileEntry[] {
+  const used = new Set<string>();
+  return input.map(({ key, content }) => {
+    const base = key
+      ? normalizeCompanyProfileStableKey(key)
+      : deriveCompanyProfileStableKey(content);
+    let candidate = base;
+    for (let suffix = 2; used.has(candidate); suffix += 1) {
+      const tail = `-${suffix}`;
+      candidate = `${base.slice(0, COMPANY_PROFILE_STABLE_KEY_MAX_CHARS - tail.length)}${tail}`;
+    }
+    used.add(candidate);
+    return { key: candidate, content };
+  });
+}
+
+function boundedIssueMessage(error: z.ZodError): string {
+  return error.issues
+    .slice(0, 5)
+    .map((issue) => `${issue.path.join(".") || "profile"}: ${issue.message}`)
+    .join("; ")
+    .slice(0, 1_024);
+}
+
+/**
+ * Register the explicit owner-confirmed organization profile path. This is
+ * administration, not derived learning: workspace learning mode is never
+ * consulted, the initiating human must be the organization's active owner (the
+ * same authority as the manual `account:admin` route), and the proposal cannot
+ * become active without the exact bound human-input response returned by the
+ * first call.
+ */
+export function registerCompanyProfileAgentAdminTools(
+  input: RegisterCompanyProfileAgentAdminToolsInput,
+): void {
+  const router = input.router ?? createCompanyProfileAgentAdminRouter({ db: input.db });
+  input.server.registerTool(
+    "company_profile_propose",
+    {
+      description:
+        "Prepare one complete organization company profile covering identity, mission, products, customers, strategic goals, and critical constraints. Omitted list keys are derived from content. " +
+        "Once activated, every field here is mandatory prompt context in every session for the whole organization, so write it as a concise profile rather than a document: one plain descriptive statement per field, no numbered procedure and no marketing copy. Longer source material belongs in organization Documents and is retrieved as evidence; never copy it into the profile. " +
+        `Bounds for this tool are ${AGENT_AUTHORED_COMPANY_PROFILE_SCALAR_MAX_CHARS} characters for identity and mission, ${AGENT_AUTHORED_COMPANY_PROFILE_ENTRY_MAX_CHARS} per list entry, ${COMPANY_PROFILE_ENTRY_MAX_COUNT} entries per list, and ${AGENT_AUTHORED_COMPANY_PROFILE_CONTENT_MAX_UTF8_BYTES} UTF-8 bytes for the whole profile. ` +
+        "This creates only an immutable inactive proposal for the exact live turn initiated by the organization owner and does not use workspace learning policy. The receipt returns the exact `humanInput` payload; call `request_human_input` with it verbatim, then call `company_profile_confirm` with the returned requestId.",
+      inputSchema: {
+        operationId: z.string().uuid(),
+        identity: scalar,
+        mission: scalar,
+        products: entries,
+        customers: entries,
+        goals: entries,
+        constraints: entries,
+        reason: z.string().trim().min(1).max(COMPANY_PROFILE_REASON_MAX_CHARS).optional(),
+      },
+    },
+    async (request) => {
+      await input.authorize();
+      const parsed = AgentAuthoredCompanyProfileContent.safeParse({
+        identity: request.identity,
+        mission: request.mission,
+        products: resolveCompanyProfileEntries(request.products),
+        customers: resolveCompanyProfileEntries(request.customers),
+        goals: resolveCompanyProfileEntries(request.goals),
+        constraints: resolveCompanyProfileEntries(request.constraints),
+      });
+      if (!parsed.success) {
+        return input.json({
+          status: "not_proposed",
+          code: "invalid_profile",
+          message: boundedIssueMessage(parsed.error),
+        });
+      }
+      try {
+        return input.json(
+          await router.propose({
+            attempt: input.attempt,
+            request: {
+              operationId: request.operationId,
+              profile: parsed.data,
+              reason: request.reason ?? DEFAULT_PROPOSAL_REASON,
+            },
+          }),
+        );
+      } catch (error) {
+        if (error instanceof CompanyProfileAgentAdminError) {
+          return input.json({ status: "not_proposed", code: error.code, message: error.message });
+        }
+        throw error;
+      }
+    },
+  );
+
+  input.server.registerTool(
+    "company_profile_confirm",
+    {
+      description:
+        "Activate a `company_profile_propose` receipt only after the exact initiating organization owner answered Activate on the returned `request_human_input` prompt. Pass the proposalReceiptId and requestId unchanged. Confirmation revalidates the live turn, organization role, proposal hash, and unchanged active-profile baseline, then returns the immutable activation receipt.",
+      inputSchema: {
+        operationId: z.string().uuid(),
+        proposalReceiptId: z.string().uuid(),
+        humanInputRequestId: z.string().uuid(),
+      },
+    },
+    async (request) => {
+      await input.authorize();
+      try {
+        return input.json(await router.confirm({ attempt: input.attempt, request }));
+      } catch (error) {
+        if (error instanceof CompanyProfileAgentAdminError) {
+          return input.json({ status: "not_confirmed", code: error.code, message: error.message });
+        }
+        throw error;
+      }
+    },
+  );
+}

package/src/mcp/documents.ts

@@ -12,6 +12,7 @@ import {
   getDocumentChunk,
   listDocumentBases,
   listEffectiveIndexedDocuments,
+  resolveEffectiveDocumentAccess,
   searchEffectiveKnowledge,
   searchEffectiveDocuments,
   type DocumentAccessFilter,
@@ -60,6 +61,7 @@ export function buildDocumentsMcpServer(
   documentServices: DocumentServices,
   options: {
     createdBySessionId?: string | undefined;
+    attemptId?: string | undefined;
     /** Immutable human subject whose agent is making this retrieval request. */
     initiatingSubjectId: string;
   },
@@ -71,10 +73,18 @@ export function buildDocumentsMcpServer(
   // This server is the agent retrieval surface. Agent-disabled documents are
   // never reachable. Workspace-visible documents are shared; private
   // documents are available only to the creating subject's agent.
-  const agentAccess: DocumentAccessFilter = {
-    agentOnly: true,
-    viewerSubjectId: options.initiatingSubjectId,
-  };
+  const agentAuthority =
+    options.createdBySessionId && options.attemptId
+      ? { sessionId: options.createdBySessionId, attemptId: options.attemptId }
+      : undefined;
+  const resolveAgentAccess = async (): Promise<DocumentAccessFilter> =>
+    await resolveEffectiveDocumentAccess(db, {
+      accountId,
+      workspaceId,
+      initiatingSubjectId: options.initiatingSubjectId,
+      surface: "agent",
+      agentAuthority,
+    });
 
   server.registerTool(
     "list_document_bases",
@@ -101,6 +111,7 @@ export function buildDocumentsMcpServer(
         documentServices,
         input,
         options.initiatingSubjectId,
+        agentAuthority,
       ),
   );
 
@@ -119,6 +130,7 @@ export function buildDocumentsMcpServer(
         documentServices,
         input,
         options.initiatingSubjectId,
+        agentAuthority,
       ),
   );
 
@@ -134,6 +146,7 @@ export function buildDocumentsMcpServer(
         accountId,
         workspaceId,
         initiatingSubjectId: options.initiatingSubjectId,
+        agentAuthority,
         id,
       });
       return {
@@ -173,6 +186,7 @@ export function buildDocumentsMcpServer(
                 accountId,
                 workspaceId,
                 initiatingSubjectId: options.initiatingSubjectId,
+                agentAuthority,
                 ...(parentId ? { parentId } : {}),
                 ...(topic ? { topic } : {}),
                 ...(sourceKinds ? { sourceKinds } : {}),
@@ -206,6 +220,7 @@ export function buildDocumentsMcpServer(
                 accountId,
                 workspaceId,
                 initiatingSubjectId: options.initiatingSubjectId,
+                agentAuthority,
                 ...(checkpoint ? { checkpoint } : {}),
                 ...(limit ? { limit } : {}),
               }),
@@ -225,7 +240,13 @@ export function buildDocumentsMcpServer(
       },
     },
     async ({ chunkId }) => {
-      const found = await getDocumentChunk(db, accountId, workspaceId, chunkId, agentAccess);
+      const found = await getDocumentChunk(
+        db,
+        accountId,
+        workspaceId,
+        chunkId,
+        await resolveAgentAccess(),
+      );
       return {
         content: [
           { type: "text", text: found ? JSON.stringify(found) : `chunk not found: ${chunkId}` },
@@ -244,7 +265,13 @@ export function buildDocumentsMcpServer(
       },
     },
     async ({ chunkId }) => {
-      const found = await getDocumentChunk(db, accountId, workspaceId, chunkId, agentAccess);
+      const found = await getDocumentChunk(
+        db,
+        accountId,
+        workspaceId,
+        chunkId,
+        await resolveAgentAccess(),
+      );
       return {
         content: [
           { type: "text", text: found ? JSON.stringify(found) : `chunk not found: ${chunkId}` },
@@ -367,6 +394,7 @@ async function searchContent(
     aclTags?: string[] | undefined;
   },
   initiatingSubjectId: string,
+  agentAuthority: { sessionId: string; attemptId: string } | undefined,
 ) {
   const results = await searchEffectiveDocuments(
     db,
@@ -380,6 +408,7 @@ async function searchContent(
       ...(input.sourceKinds ? { sourceKinds: input.sourceKinds } : {}),
       ...(input.aclTags ? { aclTags: input.aclTags } : {}),
       initiatingSubjectId,
+      agentAuthority,
       surface: "agent",
     },
     documentServices,
@@ -408,6 +437,7 @@ async function searchKnowledge(
     aclTags?: string[] | undefined;
   },
   initiatingSubjectId: string,
+  agentAuthority: { sessionId: string; attemptId: string } | undefined,
 ) {
   const response = await searchEffectiveKnowledge(
     db,
@@ -421,6 +451,7 @@ async function searchKnowledge(
       ...(input.sourceKinds ? { sourceKinds: input.sourceKinds } : {}),
       ...(input.aclTags ? { aclTags: input.aclTags } : {}),
       initiatingSubjectId,
+      agentAuthority,
       surface: "agent",
     },
     documentServices,

package/src/mcp/files.ts

@@ -1,5 +1,5 @@
 import type { AccessGrant } from "@opengeni/contracts";
-import { requireFileForSubject } from "@opengeni/db";
+import { recordAuditEvent, requireFileForSubject } from "@opengeni/db";
 import { hasPermission, type ApiRouteDeps } from "@opengeni/core";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod/v4";
@@ -47,6 +47,21 @@ export function buildFilesMcpServer(deps: ApiRouteDeps, grant: AccessGrant): Mcp
         throw new Error(`file is ${file.status}`);
       }
       const signed = await deps.objectStorage.createGetUrl({ key: file.objectKey });
+      // Principal-facing signed URL issuance is a metadata-only audit
+      // fact, awaited before the URL leaves the platform. Never the URL/key.
+      await recordAuditEvent(deps.db, {
+        accountId: grant.accountId,
+        workspaceId: grant.workspaceId,
+        subjectId: grant.subjectId,
+        action: "file.signed_url.issued",
+        targetType: "workspace_file",
+        targetId: file.id,
+        metadata: {
+          fileId: file.id,
+          kind: "mcp_download",
+          expiresAt: signed.expiresAt.toISOString(),
+        },
+      });
       return {
         content: [
           {

package/src/mcp/remember.ts

@@ -0,0 +1,181 @@
+import {
+  AGENT_AUTHORED_INSTRUCTION_POLICY_CONTENT_MAX_CHARS,
+  AGENT_AUTHORED_PREFERENCE_CONTENT_MAX_CHARS,
+  AGENT_AUTHORED_REMEMBER_CONTENT_TOO_LONG_MESSAGE,
+  PREFERENCE_REGISTRY_DESCRIPTOR_DESCRIPTION_MAX_CHARS,
+  PREFERENCE_REGISTRY_TITLE_MAX_CHARS,
+  REMEMBER_CONTENT_MAX_CHARS,
+  WorkspaceInstructionPolicyTarget,
+  agentAuthoredDurableTextTooLongMessage,
+  type CompanyBrainGovernedWriteAttempt,
+  type RememberLane,
+} from "@opengeni/contracts";
+import { RememberError, createRememberRouter } from "@opengeni/core";
+import type { Database } from "@opengeni/db";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod/v4";
+
+type JsonResult = (value: unknown) => {
+  content: { type: "text"; text: string }[];
+};
+
+export type RegisterRememberToolsInput = {
+  server: McpServer;
+  db: Database;
+  attempt: CompanyBrainGovernedWriteAttempt;
+  authorize: () => Promise<void>;
+  json: JsonResult;
+  router?: Pick<ReturnType<typeof createRememberRouter>, "remember" | "confirm">;
+};
+
+/**
+ * Per-lane budgets. The flat MCP input schema cannot vary `content` by lane, so
+ * it carries the widest lane (Knowledge) and the handler rejects an over-budget
+ * prompt-composed lane with the actionable message before anything durable is
+ * written. The contract enforces the same bounds for every other caller.
+ */
+const laneContentMaxChars: Record<RememberLane, number> = {
+  instruction_policy: AGENT_AUTHORED_INSTRUCTION_POLICY_CONTENT_MAX_CHARS,
+  preference: AGENT_AUTHORED_PREFERENCE_CONTENT_MAX_CHARS,
+  knowledge: REMEMBER_CONTENT_MAX_CHARS,
+};
+
+const laneFields = {
+  operationId: z.string().uuid(),
+  content: z
+    .string()
+    .trim()
+    .min(1)
+    // The widest lane, because one flat schema serves all three. Carry the
+    // lane-aware guidance in the message so an over-long rule is not refused
+    // with a generic bound that points at the wrong number.
+    .max(REMEMBER_CONTENT_MAX_CHARS, AGENT_AUTHORED_REMEMBER_CONTENT_TOO_LONG_MESSAGE)
+    .describe(
+      `The exact thing to remember, in the user's words. Budgets by lane: instruction_policy at most ${AGENT_AUTHORED_INSTRUCTION_POLICY_CONTENT_MAX_CHARS} characters because it is composed into the prompt of every session it applies to, preference at most ${AGENT_AUTHORED_PREFERENCE_CONTENT_MAX_CHARS} (its short descriptor is what is composed; the content is retrieved on demand), knowledge at most ${REMEMBER_CONTENT_MAX_CHARS}.`,
+    ),
+  reason: z.string().trim().min(1).max(4_096),
+};
+
+/**
+ * Explicit user-directed remember. Content becomes exact task-note evidence,
+ * promotion runs through the frozen workspace learning policy, and activation
+ * is either automatic (preference under Automatic mode) or requires exactly one
+ * bound human confirmation through the built-in `request_human_input` tool.
+ * Tool input cannot select scope beyond the workspace, active authority, or
+ * another learning-policy source.
+ */
+export function registerRememberTools(input: RegisterRememberToolsInput): void {
+  const router = input.router ?? createRememberRouter({ db: input.db });
+  input.server.registerTool(
+    "remember",
+    {
+      description:
+        "Durably remember something the user explicitly asked to keep for this workspace. Use lane=preference for how agents should act, lane=instruction_policy only when the user stated a hard always/never rule, lane=knowledge for a company/product/people fact. " +
+        `Write it short. A lane=instruction_policy rule is composed verbatim into the prompt of every session it applies to (every session in this workspace for a global rule, every session bound to the role for a role rule) for as long as it stays active, so keep it under ${AGENT_AUTHORED_INSTRUCTION_POLICY_CONTENT_MAX_CHARS} characters: one imperative rule in 1-3 sentences, no numbered steps, no examples, no rationale, no restating of defaults. At most three rules compose at once, so this is a standing budget you share. Keep a lane=preference under ${AGENT_AUTHORED_PREFERENCE_CONTENT_MAX_CHARS} characters; there only its short title and description are composed and the content is retrieved on demand, so length is retrieval cost rather than standing prompt cost. Prefer several small entries over one long one, and put procedure in a Document or Skill that the rule references instead of inlining it. ` +
+        "Under Automatic learning a preference activates immediately; otherwise the receipt returns status=confirmation_required with the exact `humanInput` payload: call `request_human_input` with it verbatim, then call `remember_confirm` with the returned requestId. Mandatory rules always need that confirmation. Do not use this for facts you merely inferred; use knowledge_propose or task notes for those. A confirmed lane=knowledge fact enters the human-reviewed Knowledge claim lifecycle; it does not become workspace memory, so do not expect to find it later through `memory_search`.",
+      inputSchema: {
+        lane: z.enum(["preference", "instruction_policy", "knowledge"]),
+        ...laneFields,
+        stableKey: z
+          .string()
+          .trim()
+          .min(1)
+          .max(128)
+          .regex(/^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/)
+          .optional(),
+        title: z.string().trim().min(1).max(PREFERENCE_REGISTRY_TITLE_MAX_CHARS).optional(),
+        description: z
+          .string()
+          .trim()
+          .min(1)
+          .max(PREFERENCE_REGISTRY_DESCRIPTOR_DESCRIPTION_MAX_CHARS)
+          .optional(),
+        target: WorkspaceInstructionPolicyTarget.optional(),
+        subject: z.string().trim().min(1).max(512).optional(),
+      },
+    },
+    async (request) => {
+      await input.authorize();
+      const { lane, operationId, content, reason } = request;
+      if (lane !== "knowledge" && content.length > laneContentMaxChars[lane]) {
+        return input.json({
+          status: "not_remembered",
+          code: "content_too_long",
+          message: agentAuthoredDurableTextTooLongMessage({
+            kind: lane,
+            actualChars: content.length,
+          }),
+        });
+      }
+      const base = { operationId, content, reason, scope: "workspace" as const };
+      const rememberRequest =
+        lane === "preference"
+          ? {
+              ...base,
+              lane,
+              stableKey: request.stableKey ?? `remember.${operationId.replaceAll("-", "")}`,
+              title: request.title ?? content.slice(0, 80),
+              description: request.description ?? content.slice(0, 200),
+            }
+          : lane === "instruction_policy"
+            ? { ...base, lane, target: request.target }
+            : { ...base, lane, subject: request.subject ?? content.slice(0, 80) };
+      return input.json(
+        await router.remember({ attempt: input.attempt, request: rememberRequest }),
+      );
+    },
+  );
+
+  input.server.registerTool(
+    "remember_confirm",
+    {
+      description:
+        "Complete a `remember` that returned status=confirmation_required after the human answered the bound `request_human_input` question. For preference/instruction_policy pass proposalId and learning.receiptId (as decisionReceiptId) from that receipt; for knowledge pass claimId. Always pass the requestId returned by request_human_input. Activation only succeeds when the exact initiating human answered Save on this turn; otherwise the proposal stays for review.",
+      inputSchema: {
+        operationId: z.string().uuid(),
+        proposalId: z.string().uuid().optional(),
+        decisionReceiptId: z.string().uuid().optional(),
+        claimId: z.string().uuid().optional(),
+        humanInputRequestId: z.string().uuid(),
+      },
+    },
+    async (request) => {
+      await input.authorize();
+      const confirmRequest =
+        request.proposalId && request.decisionReceiptId
+          ? {
+              target: "proposal" as const,
+              operationId: request.operationId,
+              proposalId: request.proposalId,
+              decisionReceiptId: request.decisionReceiptId,
+              humanInputRequestId: request.humanInputRequestId,
+            }
+          : request.claimId
+            ? {
+                target: "knowledge_claim" as const,
+                operationId: request.operationId,
+                claimId: request.claimId,
+                humanInputRequestId: request.humanInputRequestId,
+              }
+            : null;
+      if (!confirmRequest) {
+        return input.json({
+          status: "not_confirmed",
+          code: "invalid_target",
+          message:
+            "Pass proposalId + decisionReceiptId (preference/instruction_policy) or claimId (knowledge).",
+        });
+      }
+      try {
+        return input.json(
+          await router.confirm({ attempt: input.attempt, request: confirmRequest }),
+        );
+      } catch (error) {
+        if (error instanceof RememberError) {
+          return input.json({ status: "not_confirmed", code: error.code, message: error.message });
+        }
+        throw error;
+      }
+    },
+  );
+}

package/src/mcp/request-abort.ts

@@ -0,0 +1,44 @@
+import type { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+
+/**
+ * Serve one first-party MCP POST and bind the tool handlers' `extra.signal` to
+ * the HTTP client's connection.
+ *
+ * The API builds a fresh transport plus `McpServer` per POST, so an MCP
+ * `notifications/cancelled` from the worker would land on a different Protocol
+ * instance and never reach the handler. The only cancellation evidence this
+ * process can observe is the HTTP request's own abort (`Request.signal`, which
+ * Bun fires when the client disconnects). Closing the transport runs the SDK
+ * `Protocol._onclose`, which aborts every in-flight request handler's
+ * controller, so a blocking tool such as `session_wait` stops promptly when the
+ * worker drops the call (Steer, Pause, turn interruption).
+ *
+ * In JSON-response mode the SDK's `handleRequest` promise never settles once
+ * its stream mapping is cleared, so the race resolves a client-gone response
+ * instead of leaving the route handler pending.
+ */
+export async function handleMcpRequestWithClientAbort(
+  transport: Pick<WebStandardStreamableHTTPServerTransport, "handleRequest" | "close">,
+  request: Request,
+  clientSignal: AbortSignal | undefined,
+): Promise<Response> {
+  if (!clientSignal) return await transport.handleRequest(request);
+  const clientGone = () => new Response(null, { status: 499 });
+  if (clientSignal.aborted) {
+    await transport.close().catch(() => undefined);
+    return clientGone();
+  }
+  let onAbort: (() => void) | null = null;
+  const aborted = new Promise<Response>((resolve) => {
+    onAbort = () => {
+      void transport.close().catch(() => undefined);
+      resolve(clientGone());
+    };
+    clientSignal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([transport.handleRequest(request), aborted]);
+  } finally {
+    if (onAbort) clientSignal.removeEventListener("abort", onAbort);
+  }
+}

package/src/mcp/scheduled-task-view.ts

@@ -301,6 +301,7 @@ function toolIdentity(
       kind: tool.kind,
       id: id.value,
       ...(tool.optional !== undefined ? { optional: tool.optional } : {}),
+      ...(tool.eager !== undefined ? { eager: tool.eager } : {}),
     },
     truncatedFieldCount: Number(id.truncated),
   };