stitchkit 0.104.1 → 0.105.0

package/dist/entrypoints/tools/connections.js

@@ -1,23 +1,32 @@
+import {
+  AppError2,
+  STITCH_ERROR_STATUS2,
+  isRetryableStatus2
+} from "../../index-j9gxbztg.js";
+import {
+  TOOL_ERROR_PROJECTION
+} from "../../index-556g5hsh.js";
 import"../../index-ct75c3at.js";
 import {
   declaresDraft07,
   withDefsDialect
-} from "../../index-77nxk6ay.js";
+} from "../../index-r393tnfp.js";
+import"../../index-rpzewktb.js";
 import {
-  AppError2
-} from "../../index-x928baz2.js";
-import"../../index-kb8styz3.js";
+  withSignalDeadline
+} from "../../index-9tqbxv5p.js";
 import {
-  defineRuntimeTool2
-} from "../../index-cvda079a.js";
+  raceAbort
+} from "../../index-b0kddvzw.js";
 import {
-  ConnectionAuthorizationRequiredError2,
-  ConnectionRequestError2,
-  ConnectionUrlError2,
-  ConnectionBudgetExceededError2,
-  ConnectionTimeoutError2,
-  ConnectionResponseTooLargeError2
-} from "../../index-1a6jtnd9.js";
+  MAX_TIMER_MS
+} from "../../index-eemvahkc.js";
+import {
+  assertPositiveSafeInteger
+} from "../../index-0s4xebbg.js";
+import {
+  defineRuntimeTool2
+} from "../../index-yvfk3y36.js";
 import {
   safeJsonParse
 } from "../../index-zsarb5xp.js";
@@ -25,10 +34,186 @@ import {
   isRecord
 } from "../../index-9jfdm5tg.js";
 
