veryfront 0.1.1185 → 0.1.1189

package/esm/src/integrations/limits.js

@@ -0,0 +1,40 @@
+/**
+ * Resource ceilings for the remote integration bridge.
+ *
+ * Keep these limits independent of agent, worker, and provider modules so the
+ * integration boundary does not acquire an inverted dependency on one of its
+ * consumers. The values are deliberately generous for existing integrations
+ * while still placing deterministic bounds on authenticated remote input.
+ */
+/** End-to-end deadline for one integration API request, including body reads. */
+export const INTEGRATION_REQUEST_TIMEOUT_MS = 30_000;
+/** Maximum serialized request accepted by the remote tool-call endpoint. */
+export const MAX_INTEGRATION_CALL_REQUEST_BYTES = 4 * 1024 * 1024;
+/** Maximum decoded JSON response accepted from tool discovery. */
+export const MAX_INTEGRATION_TOOL_LIST_RESPONSE_BYTES = 16 * 1024 * 1024;
+/** Maximum decoded JSON response accepted from tool execution. */
+export const MAX_INTEGRATION_TOOL_CALL_RESPONSE_BYTES = 4 * 1024 * 1024;
+/** Maximum diagnostic prefix retained from a failed integration API response. */
+export const MAX_INTEGRATION_API_ERROR_RESPONSE_BYTES = 4 * 1024;
+/** Maximum number of remote tool definitions admitted atomically. */
+export const MAX_REMOTE_INTEGRATION_TOOL_DEFINITIONS = 1_000;
+/** Maximum caller or environment credential length admitted into an HTTP header. */
+export const MAX_REMOTE_INTEGRATION_API_TOKEN_LENGTH = 16_384;
+/** Runtime tool names use the same ceiling as the agent invocation contract. */
+export const MAX_REMOTE_INTEGRATION_TOOL_NAME_LENGTH = 128;
+/** Maximum canonical connector-name length at lookup and policy boundaries. */
+export const MAX_INTEGRATION_NAME_LENGTH = MAX_REMOTE_INTEGRATION_TOOL_NAME_LENGTH - 3;
+/** Maximum integrations admitted into one exact-source narrowing policy. */
+export const MAX_SOURCE_INTEGRATION_POLICY_INTEGRATIONS = 512;
+/** A segment must leave room for the separator and the other non-empty segment. */
+export const MAX_SOURCE_INTEGRATION_POLICY_SEGMENT_LENGTH = MAX_INTEGRATION_NAME_LENGTH;
+/** A policy cannot usefully name more tools than remote discovery can admit. */
+export const MAX_SOURCE_INTEGRATION_POLICY_TOOL_IDS = MAX_REMOTE_INTEGRATION_TOOL_DEFINITIONS;
+/** Runtime tool descriptions use the same ceiling as the agent invocation contract. */
+export const MAX_REMOTE_INTEGRATION_TOOL_DESCRIPTION_LENGTH = 1_024;
+/** Run and agent identifiers use the same ceiling as the agent invocation contract. */
+export const MAX_REMOTE_INTEGRATION_CONTEXT_ID_LENGTH = 128;
+/** Runtime tool schemas use the same serialized ceiling as the agent invocation contract. */
+export const MAX_REMOTE_INTEGRATION_TOOL_SCHEMA_BYTES = 16_384;
+/** Prevent recursively consumed provider schemas from approaching stack limits. */
+export const MAX_REMOTE_INTEGRATION_TOOL_SCHEMA_DEPTH = 64;

package/esm/src/integrations/remote-tools.d.ts

@@ -8,11 +8,7 @@
  * different projects expose different authorized integration tools. The agent runtime
  * calls these functions at tool-enumeration and tool-execution time.
  */
-import type { ToolDefinition } from "../tool/index.js";
-type RemoteIntegrationToolExecutionContext = {
-    runId?: string;
-    agentId?: string;
-};
+import type { ToolDefinition, ToolExecutionContext } from "../tool/index.js";
 /**
  * Fetch integration tool definitions for the current request context.
  * Returns ToolDefinition[] that the agent runtime merges into the model's
@@ -20,8 +16,10 @@ type RemoteIntegrationToolExecutionContext = {
  *
  * Called per agent loop iteration — results are scoped to the current
  * project's authorized integration tools via the per-request API token.
+ * Caller cancellation is propagated; remote failures and malformed or
+ * over-limit catalogs fail closed to an empty list.
  */
