@zackbart/connecta 0.7.7 → 0.7.9

package/src/meta-tools.ts

@@ -17,6 +17,7 @@ import {
   messageLooksRetryable,
   type CallErrorDetails,
 } from "./errors.js";
+import { isCallAdmissionError } from "./call-admission.js";
 import {
   isValidMaxResultBytes,
   MIN_MAX_RESULT_BYTES,
@@ -228,6 +229,24 @@ function errorDetails(code: string, message: string): ErrorDetails {
   return { code, message, retryable: messageLooksRetryable(message) };
 }
 
+function callerCancelledDetails(): ErrorDetails {
+  return {
+    code: "cancelled",
+    message: "Tool call was cancelled by the caller.",
+    retryable: false,
+  };
+}
+
+function isCallerCancellation(
+  error: unknown,
+  signal: AbortSignal | undefined,
+): boolean {
+  return (
+    signal?.aborted === true ||
+    (isCallAdmissionError(error) && error.admissionKind === "cancelled")
+  );
+}
+
 /** True if `b` is a UTF-8 continuation byte (0b10xxxxxx). */
 function isContinuationByte(b: number): boolean {
   return (b & 0xc0) === 0x80;
@@ -406,6 +425,15 @@ async function stashResult(
   };
 }
 
+/** Keep an oversized batch's inline outcome summary at fixed string overhead. */
+function batchSummaryString(value: string): string {
+  const bytes = enc.encode(value);
+  const maxBytes = 512;
+  if (bytes.length <= maxBytes) return value;
+  const end = alignEndToCharBoundary(bytes, 0, maxBytes, bytes.length);
+  return `${dec.decode(bytes.slice(0, end))}…`;
+}
+
 /**
  * Return `text` as a single content block; if it exceeds `cap` bytes, stash the
  * full text and return the first `cap` bytes followed by a JSON truncation
@@ -575,10 +603,10 @@ export interface SkillArgs {
  * supplies a deadline for calls that don't carry one. (execute_code, the
  * optional tenth tool, is registered separately by registerExecuteTool.)
  *
- * The deployment-wide result-size cap is read off the registry view rather than
- * passed in: `ConnectaConfig.calls.maxResultBytes` and the per-connector
- * override are the only places a cap is set, so there is one answer to where a
- * deployment sets it (issue #44).
+ * Deployment-wide result-size caps are read off the registry view rather than
+ * passed in: `ConnectaConfig.calls.maxResultBytes`, its per-connector override,
+ * and the independent `calls.maxBatchResultBytes` final-envelope boundary each
+ * have one runtime source of truth.
  */
 export function createMetaTools(
   registry: RegistryView,
@@ -589,12 +617,15 @@ export function createMetaTools(
     /** Per-connector deadline for the list/search/describe probe fan-out. Default 30_000. */
     probeTimeoutMs?: number;
     activity?: ActivityRequestContext;
+    /** Inbound request cancellation shared by direct and batch child calls. */
+    requestSignal?: AbortSignal;
     /** Runtime continuation for the bounded tail of probe-owned teardown. */
     defer?: DeferredWork;
   } = {},
 ) {
   // Already normalized and warned about at registry construction.
   const globalCap = registry.maxResultBytes;
+  const batchCap = registry.maxBatchResultBytes;
   const defaultToolTimeoutMs = normalizeTimeoutMs(opts.defaultToolTimeoutMs);
   const probeTimeoutMs =
     normalizeTimeoutMs(opts.probeTimeoutMs) ?? DEFAULT_PROBE_TIMEOUT_MS;
@@ -621,6 +652,7 @@ export function createMetaTools(
     attempts: number;
     timing: {
       catalogMs: number;
+      admissionMs: number;
       connectorMs: number;
       backoffMs: number;
       resultProcessingMs: number;
@@ -638,12 +670,14 @@ export function createMetaTools(
   ): Promise<RunCallOutcome> {
     const started = Date.now();
     let catalogMs = 0;
+    let admissionMs = 0;
     let connectorMs = 0;
     let backoffMs = 0;
     let resultProcessingMs = 0;
     let attempts = 0;
     const timing = () => ({
       catalogMs,
+      admissionMs,
       connectorMs,
       backoffMs,
       resultProcessingMs,
@@ -651,7 +685,7 @@ export function createMetaTools(
     });
     const resolved = registry.resolveAddress(call.address);
     const record = (
-      outcome: "success" | "error" | "timeout",
+      outcome: "success" | "error" | "timeout" | "cancelled",
       errorCode?: string,
     ) => {
       if (!resolved) return;
@@ -669,7 +703,14 @@ export function createMetaTools(
     const failed = (error: ErrorDetails): RunCallOutcome => {
       const durationMs = Date.now() - started;
       const diagnostics = timing();
-      record(error.code === "timeout" ? "timeout" : "error", error.code);
+      record(
+        error.code === "timeout"
+          ? "timeout"
+          : error.code === "cancelled"
+            ? "cancelled"
+            : "error",
+        error.code,
+      );
       return {
         toolResult:
           call.resultMode === "value"
@@ -719,6 +760,9 @@ export function createMetaTools(
       ).find((tool) => tool.name === resolved.toolName);
     } catch (err) {
       catalogMs += Date.now() - catalogStarted;
+      if (opts.requestSignal?.aborted) {
+        return failed(callerCancelledDetails());
+      }
       // A connector whose catalog cannot be fetched is as unusable as one whose
       // execution fails, so it feeds health accounting the same way the
       // execution catch below does — otherwise a connector every call_tool
@@ -764,38 +808,76 @@ export function createMetaTools(
     let result: unknown;
     while (true) {
       attempts++;
-      const controller = timeoutMs ? new AbortController() : undefined;
+      let permit: Awaited<ReturnType<RegistryView["admitCall"]>> | undefined;
+      const controller =
+        timeoutMs || opts.requestSignal ? new AbortController() : undefined;
+      const forwardAbort = () =>
+        controller?.abort(opts.requestSignal?.reason);
+      if (opts.requestSignal?.aborted) forwardAbort();
+      else {
+        opts.requestSignal?.addEventListener("abort", forwardAbort, {
+          once: true,
+        });
+      }
       let timer: ReturnType<typeof setTimeout> | undefined;
-      const ctx = registry.contextFor(
-        resolved.connector.id,
-        baseUrl,
-        requestScope,
-        { signal: controller?.signal, timeoutMs },
-      );
-      const connectorStarted = Date.now();
+      let onAbort: (() => void) | undefined;
+      let attemptFailed = false;
+      let attemptError: unknown;
       try {
-        const pending = resolved.connector.callTool(
-          resolved.toolName,
-          call.args ?? {},
-          ctx,
+        const admissionStarted = Date.now();
+        try {
+          permit = await registry.admitCall(resolved.connector.id, {
+            toolName: resolved.toolName,
+            args: call.args ?? {},
+            signal: opts.requestSignal,
+          });
+        } finally {
+          admissionMs += Date.now() - admissionStarted;
+        }
+        const ctx = registry.contextFor(
+          resolved.connector.id,
+          baseUrl,
+          requestScope,
+          { signal: controller?.signal, timeoutMs },
         );
-        result = timeoutMs
-          ? await Promise.race([
-              pending,
-              new Promise<never>((_, reject) => {
-                timer = setTimeout(() => {
-                  reject(
-                    new ConnectorCallError(
-                      "timeout",
-                      `Tool call timed out after ${timeoutMs}ms`,
-                    ),
-                  );
-                  controller?.abort();
-                }, timeoutMs);
-              }),
-            ])
-          : await pending;
-        connectorMs += Date.now() - connectorStarted;
+        let rejectCancelled!: (reason: unknown) => void;
+        const cancelled = controller
+          ? new Promise<never>((_, reject) => {
+              rejectCancelled = reject;
+            })
+          : undefined;
+        onAbort = () => {
+          rejectCancelled(
+            controller?.signal.reason ??
+              new ConnectorCallError("timeout", "Tool call was cancelled"),
+          );
+        };
+        controller?.signal.addEventListener("abort", onAbort, { once: true });
+        if (controller?.signal.aborted) onAbort();
+        if (controller?.signal.aborted) await cancelled;
+        if (timeoutMs) {
+          timer = setTimeout(() => {
+            controller?.abort(
+              new ConnectorCallError(
+                "timeout",
+                `Tool call timed out after ${timeoutMs}ms`,
+              ),
+            );
+          }, timeoutMs);
+        }
+        const connectorStarted = Date.now();
+        try {
+          const pending = resolved.connector.callTool(
+            resolved.toolName,
+            call.args ?? {},
+            ctx,
+          );
+          result = cancelled
+            ? await Promise.race([pending, cancelled])
+            : await pending;
+        } finally {
+          connectorMs += Date.now() - connectorStarted;
+        }
         const mcpResult = result as {
           content?: TextContent[];
           isError?: boolean;
@@ -806,34 +888,72 @@ export function createMetaTools(
               "Downstream tool call failed",
           );
         }
-        break;
       } catch (err) {
-        // Includes connector setup, downstream execution, and timeout wait.
-        connectorMs += Date.now() - connectorStarted;
-        const details = classifyCallError(err);
-        if (attempts <= maxRetries && retrySafe && details.retryable) {
+        attemptFailed = true;
+        attemptError = err;
+      } finally {
+        if (timer) clearTimeout(timer);
+        if (onAbort) {
+          controller?.signal.removeEventListener("abort", onAbort);
+        }
+        opts.requestSignal?.removeEventListener("abort", forwardAbort);
+        permit?.release();
+      }
+      if (attemptFailed) {
+        const callerCancelled = isCallerCancellation(
+          attemptError,
+          opts.requestSignal,
+        );
+        const details = callerCancelled
+          ? callerCancelledDetails()
+          : classifyCallError(attemptError);
+        if (
+          !callerCancelled &&
+          attempts <= maxRetries &&
+          retrySafe &&
+          details.retryable
+        ) {
           const wait = retryBackoffMs(attempts, details.retryAfterMs);
           if (wait !== undefined) {
             const backoffStarted = Date.now();
             if (wait > 0) {
-              await new Promise((resolve) => setTimeout(resolve, wait));
+              const completed = await new Promise<boolean>((resolve) => {
+                let settled = false;
+                const finish = (value: boolean) => {
+                  if (settled) return;
+                  settled = true;
+                  clearTimeout(timer);
+                  opts.requestSignal?.removeEventListener("abort", cancel);
+                  resolve(value);
+                };
+                const timer = setTimeout(() => finish(true), wait);
+                const cancel = () => finish(false);
+                opts.requestSignal?.addEventListener("abort", cancel, {
+                  once: true,
+                });
+                if (opts.requestSignal?.aborted) cancel();
+              });
+              backoffMs += Date.now() - backoffStarted;
+              if (!completed) return failed(callerCancelledDetails());
+            } else {
+              backoffMs += Date.now() - backoffStarted;
             }
-            backoffMs += Date.now() - backoffStarted;
             continue;
           }
           // The reported window is longer than the engine will park a
           // synchronous request for. Fall through to failure with
           // retryAfterMs reported verbatim so the agent can re-issue.
         }
-        registry.recordFailure(
-          resolved.connector.id,
-          Date.now() - started,
-          err,
-        );
+        if (!callerCancelled && !isCallAdmissionError(attemptError)) {
+          registry.recordFailure(
+            resolved.connector.id,
+            Date.now() - started,
+            attemptError,
+          );
+        }
         return failed(details);
-      } finally {
-        if (timer) clearTimeout(timer);
       }
+      break;
     }
 
     registry.recordSuccess(resolved.connector.id, Date.now() - started);
@@ -1141,26 +1261,36 @@ export function createMetaTools(
           ),
         ),
       );
-      let orderBase = 0;
-      catalogs.forEach((catalog, connectorIndex) => {
-        const c = conns[connectorIndex];
-        if (catalog.status === "fulfilled") {
-          for (const ranked of rankTools(catalog.value, q)) {
-            matches.push({
-              connectorId: c.id,
-              connectorTitle: c.title,
-              connectorDescription: c.description,
-              ...(connectorGuide(c)
-                ? { connectorGuideSkill: connectorSkillName(c.id) }
-                : {}),
-              tool: ranked.tool,
-              score: ranked.score,
-              order: orderBase + ranked.order,
-            });
+      let matchMode: "all" | "partial" = "all";
+      const collectMatches = (mode: "all" | "partial") => {
+        matches.length = 0;
+        let orderBase = 0;
+        catalogs.forEach((catalog, connectorIndex) => {
+          const c = conns[connectorIndex];
+          if (catalog.status === "fulfilled") {
+            for (const ranked of rankTools(catalog.value, q, mode)) {
+              matches.push({
+                connectorId: c.id,
+                connectorTitle: c.title,
+                connectorDescription: c.description,
+                ...(connectorGuide(c)
+                  ? { connectorGuideSkill: connectorSkillName(c.id) }
+                  : {}),
+                tool: ranked.tool,
+                score: ranked.score,
+                order: orderBase + ranked.order,
+              });
+            }
           }
-        }
-        orderBase += catalog.status === "fulfilled" ? catalog.value.length : 1;
-      });
+          orderBase +=
+            catalog.status === "fulfilled" ? catalog.value.length : 1;
+        });
+      };
+      collectMatches("all");
+      if (q.trim() && matches.length === 0) {
+        matchMode = "partial";
+        collectMatches(matchMode);
+      }
       matches.sort((a, b) => b.score - a.score || a.order - b.order);
       const page = matches.slice(offset, offset + limit);
       const groups: {
@@ -1235,6 +1365,9 @@ export function createMetaTools(
           limit,
           hasMore: nextOffset !== undefined,
           ...(nextOffset !== undefined ? { nextOffset } : {}),
+          ...(matchMode === "partial" && matches.length > 0
+            ? { matchMode }
+            : {}),
         },
         "Request a smaller limit, omit fullDescriptions, or use compact schemas.",
       );
@@ -1457,9 +1590,50 @@ export function createMetaTools(
             : {}),
         };
       });
-      return jsonResult({
+      const envelope = {
         results,
         durationMs: Date.now() - batchStarted,
+      };
+      const text = serializeResultText(envelope);
+      const bytes = enc.encode(text);
+      if (bytes.length <= batchCap) return jsonResult(envelope);
+
+      const notice = await stashResult(
+        text,
+        registry.resultsStorage(),
+        bytes.length,
+      );
+      return jsonResult({
+        results: results.map((result) => {
+          const common = {
+            address: batchSummaryString(result.address),
+            ok: !("error" in result),
+            ...("durationMs" in result
+              ? { durationMs: result.durationMs }
+              : {}),
+            ...("attempts" in result ? { attempts: result.attempts } : {}),
+            ...("timing" in result ? { timing: result.timing } : {}),
+          };
+          if (!("error" in result)) return common;
+          const error = result.error ?? "Batch call failed";
+          const details =
+            result.errorDetails ??
+            errorDetails("batch_call_failed", error);
+          return {
+            ...common,
+            error: batchSummaryString(error),
+            errorDetails: {
+              code: batchSummaryString(details.code),
+              message: batchSummaryString(details.message),
+              retryable: details.retryable,
+              ...(details.retryAfterMs !== undefined
+                ? { retryAfterMs: details.retryAfterMs }
+                : {}),
+            },
+          };
+        }),
+        durationMs: envelope.durationMs,
+        ...notice,
       });
     },
 
@@ -1527,7 +1701,7 @@ const CALL_DESTRUCTIVE_DESC =
 const GET_RESULT_DESC =
   "Page a truncated result stashed by call_tool/batch_call. Input { id, offset?, maxBytes? } → { text, offset, nextOffset?, totalBytes } sliced by byte offset. maxBytes is a whole number of bytes >= 1 (omit for the deployment default) and offset a whole number of bytes >= 0; an offset inside a multi-byte character is moved back to that character's first byte and the offset served is returned. Unknown/expired id is an error.";
 const BATCH_DESC =
-  "Use for 2–10 independent tools explicitly annotated readOnlyHint: true. Calls run in parallel with shared request-scoped clients; use execute_code when available instead for dependencies or in-sandbox reduction. Unannotated, write-capable, and destructive tools are refused. Batch timeout, safe retry, result mode, and diagnostics defaults may be overridden per call.";
+  "Use for 2–10 independent tools explicitly annotated readOnlyHint: true. Calls run in parallel with shared request-scoped clients; use execute_code when available instead for dependencies or in-sandbox reduction. Unannotated, write-capable, and destructive tools are refused. Batch timeout, safe retry, result mode, and diagnostics defaults may be overridden per call. An oversized final envelope returns ordered outcome summaries plus a get_result page handle.";
 const AUTHORIZE_DESC =
   "Use after a connector reports auth_required. Starts downstream OAuth and returns an authorizationUrl for the operator to open. force=true wipes stored credentials first and restarts consent.";
 const SKILLS_DESC =
@@ -1593,6 +1767,7 @@ export function registerMetaTools(
     defaultToolTimeoutMs?: number;
     probeTimeoutMs?: number;
     activity?: ActivityRequestContext;
+    requestSignal?: AbortSignal;
     defer?: DeferredWork;
   },
 ): void {
@@ -1600,6 +1775,7 @@ export function registerMetaTools(
     defaultToolTimeoutMs: ctx.defaultToolTimeoutMs,
     probeTimeoutMs: ctx.probeTimeoutMs,
     activity: ctx.activity,
+    requestSignal: ctx.requestSignal,
     defer: ctx.defer,
   });
 

package/src/registry.ts

@@ -18,6 +18,11 @@ import {
   type CredentialHealthConfig,
   type CredentialHealthRecord,
 } from "./credential-health.js";
+import {
+  ConnectorCallAdmissionController,
+  type CallAdmissionPermit,
+  type ConnectorCallAdmissionSnapshot,
+} from "./call-admission.js";
 import type { DeferredWork } from "./connector-scope.js";
 import { splitAddress, type Toolkit } from "./toolkits.js";
 
@@ -25,6 +30,8 @@ const ID_RE = /^[a-z0-9_-]+$/;
 const DEFAULT_TTL_SECONDS = 300;
 const DEFAULT_STALE_SECONDS = 3600;
 export const DEFAULT_MAX_RESULT_BYTES = 50_000;
+/** Independent final-envelope boundary for `batch_call`. */
+export const DEFAULT_MAX_BATCH_RESULT_BYTES = 100_000;
 
 /**
  * Smallest accepted inline-result cap. One byte is pathological but harmless:
@@ -143,6 +150,11 @@ export interface RegistryOptions {
    * to the default 50_000.
    */
   maxResultBytes?: number;
+  /**
+   * Cap on the complete serialized batch_call envelope. Must be a whole number
+   * of bytes >= 1; anything else warns and falls back to 100_000.
+   */
+  maxBatchResultBytes?: number;
   /** Tuning for the credential liveness checks (issue #24). */
   credentialHealth?: CredentialHealthConfig;
 }
@@ -179,6 +191,8 @@ type ConnectorOperationOptions = Pick<
 export interface RegistryView {
   /** Deployment-wide result-size cap threaded to the meta-tools. */
   readonly maxResultBytes: number;
+  /** Independent cap for the complete serialized batch_call envelope. */
+  readonly maxBatchResultBytes: number;
   listConnectors(): Connector[];
   getConnector(id: string): Connector | undefined;
   resolveAddress(
@@ -203,6 +217,14 @@ export interface RegistryView {
     requestScope?: object,
     callOptions?: ConnectorOperationOptions,
   ): ConnectorContext;
+  /**
+   * Acquire the connector's shared downstream-call permit. Scoped views
+   * delegate to the base registry so every toolkit contends on the same pool.
+   */
+  admitCall(
+    id: string,
+    input: { toolName: string; args: unknown; signal?: AbortSignal },
+  ): Promise<CallAdmissionPermit>;
   resultsStorage(): KVStorage;
   recordSuccess(id: string, latencyMs: number): void;
   recordFailure(id: string, latencyMs: number, error: unknown): void;
@@ -233,6 +255,10 @@ export interface RegistryView {
  */
 export class Registry implements RegistryView {
   private readonly connectors = new Map<string, Connector>();
+  private readonly callAdmission = new Map<
+    string,
+    ConnectorCallAdmissionController
+  >();
   private readonly cache = new Map<string, CacheEntry>();
   private readonly invalidated = new Set<string>();
   /** Per-connector epoch preventing a pre-invalidation refresh from publishing. */
@@ -246,6 +272,8 @@ export class Registry implements RegistryView {
   private readonly persistToolCatalog: boolean;
   /** Result-size guard cap threaded to the meta-tools. */
   readonly maxResultBytes: number;
+  /** Final batch envelope cap threaded to the meta-tools. */
+  readonly maxBatchResultBytes: number;
   /** Proactive liveness checks over stored downstream credentials (issue #24). */
   private readonly credentialHealth: CredentialHealthChecker;
 
@@ -262,6 +290,10 @@ export class Registry implements RegistryView {
       opts.maxResultBytes,
       DEFAULT_MAX_RESULT_BYTES,
     );
+    this.maxBatchResultBytes = resolveMaxResultBytes(
+      opts.maxBatchResultBytes,
+      DEFAULT_MAX_BATCH_RESULT_BYTES,
+    );
     for (const c of connectors) {
       if (!ID_RE.test(c.id)) {
         throw new Error(
@@ -272,9 +304,19 @@ export class Registry implements RegistryView {
         throw new Error(`Duplicate connector id "${c.id}"`);
       }
       this.connectors.set(c.id, c);
+      if (c.callAdmission) {
+        this.callAdmission.set(
+          c.id,
+          new ConnectorCallAdmissionController(c.id, c.callAdmission),
+        );
+      }
     }
     this.checkConventions(opts.logger);
-    this.checkResultCaps(opts.logger, opts.maxResultBytes);
+    this.checkResultCaps(
+      opts.logger,
+      opts.maxResultBytes,
+      opts.maxBatchResultBytes,
+    );
     this.credentialHealth = new CredentialHealthChecker(
       {
         listConnectors: () => this.listConnectors(),
@@ -300,6 +342,7 @@ export class Registry implements RegistryView {
   private checkResultCaps(
     logger: Logger,
     configured: number | undefined,
+    configuredBatch: number | undefined,
   ): void {
     if (configured !== undefined && !isValidMaxResultBytes(configured)) {
       logger.warn(
@@ -309,6 +352,17 @@ export class Registry implements RegistryView {
           `default ${DEFAULT_MAX_RESULT_BYTES} instead.`,
       );
     }
+    if (
+      configuredBatch !== undefined &&
+      !isValidMaxResultBytes(configuredBatch)
+    ) {
+      logger.warn(
+        `[connecta] calls.maxBatchResultBytes ${configuredBatch} is not a whole ` +
+          `number of bytes >= ${MIN_MAX_RESULT_BYTES}: it would leave the final ` +
+          "batch envelope unbounded or serve an unusable page. Using the " +
+          `default ${DEFAULT_MAX_BATCH_RESULT_BYTES} instead.`,
+      );
+    }
     for (const c of this.connectors.values()) {
       if (
         c.maxResultBytes !== undefined &&
@@ -399,6 +453,30 @@ export class Registry implements RegistryView {
     };
   }
 
+  admitCall(
+    id: string,
+    input: { toolName: string; args: unknown; signal?: AbortSignal },
+  ): Promise<CallAdmissionPermit> {
+    const admission = this.callAdmission.get(id);
+    if (admission) return admission.acquire(input);
+    return Promise.resolve({ waitMs: 0, release() {} });
+  }
+
+  /** Payload-free aggregate state for the open health endpoint. */
+  callAdmissionSnapshot(): Record<string, ConnectorCallAdmissionSnapshot> {
+    return Object.fromEntries(
+      [...this.callAdmission].map(([id, admission]) => [
+        id,
+        admission.snapshot(),
+      ]),
+    );
+  }
+
+  /** Reject queued/future downstream admission; active permits release safely. */
+  closeCallAdmission(): void {
+    for (const admission of this.callAdmission.values()) admission.close();
+  }
+
   /**
    * Storage namespaced to the meta-tool result store (`results:` prefix), kept
    * separate from any connector's `conn:<id>:` namespace. Backs get_result.
@@ -831,6 +909,10 @@ export class ScopedRegistry implements RegistryView {
     return this.base.maxResultBytes;
   }
 
+  get maxBatchResultBytes(): number {
+    return this.base.maxBatchResultBytes;
+  }
+
   /** In scope AND actually registered. */
   private visible(id: string): boolean {
     return (
@@ -911,6 +993,14 @@ export class ScopedRegistry implements RegistryView {
     return this.base.contextFor(id, baseUrl, requestScope, callOptions);
   }
 
+  admitCall(
+    id: string,
+    input: { toolName: string; args: unknown; signal?: AbortSignal },
+  ): Promise<CallAdmissionPermit> {
+    if (!this.visible(id)) return Promise.reject(this.unknownConnector(id));
+    return this.base.admitCall(id, input);
+  }
+
   /**
    * Stashed oversized results are bound to the scope that produced them: a
    * scoped session cannot page a result it could not have produced, and an id

package/src/server.ts

@@ -1273,6 +1273,7 @@ async function serveMcp(
     activity,
     defaultToolTimeoutMs: opts.defaultToolTimeoutMs,
     probeTimeoutMs: opts.probeTimeoutMs,
+    requestSignal: request.signal,
     ...(runtimeContext
       ? { defer: runtimeContext.waitUntil.bind(runtimeContext) }
       : {}),
@@ -1577,6 +1578,10 @@ export function createFetchHandler(
             code: opts.executor
               ? (codeAdmission ?? { managedByExecutor: true })
               : null,
+            downstreamCalls: {
+              policy: "connector-partitioned-per-runtime",
+              connectors: registry.callAdmissionSnapshot(),
+            },
             reservedRoutes: [
               "/health",
               "/",