+// src/tools/connections/errors.ts
+class ConnectionAuthorizationRequiredError extends Error {
+  connectionName;
+  instanceId;
+  operation;
+  phase;
+  constructor(connectionName, instanceId, context = {}) {
+    super(`Connection "${connectionName}" requires authorization`);
+    this.name = "ConnectionAuthorizationRequiredError";
+    this.connectionName = connectionName;
+    this.instanceId = instanceId;
+    this.operation = context.operation ?? "request";
+    this.phase = context.phase ?? "call";
+  }
+  [TOOL_ERROR_PROJECTION]() {
+    const message = "Authorization required";
+    return new AppError2("UNAUTHORIZED", {
+      message,
+      status: STITCH_ERROR_STATUS2.UNAUTHORIZED,
+      details: {
+        message,
+        reason: "authorization-required",
+        operation: this.operation,
+        phase: this.phase
+      },
+      hint: "Obtain a new credential before retrying.",
+      retryable: false
+    });
+  }
+}
+
+class ConnectionRequestError extends Error {
+  connectionName;
+  status;
+  body;
+  operation;
+  phase;
+  constructor(connectionName, status, body, context = {}) {
+    super(`Connection "${connectionName}" request failed with status ${status}`);
+    this.name = "ConnectionRequestError";
+    this.connectionName = connectionName;
+    this.status = status;
+    this.body = body;
+    this.operation = context.operation ?? "request";
+    this.phase = context.phase ?? "call";
+  }
+  [TOOL_ERROR_PROJECTION]() {
+    const forbidden = this.status === 403;
+    const code = forbidden ? "FORBIDDEN" : "CONNECTION_REQUEST_FAILED";
+    const message = forbidden ? "Connection access denied" : "Connection request failed";
+    return new AppError2(code, {
+      message,
+      status: STITCH_ERROR_STATUS2[code],
+      details: {
+        message,
+        reason: forbidden ? "permission-denied" : "upstream-request-failed",
+        operation: this.operation,
+        phase: this.phase,
+        upstreamStatus: this.status
+      },
+      hint: forbidden ? "Check the credential permissions." : "Check the upstream service and verify any write outcome before retrying.",
+      retryable: !forbidden && isRetryableStatus2(this.status)
+    });
+  }
+}
+
+class ConnectionUrlError extends Error {
+  url;
+  constructor(message, url) {
+    super(message);
+    this.name = "ConnectionUrlError";
+    this.url = url;
+  }
+  [TOOL_ERROR_PROJECTION]() {
+    return new AppError2("BAD_REQUEST", {
+      message: "Connection URL refused",
+      status: STITCH_ERROR_STATUS2.BAD_REQUEST,
+      details: { message: "Connection URL refused", reason: "url-rejected" },
+      hint: "Check the connection URL and its allowed hosts.",
+      retryable: false
+    });
+  }
+}
+
+class ConnectionBudgetExceededError extends Error {
+  limit;
+  actual;
+  constructor(limit, actual, unit = "tools") {
+    super(`Connection surface exposes ${actual} ${unit}, above the budget of ${limit}`);
+    this.name = "ConnectionBudgetExceededError";
+    this.limit = limit;
+    this.actual = actual;
+  }
+  [TOOL_ERROR_PROJECTION]() {
+    return new AppError2("BAD_REQUEST", {
+      message: "Connection mount budget exceeded",
+      status: STITCH_ERROR_STATUS2.BAD_REQUEST,
+      details: {
+        message: "Connection mount budget exceeded",
+        reason: "mount-budget-exceeded",
+        limit: this.limit,
+        actual: this.actual
+      },
+      hint: "Narrow the mounted tool surface or increase its mount budget.",
+      retryable: false
+    });
+  }
+}
+
+class ConnectionTimeoutError extends Error {
+  connectionName;
+  timeoutMs;
+  operation;
+  phase;
+  observedReadBytes;
+  constructor(connectionName, timeoutMs, context = {}) {
+    super(`Connection "${connectionName}" timed out after ${timeoutMs} ms`);
+    this.name = "ConnectionTimeoutError";
+    this.connectionName = connectionName;
+    this.timeoutMs = timeoutMs;
+    this.operation = context.operation ?? "request";
+    this.phase = context.phase ?? "call";
+    this.observedReadBytes = context.observedReadBytes ?? 0;
+  }
+  [TOOL_ERROR_PROJECTION]() {
+    const message = "Connection deadline exceeded";
+    return new AppError2("CONNECTION_TIMEOUT", {
+      message,
+      status: STITCH_ERROR_STATUS2.CONNECTION_TIMEOUT,
+      details: {
+        message,
+        reason: "deadline-exceeded",
+        operation: this.operation,
+        phase: this.phase,
+        timeoutMs: this.timeoutMs,
+        observedReadBytes: this.observedReadBytes
+      },
+      hint: "Check the connection deadline and verify any write outcome before retrying.",
+      retryable: false
+    });
+  }
+}
+
+class ConnectionResponseTooLargeError extends Error {
+  connectionName;
+  maxBytes;
+  operation;
+  phase;
+  observedReadBytes;
+  constructor(connectionName, maxBytes, context = {}) {
+    super(`Connection "${connectionName}" response exceeded the ${maxBytes} byte limit`);
+    this.name = "ConnectionResponseTooLargeError";
+    this.connectionName = connectionName;
+    this.maxBytes = maxBytes;
+    this.operation = context.operation ?? "request";
+    this.phase = context.phase ?? "call";
+    this.observedReadBytes = context.observedReadBytes ?? 0;
+  }
+  [TOOL_ERROR_PROJECTION]() {
+    const message = "Connection response exceeds the byte limit";
+    return new AppError2("CONNECTION_RESPONSE_TOO_LARGE", {
+      message,
+      status: STITCH_ERROR_STATUS2.CONNECTION_RESPONSE_TOO_LARGE,
+      details: {
+        message,
+        reason: "response-too-large",
+        operation: this.operation,
+        phase: this.phase,
+        maxResponseBytes: this.maxBytes,
+        observedReadBytes: this.observedReadBytes
+      },
+      hint: "Narrow the response or increase the limit for this operation phase.",
+      retryable: false
+    });
+  }
+}
+
 // src/tools/connections/limits.ts
 var DEFAULT_CONNECTION_TIMEOUT_MS = 30000;
 var DEFAULT_MAX_RESPONSE_BYTES = 1024 * 1024;