-export declare function getRemoteIntegrationToolDefinitions(): Promise<ToolDefinition[]>;
+export declare function getRemoteIntegrationToolDefinitions(context?: ToolExecutionContext): Promise<ToolDefinition[]>;
 /**
  * Check if a tool name looks like a remote integration tool.
  * Integration tools use "integration__tool_id" format (double underscore separator).
@@ -30,7 +28,8 @@ export declare function isRemoteIntegrationTool(toolName: string): boolean;
 /**
  * Execute a remote integration tool via the API.
  * Called by the agent runtime when a tool isn't found in the local registry.
+ * The request, response, and caller-supplied cancellation signal remain
+ * bounded for the complete network and response-body lifecycle.
  */
-export declare function executeRemoteIntegrationTool(toolName: string, args: Record<string, unknown>, context?: RemoteIntegrationToolExecutionContext): Promise<unknown>;
-export {};
+export declare function executeRemoteIntegrationTool(toolName: string, args: Record<string, unknown>, context?: ToolExecutionContext): Promise<unknown>;
 //# sourceMappingURL=remote-tools.d.ts.map

package/esm/src/integrations/remote-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote-tools.d.ts","sourceRoot":"","sources":["../../../src/src/integrations/remote-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAYH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAsBvD,KAAK,qCAAqC,GAAG;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AA2KF;;;;;;;GAOG;AACH,wBAAsB,mCAAmC,IAAI,OAAO,CAClE,cAAc,EAAE,CACjB,CAwBA;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEjE;AAED;;;GAGG;AACH,wBAAsB,4BAA4B,CAChD,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE,qCAAqC,GAC9C,OAAO,CAAC,OAAO,CAAC,CA4BlB"}
+{"version":3,"file":"remote-tools.d.ts","sourceRoot":"","sources":["../../../src/src/integrations/remote-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAkBH,OAAO,KAAK,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAokB7E;;;;;;;;;GASG;AACH,wBAAsB,mCAAmC,CACvD,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CACR,cAAc,EAAE,CACjB,CA2BA;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEjE;AAED;;;;;GAKG;AACH,wBAAsB,4BAA4B,CAChD,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,OAAO,CAAC,CAkClB"}

package/esm/src/integrations/remote-tools.js

@@ -8,29 +8,94 @@
  * different projects expose different authorized integration tools. The agent runtime
  * calls these functions at tool-enumeration and tool-execution time.
  */
-import { logger } from "../utils/index.js";
 import { getApiBaseUrlEnv, getApiTokenEnv } from "../config/env.js";
 import { getEnvironmentConfig } from "../config/environment-config.js";
 import { getActiveSourceIntegrationPolicy } from "./source-policy-context.js";
 import { isIntegrationToolAllowedBySourcePolicy, parseIntegrationToolIdentity, } from "./source-policy.js";
 import { getCurrentRequestContext } from "../platform/adapters/fs/veryfront/request-context.js";
-/**
- * Default timeout for outbound integration API calls. Without it, a hung remote
- * server would block the whole agent loop indefinitely.
- */
-const INTEGRATION_REQUEST_TIMEOUT_MS = 30_000;
+import { snapshotBoundedJsonValue } from "../schemas/json-value.js";
+import { logger } from "../utils/index.js";
+import { hasProjectIdentityControlCharacters, isCanonicalProjectSlug, } from "../utils/project-identity.js";
+import { readResponseTextPrefix } from "../utils/response-body.js";
+import { INTEGRATION_REQUEST_TIMEOUT_MS, MAX_INTEGRATION_API_ERROR_RESPONSE_BYTES, MAX_INTEGRATION_CALL_REQUEST_BYTES, MAX_INTEGRATION_TOOL_CALL_RESPONSE_BYTES, MAX_INTEGRATION_TOOL_LIST_RESPONSE_BYTES, MAX_REMOTE_INTEGRATION_API_TOKEN_LENGTH, MAX_REMOTE_INTEGRATION_CONTEXT_ID_LENGTH, MAX_REMOTE_INTEGRATION_TOOL_DEFINITIONS, MAX_REMOTE_INTEGRATION_TOOL_DESCRIPTION_LENGTH, MAX_REMOTE_INTEGRATION_TOOL_NAME_LENGTH, MAX_REMOTE_INTEGRATION_TOOL_SCHEMA_BYTES, MAX_REMOTE_INTEGRATION_TOOL_SCHEMA_DEPTH, } from "./limits.js";
+const utf8Encoder = new TextEncoder();
+const EMPTY_REMOTE_INTEGRATION_CONTEXT = Object.freeze({
+    hasExplicitCredential: false,
+    authToken: undefined,
+    projectSlug: undefined,
+    runId: undefined,
+    agentId: undefined,
+    abortSignal: undefined,
+});
+function snapshotToolExecutionContext(context, includeCallMetadata) {
+    if (context === undefined)
+        return EMPTY_REMOTE_INTEGRATION_CONTEXT;
+    if (typeof context !== "object" || context === null) {
+        throw new TypeError("Integration tool execution context must be an object");
+    }
+    const readOwnDataProperty = (key) => {
+        const descriptor = Reflect.getOwnPropertyDescriptor(context, key);
+        if (!descriptor)
+            return { present: false, value: undefined };
+        if (!("value" in descriptor)) {
+            throw new TypeError(`Integration tool execution context property "${key}" must be a data property`);
+        }
+        return { present: true, value: descriptor.value };
+    };
+    try {
+        const authToken = readOwnDataProperty("authToken");
+        const projectSlug = authToken.present
+            ? readOwnDataProperty("projectSlug")
+            : { present: false, value: undefined };
+        const runId = includeCallMetadata
+            ? readOwnDataProperty("runId")
+            : { present: false, value: undefined };
+        const agentId = includeCallMetadata
+            ? readOwnDataProperty("agentId")
+            : { present: false, value: undefined };
+        const abortSignal = readOwnDataProperty("abortSignal");
+        if (abortSignal.value !== undefined &&
+            !(abortSignal.value instanceof AbortSignal)) {
+            throw new TypeError("Integration tool execution context abortSignal must be an AbortSignal");
+        }
+        return Object.freeze({
+            hasExplicitCredential: authToken.present,
+            authToken: authToken.value,
+            projectSlug: projectSlug.value,
+            runId: runId.value,
+            agentId: agentId.value,
+            abortSignal: abortSignal.value,
+        });
+    }
+    catch (cause) {
+        throw new TypeError("Invalid integration tool execution context", { cause });
+    }
+}
 // ---------------------------------------------------------------------------
 // Per-request token resolution
 // ---------------------------------------------------------------------------
 function isValidApiToken(token) {
-    return typeof token === "string" && token.length > 0 && token === token.trim();
+    if (typeof token !== "string" ||
+        token.length === 0 ||
+        token.length > MAX_REMOTE_INTEGRATION_API_TOKEN_LENGTH) {
+        return false;
+    }
+    for (let index = 0; index < token.length; index++) {
+        const code = token.charCodeAt(index);
+        if (code < 0x21 || code > 0x7e)
+            return false;
+    }
+    return true;
 }
 /**
  * Resolve the API token for the active runtime mode.
  * Proxy mode requires a valid request-scoped project token. Single-project
  * runtimes may use their process-wide environment token.
  */
-function resolveRequestToken() {
+function resolveRequestToken(context) {
+    if (context.hasExplicitCredential) {
+        return isValidApiToken(context.authToken) ? context.authToken : undefined;
+    }
     const requestContext = getCurrentRequestContext();
     if (requestContext) {
         return isValidApiToken(requestContext.token) ? requestContext.token : undefined;
@@ -41,10 +106,23 @@ function resolveRequestToken() {
     return isValidApiToken(environmentToken) ? environmentToken : undefined;
 }
 function normalizeProjectSlug(projectSlug) {
-    const normalized = projectSlug?.trim();
-    return normalized || undefined;
+    if (projectSlug === undefined)
+        return undefined;
+    if (typeof projectSlug !== "string") {
+        throw new TypeError("Integration project slug must be a string");
+    }
+    const normalized = projectSlug.trim();
+    if (normalized.length === 0)
+        return undefined;
+    if (!isCanonicalProjectSlug(normalized)) {
+        throw new TypeError("Integration project slug must be canonical");
+    }
+    return normalized;
 }
-function resolveRequestProjectSlug() {
+function resolveRequestProjectSlug(context) {
+    if (context.hasExplicitCredential) {
+        return normalizeProjectSlug(context.projectSlug);
+    }
     const requestContext = getCurrentRequestContext();
     if (requestContext) {
         return normalizeProjectSlug(requestContext.projectSlug);
@@ -56,13 +134,14 @@ function resolveRequestProjectSlug() {
 // ---------------------------------------------------------------------------
 function joinCallToolText(content) {
     return content
-        .map((item) => item.text)
+        .map((item) => isRecord(item) && typeof item.text === "string" ? item.text : undefined)
         .filter((text) => text !== undefined)
         .join("\n");
 }
 function parseJsonText(text) {
     try {
-        return JSON.parse(text);
+        const snapshot = snapshotBoundedJsonValue(JSON.parse(text));
+        return snapshot.success ? snapshot.value : undefined;
     }
     catch {
         return undefined;
@@ -71,28 +150,197 @@ function parseJsonText(text) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isRemoteToolDefinition(value) {
-    return isRecord(value) &&
-        typeof value.name === "string" &&
-        isRemoteIntegrationTool(value.name) &&
-        typeof value.description === "string" &&
-        isRecord(value.inputSchema);
+function isJsonDepthWithin(value, maxDepth) {
+    const stack = [{ value, depth: 0 }];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current)
+            break;
+        if (current.depth > maxDepth)
+            return false;
+        if (Array.isArray(current.value)) {
+            for (const child of current.value) {
+                stack.push({ value: child, depth: current.depth + 1 });
+            }
+            continue;
+        }
+        if (isRecord(current.value)) {
+            for (const child of Object.values(current.value)) {
+                stack.push({ value: child, depth: current.depth + 1 });
+            }
+        }
+    }
+    return true;
+}
+function parseRemoteToolDefinition(value) {
+    if (!isRecord(value) ||
+        typeof value.name !== "string" ||
+        value.name.length > MAX_REMOTE_INTEGRATION_TOOL_NAME_LENGTH ||
+        !isRemoteIntegrationTool(value.name) ||
+        typeof value.description !== "string" ||
+        value.description.length > MAX_REMOTE_INTEGRATION_TOOL_DESCRIPTION_LENGTH) {
+        return undefined;
+    }
+    const schemaSnapshot = snapshotBoundedJsonValue(value.inputSchema);
+    if (!schemaSnapshot.success ||
+        !isRecord(schemaSnapshot.value) ||
+        !isJsonDepthWithin(schemaSnapshot.value, MAX_REMOTE_INTEGRATION_TOOL_SCHEMA_DEPTH)) {
+        return undefined;
+    }
+    const serializedSchema = JSON.stringify(schemaSnapshot.value);
+    if (utf8Encoder.encode(serializedSchema).byteLength > MAX_REMOTE_INTEGRATION_TOOL_SCHEMA_BYTES) {
+        return undefined;
+    }
+    return {
+        name: value.name,
+        description: value.description,
+        inputSchema: schemaSnapshot.value,
+    };
+}
+function parseToolListResponse(value) {
+    if (!isRecord(value) ||
+        !Array.isArray(value.tools) ||
+        value.tools.length > MAX_REMOTE_INTEGRATION_TOOL_DEFINITIONS) {
+        return undefined;
+    }
+    const definitions = [];
+    const names = new Set();
+    for (const candidate of value.tools) {
+        const definition = parseRemoteToolDefinition(candidate);
+        if (!definition || names.has(definition.name))
+            return undefined;
+        names.add(definition.name);
+        definitions.push(definition);
+    }
+    return definitions;
+}
+function createIntegrationRequestSignalScope(callerSignal) {
+    callerSignal?.throwIfAborted();
+    const controller = new AbortController();
+    const forwardCallerAbort = () => controller.abort(callerSignal?.reason);
+    const timeoutId = setTimeout(() => {
+        controller.abort(new DOMException(`Integration API request timed out after ${INTEGRATION_REQUEST_TIMEOUT_MS} ms`, "TimeoutError"));
+    }, INTEGRATION_REQUEST_TIMEOUT_MS);
+    const detachCaller = () => {
+        callerSignal?.removeEventListener("abort", forwardCallerAbort);
+    };
+    const cleanupAfterAbort = () => {
+        clearTimeout(timeoutId);
+        detachCaller();
+    };
+    controller.signal.addEventListener("abort", cleanupAfterAbort, { once: true });
+    if (callerSignal) {
+        callerSignal.addEventListener("abort", forwardCallerAbort, { once: true });
+        // An abort can race the initial check and listener registration.
+        if (callerSignal.aborted)
+            forwardCallerAbort();
+    }
+    let disposed = false;
+    return {
+        signal: controller.signal,
+        dispose: () => {
+            if (disposed)
+                return;
+            disposed = true;
+            clearTimeout(timeoutId);
+            detachCaller();
+            controller.signal.removeEventListener("abort", cleanupAfterAbort);
+        },
+    };
+}
+function discardResponseBody(response) {
+    if (!response.body)
+        return;
+    try {
+        const cancellation = response.body.cancel();
+        void cancellation.catch((error) => {
+            logger.debug("Failed to discard integration API response body", {
+                status: response.status,
+                errorName: error instanceof Error ? error.name : typeof error,
+            });
+        });
+    }
+    catch (error) {
+        logger.debug("Failed to discard integration API response body", {
+            status: response.status,
+            errorName: error instanceof Error ? error.name : typeof error,
+        });
+    }
+}
+function assertResponseContentLengthWithin(response, maxBytes, label) {
+    const rawContentLength = response.headers.get("content-length");
+    if (rawContentLength === null)
+        return;
+    const contentLength = Number(rawContentLength.trim());
+    if (!/^\d+$/.test(rawContentLength.trim()) ||
+        !Number.isSafeInteger(contentLength) ||
+        contentLength > maxBytes) {
+        discardResponseBody(response);
+        throw new Error(`${label} exceeds the ${maxBytes}-byte response limit`);
+    }
+}
+async function readBoundedResponseJson(response, maxBytes, signal, label) {
+    assertResponseContentLengthWithin(response, maxBytes, label);
+    const { text, truncated } = await readResponseTextPrefix(response, maxBytes + 1, signal, { fatalUtf8: true });
+    if (truncated || utf8Encoder.encode(text).byteLength > maxBytes) {
+        throw new Error(`${label} exceeds the ${maxBytes}-byte response limit`);
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (cause) {
+        throw new SyntaxError(`${label} is not valid JSON`, { cause });
+    }
+}
+function snapshotRemoteToolArguments(args) {
+    const snapshot = snapshotBoundedJsonValue(args);
+    if (!snapshot.success || !isRecord(snapshot.value)) {
+        throw new TypeError("Remote integration tool arguments must be a bounded JSON object without accessors or cycles");
+    }
+    return snapshot.value;
 }
-function isToolListResponse(value) {
-    return isRecord(value) &&
-        Array.isArray(value.tools) &&
-        value.tools.every(isRemoteToolDefinition);
+function serializeCallRequest(toolName, args, context) {
+    for (const [label, value] of [
+        ["run id", context.runId],
+        ["agent id", context.agentId],
+    ]) {
+        if (value === undefined)
+            continue;
+        if (typeof value !== "string") {
+            throw new TypeError(`Integration tool call ${label} must be a string`);
+        }
+        if (value.length > MAX_REMOTE_INTEGRATION_CONTEXT_ID_LENGTH) {
+            throw new RangeError(`Integration tool call ${label} exceeds the ${MAX_REMOTE_INTEGRATION_CONTEXT_ID_LENGTH}-character limit`);
+        }
+        if (value.length === 0 ||
+            value !== value.trim() ||
+            hasProjectIdentityControlCharacters(value)) {
+            throw new TypeError(`Integration tool call ${label} must be a canonical identifier`);
+        }
+    }
+    const body = {
+        name: toolName,
+        arguments: snapshotRemoteToolArguments(args),
+        ...(context.runId !== undefined ? { run_id: context.runId } : {}),
+        ...(context.agentId !== undefined ? { agent_id: context.agentId } : {}),
+    };
+    const serialized = JSON.stringify(body);
+    if (utf8Encoder.encode(serialized).byteLength > MAX_INTEGRATION_CALL_REQUEST_BYTES) {
+        throw new RangeError(`Integration tool call request exceeds the ${MAX_INTEGRATION_CALL_REQUEST_BYTES}-byte limit`);
+    }
+    return serialized;
 }
 /**
  * Issue an authenticated POST to the integration tools API with a bounded
  * timeout. The two endpoints have different response contracts — tools/list
  * throws on failure while tools/call maps failures into a structured result —
- * so callers own response handling; this centralizes the auth headers and the
- * timeout AbortSignal that both share. No retry: tools/call is not idempotent
+ * so callers own response handling and request-signal lifetime; this
+ * centralizes authenticated dispatch. No retry: tools/call is not idempotent
  * (a retried call could re-send an email or re-create a record).
  */
-async function postIntegrationApi(baseUrl, path, token, body) {
-    const projectSlug = resolveRequestProjectSlug();
+async function postIntegrationApi(baseUrl, path, token, serializedBody, context, signal) {
+    const projectSlug = resolveRequestProjectSlug(context);
+    signal.throwIfAborted();
     return await fetch(`${baseUrl}${path}`, {
         method: "POST",
         headers: {
@@ -100,51 +348,72 @@ async function postIntegrationApi(baseUrl, path, token, body) {
             "Content-Type": "application/json",
             ...(projectSlug ? { "x-veryfront-project-slug": projectSlug } : {}),
         },
-        ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
-        signal: AbortSignal.timeout(INTEGRATION_REQUEST_TIMEOUT_MS),
+        ...(serializedBody !== undefined ? { body: serializedBody } : {}),
+        signal,
     });
 }
-async function fetchToolList(baseUrl, token) {
-    const response = await postIntegrationApi(baseUrl, "/integrations/tools/list", token);
-    if (!response.ok) {
-        // Throw so callers can distinguish a fetch failure from "no remote tools
-        // available" (which returns an empty tools array with status 200).
-        throw new Error(`Integration tools API returned ${response.status} ${response.statusText}`.trim());
+async function fetchToolList(baseUrl, token, context) {
+    const requestScope = createIntegrationRequestSignalScope(context.abortSignal);
+    try {
+        const response = await postIntegrationApi(baseUrl, "/integrations/tools/list", token, undefined, context, requestScope.signal);
+        if (!response.ok) {
+            // Throw so callers can distinguish a fetch failure from "no remote tools
+            // available" (which returns an empty tools array with status 200).
+            discardResponseBody(response);
+            throw new Error(`Integration tools API returned ${response.status} ${response.statusText}`.trim());
+        }
+        const rawData = await readBoundedResponseJson(response, MAX_INTEGRATION_TOOL_LIST_RESPONSE_BYTES, requestScope.signal, "Integration tools API list response");
+        const definitions = parseToolListResponse(rawData);
+        if (!definitions) {
+            throw new Error("Integration tools API returned unexpected response shape");
+        }
+        return definitions;
     }
-    const rawData = await response.json();
-    if (!isToolListResponse(rawData)) {
-        throw new Error("Integration tools API returned unexpected response shape");
+    finally {
+        requestScope.dispose();
     }
-    return rawData.tools ?? [];
 }
 async function callRemoteTool(baseUrl, token, toolName, args, context) {
-    const response = await postIntegrationApi(baseUrl, "/integrations/tools/call", token, {
-        name: toolName,
-        arguments: args,
-        run_id: context?.runId,
-        agent_id: context?.agentId,
-    });
-    if (!response.ok) {
-        const text = await response.text();
-        return { error: "api_error", status: response.status, message: text };
-    }
-    const result = await response.json();
-    // If MCP CallToolResult format, extract content
-    if (result?.content && Array.isArray(result.content)) {
-        const text = joinCallToolText(result.content);
-        if (result.structuredContent) {
-            return result.structuredContent;
+    const requestScope = createIntegrationRequestSignalScope(context.abortSignal);
+    try {
+        const serializedBody = serializeCallRequest(toolName, args, context);
+        const response = await postIntegrationApi(baseUrl, "/integrations/tools/call", token, serializedBody, context, requestScope.signal);
+        if (!response.ok) {
+            const { text } = await readResponseTextPrefix(response, MAX_INTEGRATION_API_ERROR_RESPONSE_BYTES, requestScope.signal, { fatalUtf8: true });
+            return { error: "api_error", status: response.status, message: text };
         }
-        if (result.isError) {
-            // Try to preserve structured error data (e.g., authentication_required with connectUrl)
-            const parsed = parseJsonText(text);
-            if (parsed && typeof parsed === "object")
-                return parsed;
-            return { error: "tool_error", message: text };
+        const rawResult = await readBoundedResponseJson(response, MAX_INTEGRATION_TOOL_CALL_RESPONSE_BYTES, requestScope.signal, "Integration tools API call response");
+        const resultSnapshot = snapshotBoundedJsonValue(rawResult);
+        if (!resultSnapshot.success) {
+            throw new TypeError("Integration tools API call response exceeds bounded JSON shape limits");
         }
-        return parseJsonText(text) ?? text;
+        const result = resultSnapshot.value;
+        // If MCP CallToolResult format, extract content.
+        if (isRecord(result) && Array.isArray(result.content)) {
+            const text = joinCallToolText(result.content);
+            if (Object.hasOwn(result, "structuredContent")) {
+                if (!isRecord(result.structuredContent)) {
+                    throw new TypeError("Integration tools API returned malformed MCP structured content");
+                }
+                return result.structuredContent;
+            }
+            if (Object.hasOwn(result, "isError") && typeof result.isError !== "boolean") {
+                throw new TypeError("Integration tools API returned a malformed MCP error marker");
+            }
+            if (result.isError === true) {
+                // Preserve structured errors such as authentication_required + connectUrl.
+                const parsed = parseJsonText(text);
+                if (parsed && typeof parsed === "object")
+                    return parsed;
+                return { error: "tool_error", message: text };
+            }
+            return parseJsonText(text) ?? text;
+        }
+        return result;
+    }
+    finally {
+        requestScope.dispose();
     }
-    return result;
 }
 // ---------------------------------------------------------------------------
 // Public API — called by agent runtime per-request
@@ -156,14 +425,18 @@ async function callRemoteTool(baseUrl, token, toolName, args, context) {
  *
  * Called per agent loop iteration — results are scoped to the current
  * project's authorized integration tools via the per-request API token.
+ * Caller cancellation is propagated; remote failures and malformed or
+ * over-limit catalogs fail closed to an empty list.
  */
-export async function getRemoteIntegrationToolDefinitions() {
+export async function getRemoteIntegrationToolDefinitions(context) {
+    const requestContext = snapshotToolExecutionContext(context, false);
+    requestContext.abortSignal?.throwIfAborted();
     const baseUrl = getApiBaseUrlEnv();
-    const token = resolveRequestToken();
+    const token = resolveRequestToken(requestContext);
     if (!baseUrl || !token)
         return [];
     try {
-        const remoteDefs = await fetchToolList(baseUrl, token);
+        const remoteDefs = await fetchToolList(baseUrl, token, requestContext);
         const sourceIntegrationPolicy = getActiveSourceIntegrationPolicy();
         return remoteDefs.filter((def) => sourceIntegrationPolicy === undefined ||
             isIntegrationToolAllowedBySourcePolicy(def.name, sourceIntegrationPolicy)).map((def) => ({
@@ -175,6 +448,7 @@ export async function getRemoteIntegrationToolDefinitions() {
         }));
     }
     catch (err) {
+        requestContext.abortSignal?.throwIfAborted();
         logger.error("Failed to fetch remote integration tool definitions", {
             error: err instanceof Error ? err.message : String(err),
         });
@@ -191,9 +465,15 @@ export function isRemoteIntegrationTool(toolName) {
 /**
  * Execute a remote integration tool via the API.
  * Called by the agent runtime when a tool isn't found in the local registry.
+ * The request, response, and caller-supplied cancellation signal remain
+ * bounded for the complete network and response-body lifecycle.
  */
 export async function executeRemoteIntegrationTool(toolName, args, context) {
-    if (!isRemoteIntegrationTool(toolName)) {
+    const requestContext = snapshotToolExecutionContext(context, true);
+    requestContext.abortSignal?.throwIfAborted();
+    if (typeof toolName !== "string" ||
+        toolName.length > MAX_REMOTE_INTEGRATION_TOOL_NAME_LENGTH ||
+        !isRemoteIntegrationTool(toolName)) {
         throw new Error(`Remote integration tool "${toolName}" must use the canonical integration__tool_id name`);
     }
     const sourceIntegrationPolicy = getActiveSourceIntegrationPolicy();
@@ -202,9 +482,9 @@ export async function executeRemoteIntegrationTool(toolName, args, context) {
         throw new Error(`Tool "${toolName}" is not allowed by the source integration policy`);
     }
     const baseUrl = getApiBaseUrlEnv();
-    const token = resolveRequestToken();
+    const token = resolveRequestToken(requestContext);
     if (!baseUrl || !token) {
         return { error: "no_api_token", message: "No API token available" };
     }
-    return callRemoteTool(baseUrl, token, toolName, args, context);
+    return callRemoteTool(baseUrl, token, toolName, args, requestContext);
 }