-var MAX_TIMER_MS = 2147483647;
 function connectionTimeoutMs(value) {
   if (value === undefined)
     return DEFAULT_CONNECTION_TIMEOUT_MS;
@@ -40,55 +225,19 @@ function connectionTimeoutMs(value) {
 function connectionMaxResponseBytes(value) {
   if (value === undefined)
     return DEFAULT_MAX_RESPONSE_BYTES;
-  if (!Number.isSafeInteger(value) || value <= 0) {
-    throw new RangeError("Connection maxResponseBytes must be a positive safe integer");
-  }
+  assertPositiveSafeInteger("Connection maxResponseBytes", value, RangeError);
   return value;
 }
-async function awaitConnection(pending, signal) {
-  if (!signal)
-    return pending;
-  if (signal.aborted) {
-    pending.catch(() => {
-      return;
-    });
-    signal.throwIfAborted();
-  }
-  const aborted = Promise.withResolvers();
-  const onAbort = () => aborted.reject(signal.reason);
-  signal.addEventListener("abort", onAbort, { once: true });
-  try {
-    signal.throwIfAborted();
-    const result = await Promise.race([pending, aborted.promise]);
-    signal.throwIfAborted();
-    return result;
-  } catch (error) {
-    signal.throwIfAborted();
-    throw error;
-  } finally {
-    signal.removeEventListener("abort", onAbort);
-  }
+function awaitConnection(pending, signal) {
+  return signal ? raceAbort(pending, signal) : pending;
 }
-async function withConnectionDeadline(connectionName, timeoutMs, callerSignal, body, context) {
-  connectionTimeoutMs(timeoutMs);
-  const controller = new AbortController;
-  const timer = setTimeout(() => controller.abort(new ConnectionTimeoutError2(connectionName, timeoutMs, context)), timeoutMs);
-  const onAbort = () => controller.abort(callerSignal?.reason);
-  if (callerSignal) {
-    if (callerSignal.aborted)
-      controller.abort(callerSignal.reason);
-    else
-      callerSignal.addEventListener("abort", onAbort, { once: true });
-  }
-  if (context)
-    context.signal = controller.signal;
-  try {
-    controller.signal.throwIfAborted();
-    return await awaitConnection(body(controller.signal), controller.signal);
-  } finally {
-    clearTimeout(timer);
-    callerSignal?.removeEventListener("abort", onAbort);
-  }
+function withConnectionDeadline(connectionName, context, callerSignal, body) {
+  const timeoutMs = connectionTimeoutMs(context.timeoutMs);
+  let scoped = context;
+  return withSignalDeadline(timeoutMs, callerSignal, () => new ConnectionTimeoutError(connectionName, timeoutMs, scoped), (signal) => {
+    scoped = { ...context, signal };
+    return raceAbort(body(scoped), signal);
+  });
 }
 async function readBoundedText(response, maxBytes, connectionName, context) {
   context?.signal?.throwIfAborted();
@@ -111,7 +260,7 @@ async function readBoundedText(response, maxBytes, connectionName, context) {
       if (context)
         context.observedReadBytes += value.byteLength;
       if (total > maxBytes) {
-        throw new ConnectionResponseTooLargeError2(connectionName, maxBytes, {
+        throw new ConnectionResponseTooLargeError(connectionName, maxBytes, {
           ...context,
           observedReadBytes: total
         });
@@ -134,7 +283,7 @@ async function readConnectionErrorText(response, connectionName, context) {
     return (await readBoundedText(response, context.maxResponseBytes, connectionName, context)).slice(0, 512);
   } catch (error) {
     context.signal?.throwIfAborted();
-    if (error instanceof ConnectionResponseTooLargeError2 || error instanceof ConnectionTimeoutError2) {
+    if (error instanceof ConnectionResponseTooLargeError || error instanceof ConnectionTimeoutError) {
       throw error;
     }
     return "";
@@ -178,10 +327,10 @@ function assertConnectionUrl(rawUrl, connectionName) {
   try {
     url = new URL(rawUrl);
   } catch {
-    throw new ConnectionUrlError2(`Connection "${connectionName}" has an unparseable URL: ${rawUrl}`, rawUrl);
+    throw new ConnectionUrlError(`Connection "${connectionName}" has an unparseable URL: ${rawUrl}`, rawUrl);
   }
   if (url.protocol !== "http:" && url.protocol !== "https:") {
-    throw new ConnectionUrlError2(`Connection "${connectionName}" must use http(s), got "${url.protocol}"`, rawUrl);
+    throw new ConnectionUrlError(`Connection "${connectionName}" must use http(s), got "${url.protocol}"`, rawUrl);
   }
   return url;
 }
@@ -193,7 +342,7 @@ function connectionAllowedHosts(connectionUrl, extra) {
 }
 function assertAllowedHost(url, allowedHosts, connectionName) {
   if (!allowedHosts.has(url.host.toLowerCase())) {
-    throw new ConnectionUrlError2(`Connection "${connectionName}" refused request to host "${url.host}": not the connection host or an allowed host`, url.toString());
+    throw new ConnectionUrlError(`Connection "${connectionName}" refused request to host "${url.host}": not the connection host or an allowed host`, url.toString());
   }
 }
 
@@ -230,7 +379,7 @@ async function fetchConnection(target, init, allowedHosts, connectionName) {
   const response = await fetch(url, { ...init, redirect: "manual" });
   if (response.status >= 300 && response.status < 400) {
     await response.body?.cancel();
-    throw new ConnectionUrlError2(`Connection "${connectionName}" refused a redirect`, url.toString());
+    throw new ConnectionUrlError(`Connection "${connectionName}" refused a redirect`, url.toString());
   }
   return response;
 }
@@ -262,7 +411,7 @@ async function* readSseFrames(response, maxBytes, connectionName, options = {})
   const context = () => options.currentContext?.() ?? options.context;
   const tooLarge = (observedReadBytes) => {
     const current = context();
-    return new ConnectionResponseTooLargeError2(connectionName, current?.maxResponseBytes ?? maxBytes, { ...current, observedReadBytes });
+    return new ConnectionResponseTooLargeError(connectionName, current?.maxResponseBytes ?? maxBytes, { ...current, observedReadBytes });
   };
   try {
     for (;; ) {
@@ -356,7 +505,7 @@ class SseSession {
       return this.waitForEndpoint(signal);
     }
     const readiness = this.endpointContext;
-    return withConnectionDeadline(this.connectionName, readiness.timeoutMs, signal, (deadline) => this.waitForEndpoint(deadline), readiness);
+    return withConnectionDeadline(this.connectionName, readiness, signal, (scoped) => this.waitForEndpoint(scoped.signal));
   }
   close(reason = new Error("MCP SSE session closed")) {
     if (this.controller.signal.aborted)
@@ -383,7 +532,7 @@ class SseSession {
     if (context)
       return this.requestWithin(message, token, context, signal);
     const operation = connectionReadContext(mcpOperation(message.method), this.limits);
-    return withConnectionDeadline(this.connectionName, operation.timeoutMs, signal, (deadline) => this.requestWithin(message, token, operation, deadline), operation);
+    return withConnectionDeadline(this.connectionName, operation, signal, (scoped) => this.requestWithin(message, token, scoped, scoped.signal));
   }
   async requestWithin(message, token, context, signal) {
     const abort = () => this.close(signal?.reason);
@@ -425,10 +574,10 @@ class SseSession {
       response.body?.cancel().catch(() => {
         return;
       });
-      throw new ConnectionAuthorizationRequiredError2(this.connectionName, this.instanceId, context);
+      throw new ConnectionAuthorizationRequiredError(this.connectionName, this.instanceId, context);
     }
     if (!response.ok) {
-      throw new ConnectionRequestError2(this.connectionName, response.status, await readConnectionErrorText(response, this.connectionName, context), context);
+      throw new ConnectionRequestError(this.connectionName, response.status, await readConnectionErrorText(response, this.connectionName, context), context);
     }
   }
   currentContext() {
@@ -448,7 +597,7 @@ class SseSession {
       const total = (this.streamBytes.get(context) ?? 0) + bytes;
       this.streamBytes.set(context, total);
       if (total > context.maxResponseBytes) {
-        throw new ConnectionResponseTooLargeError2(this.connectionName, context.maxResponseBytes, { ...context, observedReadBytes: total });
+        throw new ConnectionResponseTooLargeError(this.connectionName, context.maxResponseBytes, { ...context, observedReadBytes: total });
       }
     }
   }
@@ -537,7 +686,7 @@ class McpHttpClient {
       await this.dispatch({ jsonrpc: "2.0", method: "notifications/initialized" }, token, signal);
     } catch (error) {
       signal?.throwIfAborted();
-      if (error instanceof ConnectionTimeoutError2 || error instanceof ConnectionResponseTooLargeError2) {
+      if (error instanceof ConnectionTimeoutError || error instanceof ConnectionResponseTooLargeError) {
         throw error;
       }
     }
@@ -551,21 +700,21 @@ class McpHttpClient {
     const negotiate = message.method === "initialize" && this.initialInitializePending;
     if (message.method === "initialize")
       this.initialInitializePending = false;
-    return withConnectionDeadline(this.connectionName, context.timeoutMs, signal, async () => {
+    return withConnectionDeadline(this.connectionName, context, signal, async (scoped) => {
       if (this.mode === "sse")
-        return this.sseRequest(message, token, context);
+        return this.sseRequest(message, token, scoped);
       try {
-        return await this.streamableRequest(message, token, context);
+        return await this.streamableRequest(message, token, scoped);
       } catch (error) {
-        context.signal?.throwIfAborted();
-        if (negotiate && error instanceof ConnectionRequestError2 && FALLBACK_STATUSES.has(error.status)) {
-          await this.openSse(token, context);
+        scoped.signal?.throwIfAborted();
+        if (negotiate && error instanceof ConnectionRequestError && FALLBACK_STATUSES.has(error.status)) {
+          await this.openSse(token, scoped);
           this.mode = "sse";
-          return this.sseRequest(message, token, context);
+          return this.sseRequest(message, token, scoped);
         }
         throw error;
       }
-    }, context);
+    });
   }
   async streamableRequest(message, token, context) {
     const target = new URL(this.options.transport.url);
@@ -581,10 +730,10 @@ class McpHttpClient {
       response.body?.cancel().catch(() => {
         return;
       });
-      throw new ConnectionAuthorizationRequiredError2(this.connectionName, this.instanceId, context);
+      throw new ConnectionAuthorizationRequiredError(this.connectionName, this.instanceId, context);
     }
     if (!response.ok) {
-      throw new ConnectionRequestError2(this.connectionName, response.status, await readConnectionErrorText(response, this.connectionName, context), context);
+      throw new ConnectionRequestError(this.connectionName, response.status, await readConnectionErrorText(response, this.connectionName, context), context);
     }
     const session = response.headers.get("mcp-session-id");
     if (session)
@@ -675,9 +824,19 @@ function mcpToolFailure(toolName, result) {
   if (isRecord(payload) && typeof payload.error === "string") {
     const details = isRecord(payload.details) ? payload.details : undefined;
     const message = typeof details?.message === "string" ? details.message : payload.error;
-    return new AppError2(payload.error, message, 502, details, typeof payload._hint === "string" ? payload._hint : undefined, undefined, typeof payload.retryable === "boolean" ? payload.retryable : undefined);
+    return new AppError2(payload.error, {
+      message,
+      status: 502,
+      details,
+      hint: typeof payload._hint === "string" ? payload._hint : undefined,
+      retryable: typeof payload.retryable === "boolean" ? payload.retryable : undefined
+    });
   }
-  return new AppError2(UPSTREAM_TOOL_ERROR, `External MCP tool "${toolName}" returned an error`, 502, payload === undefined ? undefined : { upstream: payload });
+  return new AppError2(UPSTREAM_TOOL_ERROR, {
+    message: `External MCP tool "${toolName}" returned an error`,
+    status: 502,
+    details: payload === undefined ? undefined : { upstream: payload }
+  });
 }
 
 // src/tools/connections/runtime.ts
@@ -687,7 +846,7 @@ async function withConnectionToken(params, body) {
   try {
     return await body(token);
   } catch (error) {
-    if (error instanceof ConnectionAuthorizationRequiredError2) {
+    if (error instanceof ConnectionAuthorizationRequiredError) {
       params.client?.teardown();
     }
     throw error;
@@ -929,8 +1088,12 @@ async function mountOpenApiConnection(connection, instanceId, onSkipped) {
           discovery: { timeoutMs, maxResponseBytes },
           call: { timeoutMs, maxResponseBytes }
         });
-        return withConnectionDeadline(connection.name, timeoutMs, context.signal, async (signal) => {
-          const requestInit = { method: entry.method, headers, signal };
+        return withConnectionDeadline(connection.name, readContext, context.signal, async (scoped) => {
+          const requestInit = {
+            method: entry.method,
+            headers,
+            signal: scoped.signal
+          };
           if (body && args.body !== undefined) {
             headers["content-type"] = "application/json";
             requestInit.body = JSON.stringify(args.body);
@@ -938,13 +1101,13 @@ async function mountOpenApiConnection(connection, instanceId, onSkipped) {
           const response = await fetchConnection(url, requestInit, allowedHosts, connection.name);
           if (response.status === 401) {
             await response.body?.cancel();
-            throw new ConnectionAuthorizationRequiredError2(connection.name, instanceId, readContext);
+            throw new ConnectionAuthorizationRequiredError(connection.name, instanceId, scoped);
           }
           if (!response.ok) {
-            throw new ConnectionRequestError2(connection.name, response.status, await readConnectionErrorText(response, connection.name, readContext), readContext);
+            throw new ConnectionRequestError(connection.name, response.status, await readConnectionErrorText(response, connection.name, scoped), scoped);
           }
-          return readResponse(response, maxResponseBytes, connection.name, readContext);
-        }, readContext);
+          return readResponse(response, maxResponseBytes, connection.name, scoped);
+        });
       })
     });
     recordForeignSchemaBytes(definition, jsonSchemaBytes(schema));
@@ -970,13 +1133,13 @@ async function loadOpenApiDocument(connection, timeoutMs, maxResponseBytes) {
     discovery: { timeoutMs, maxResponseBytes },
     call: { timeoutMs, maxResponseBytes }
   });
-  const parsed = await withConnectionDeadline(connection.name, timeoutMs, undefined, async (signal) => {
-    const response = await fetchConnection(url, { signal }, connectionAllowedHosts(url, connection.allowHosts), connection.name);
+  const parsed = await withConnectionDeadline(connection.name, readContext, undefined, async (scoped) => {
+    const response = await fetchConnection(url, { signal: scoped.signal }, connectionAllowedHosts(url, connection.allowHosts), connection.name);
     if (!response.ok) {
-      throw new ConnectionRequestError2(connection.name, response.status, await readConnectionErrorText(response, connection.name, readContext), readContext);
+      throw new ConnectionRequestError(connection.name, response.status, await readConnectionErrorText(response, connection.name, scoped), scoped);
     }
-    return readBoundedJson(response, maxResponseBytes, connection.name, readContext);
-  }, readContext);
+    return readBoundedJson(response, maxResponseBytes, connection.name, scoped);
+  });
   if (!isRecord(parsed))
     throw new Error(`OpenAPI spec at ${url} is not an object`);
   return { document: parsed, url: url.toString() };
@@ -1206,13 +1369,13 @@ async function mountConnections(connections, options = {}) {
   }
   const limit = options.budget?.maxTools;
   if (limit !== undefined && tools.length > limit) {
-    throw new ConnectionBudgetExceededError2(limit, tools.length);
+    throw new ConnectionBudgetExceededError(limit, tools.length);
   }
   const schemaLimit = options.budget?.maxSchemaBytes;
   if (schemaLimit !== undefined) {
     const schemaBytes = tools.reduce((total, tool) => total + foreignSchemaBytes(tool), 0);
     if (schemaBytes > schemaLimit) {
-      throw new ConnectionBudgetExceededError2(schemaLimit, schemaBytes, "schema bytes");
+      throw new ConnectionBudgetExceededError(schemaLimit, schemaBytes, "schema bytes");
     }
   }
   return tools;
@@ -1231,12 +1394,12 @@ function instanceIdOf(connection) {
   return connectionInstanceId(connection.name, url, connection.instanceKey);
 }
 export {
-  ConnectionAuthorizationRequiredError2 as ConnectionAuthorizationRequiredError,
-  ConnectionBudgetExceededError2 as ConnectionBudgetExceededError,
-  ConnectionRequestError2 as ConnectionRequestError,
-  ConnectionResponseTooLargeError2 as ConnectionResponseTooLargeError,
-  ConnectionTimeoutError2 as ConnectionTimeoutError,
-  ConnectionUrlError2 as ConnectionUrlError,
+  ConnectionAuthorizationRequiredError,
+  ConnectionBudgetExceededError,
+  ConnectionRequestError,
+  ConnectionResponseTooLargeError,
+  ConnectionTimeoutError,
+  ConnectionUrlError,
   defineMcpClientConnection,
   defineOpenApiConnection,
   mountConnections

package/dist/entrypoints/tools/contract.js

@@ -6,10 +6,10 @@ import {
   ViewFileErrorSchema2,
   ViewFileOutputSchema2,
   ViewFileInputSchema2
-} from "../../index-zax7resm.js";
+} from "../../index-0gxvns6s.js";
 import {
   coerceJsonArgs2
-} from "../../index-9pw0a51a.js";
+} from "../../index-6yxhe58g.js";
 export {
   AsyncOperationCancelResultSchema2 as AsyncOperationCancelResultSchema,
   McpAnnotationsSchema2 as McpAnnotationsSchema,

package/dist/entrypoints/tools/invoker.js

@@ -1,14 +1,15 @@
-import"../../index-x928baz2.js";
-import"../../index-kb8styz3.js";
-import"../../index-2vnh05w4.js";
+import"../../index-j9gxbztg.js";
+import"../../index-rpzewktb.js";
+import"../../index-556g5hsh.js";
+import"../../index-2k91mewf.js";
 import"../../index-yex7eg1v.js";
-import"../../index-9pw0a51a.js";
+import"../../index-6yxhe58g.js";
 import"../../index-ct75c3at.js";
-import"../../index-77nxk6ay.js";
-import"../../index-2hyavjjj.js";
+import"../../index-r393tnfp.js";
+import"../../index-wbhdzxar.js";
 import {
   createToolInvoker2
-} from "../../index-fa4wg312.js";
+} from "../../index-f199nfq5.js";
 import"../../index-7n68nmc6.js";
 export {
   createToolInvoker2 as createToolInvoker

package/dist/entrypoints/tools/mcp.d.ts

@@ -7,6 +7,6 @@ export { buildMcpServer, type DirectMcpSurfaceConfig, type FiniteMcpSurfaceConfi
 export type { IncompatibleSchemaPolicy, McpSchemaValidationConfig, McpSurfaceDefinition, McpSurfaceRegistry, ValidateMcpSchemasConfig, } from '../../tools/mcp/prepare.js';
 export { createStdioMcpServer, type McpStdioHandle, type StdioAuthConfig, type StdioMcpServerConfig, } from '../../tools/mcp/stdio.js';
 export { bindStdioProcessSignals, type StdioCloseTarget, type StdioProcessSignalsBinding, type StdioProcessSignalsErrorPhase, type StdioProcessSignalsOptions, } from '../../tools/mcp/stdio-signals.js';
-export type { RuntimeToolDefinitionWithoutOutput } from '../../tools/runtime-tool-execution.js';
-export type { RuntimeMcpPresentation, RuntimeMcpToolDefinition, RuntimeMcpToolDefinitionWithOutput, RuntimeMcpToolPresenters, } from '../../tools/runtime-tool-mcp.js';
+export type { RuntimeToolDefinition, RuntimeToolDefinitionWithOutput, RuntimeToolDefinitionWithoutOutput, } from '../../tools/runtime-tool-declaration.js';
+export type { RuntimeMcpPresentation, RuntimeMcpToolPresenters, } from '../../tools/runtime-tool-mcp.js';
 //# sourceMappingURL=mcp.d.ts.map

package/dist/entrypoints/tools/mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/tools/mcp.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAC9D,YAAY,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AACpF,OAAO,EACL,2BAA2B,EAC3B,kBAAkB,EAClB,KAAK,SAAS,EACd,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,kBAAkB,GACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,oBAAoB,EACpB,KAAK,eAAe,EACpB,cAAc,EACd,mBAAmB,GACpB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,KAAK,eAAe,GACrB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,cAAc,EACd,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,QAAQ,EACR,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,wBAAwB,EACxB,yBAAyB,EACzB,oBAAoB,EACpB,kBAAkB,EAClB,wBAAwB,GACzB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,oBAAoB,EACpB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,oBAAoB,GAC1B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,uBAAuB,EACvB,KAAK,gBAAgB,EACrB,KAAK,0BAA0B,EAC/B,KAAK,6BAA6B,EAClC,KAAK,0BAA0B,GAChC,MAAM,+BAA+B,CAAC;AACvC,YAAY,EAAE,kCAAkC,EAAE,MAAM,oCAAoC,CAAC;AAC7F,YAAY,EACV,sBAAsB,EACtB,wBAAwB,EACxB,kCAAkC,EAClC,wBAAwB,GACzB,MAAM,8BAA8B,CAAC"}
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/tools/mcp.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAC9D,YAAY,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AACpF,OAAO,EACL,2BAA2B,EAC3B,kBAAkB,EAClB,KAAK,SAAS,EACd,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,kBAAkB,GACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,oBAAoB,EACpB,KAAK,eAAe,EACpB,cAAc,EACd,mBAAmB,GACpB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,KAAK,eAAe,GACrB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,cAAc,EACd,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,QAAQ,EACR,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,wBAAwB,EACxB,yBAAyB,EACzB,oBAAoB,EACpB,kBAAkB,EAClB,wBAAwB,GACzB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,oBAAoB,EACpB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,oBAAoB,GAC1B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,uBAAuB,EACvB,KAAK,gBAAgB,EACrB,KAAK,0BAA0B,EAC/B,KAAK,6BAA6B,EAClC,KAAK,0BAA0B,GAChC,MAAM,+BAA+B,CAAC;AACvC,YAAY,EACV,qBAAqB,EACrB,+BAA+B,EAC/B,kCAAkC,GACnC,MAAM,sCAAsC,CAAC;AAC9C,YAAY,EACV,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,8BAA8B,CAAC"}

package/dist/entrypoints/tools/mcp.js

@@ -14,18 +14,19 @@ import {
   createMcpHttpRoute2,
   createStdioMcpServer2,
   bindStdioProcessSignals2
-} from "../../index-bhb950qs.js";
-import"../../index-x928baz2.js";
-import"../../index-kb8styz3.js";
+} from "../../index-916yh4e2.js";
+import"../../index-j9gxbztg.js";
+import"../../index-rpzewktb.js";
 import"../../index-yex7eg1v.js";
-import"../../index-9pw0a51a.js";
-import"../../index-77nxk6ay.js";
-import"../../index-2vnh05w4.js";
-import"../../index-2hyavjjj.js";
+import"../../index-6yxhe58g.js";
+import"../../index-r393tnfp.js";
+import"../../index-2k91mewf.js";
+import"../../index-556g5hsh.js";
+import"../../index-wbhdzxar.js";
 import"../../index-sznqf8fx.js";
 import"../../index-e6c2spsd.js";
-import"../../index-a0zzh8ak.js";
-import"../../index-cvda079a.js";
+import"../../index-pz3y6b6g.js";
+import"../../index-yvfk3y36.js";
 import"../../index-7n68nmc6.js";
 export {
   EXT_APPS_BUNDLE_PLACEHOLDER2 as EXT_APPS_BUNDLE_PLACEHOLDER,

package/dist/entrypoints/tools.d.ts

@@ -41,7 +41,6 @@ export { createRuntimeToolFactory, defineRuntimeTool, type RuntimeAgentModelOutp
 export { flattenToolJsonSchema, type ToolPresentationSchema, } from '../tools/schema/flatten.js';
 export { findNonPortableFormats, type NonPortableFormat, PORTABLE_JSON_SCHEMA_FORMATS, } from '../tools/schema/portable-formats.js';
 export { findUntypedProperties, type UntypedProperty, } from '../tools/schema/untyped-properties.js';
-export type { ToolSurfaceDefinition } from '../tools/surface.js';
 export { createToolLogger, type ToolCallRecord, type ToolLoggerConfig, } from '../tools/tool-logger.js';
 export { createToolkit, type Toolkit } from '../tools/toolkit.js';
 export { type DefineDownloadToolConfig, defineDownloadTool, } from '../tools/transfer/define-download-tool.js';