stitchkit 0.103.13 → 0.104.1

package/dist/entrypoints/tools/connections.js

@@ -2,14 +2,22 @@ import"../../index-ct75c3at.js";
 import {
   declaresDraft07,
   withDefsDialect
-} from "../../index-x87j7csh.js";
+} from "../../index-77nxk6ay.js";
 import {
   AppError2
-} from "../../index-n53mswt3.js";
-import"../../index-b2bz0kdm.js";
+} from "../../index-x928baz2.js";
+import"../../index-kb8styz3.js";
 import {
   defineRuntimeTool2
-} from "../../index-tgzhq07n.js";
+} from "../../index-cvda079a.js";
+import {
+  ConnectionAuthorizationRequiredError2,
+  ConnectionRequestError2,
+  ConnectionUrlError2,
+  ConnectionBudgetExceededError2,
+  ConnectionTimeoutError2,
+  ConnectionResponseTooLargeError2
+} from "../../index-1a6jtnd9.js";
 import {
   safeJsonParse
 } from "../../index-zsarb5xp.js";
@@ -17,72 +25,152 @@ import {
   isRecord
 } from "../../index-9jfdm5tg.js";
 
-// src/tools/connections/errors.ts
-class ConnectionAuthorizationRequiredError extends Error {
-  connectionName;
-  instanceId;
-  constructor(connectionName, instanceId) {
-    super(`Connection "${connectionName}" requires authorization`);
-    this.name = "ConnectionAuthorizationRequiredError";
-    this.connectionName = connectionName;
-    this.instanceId = instanceId;
+// 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;
+  if (!Number.isSafeInteger(value) || value <= 0 || value > MAX_TIMER_MS) {
+    throw new RangeError("Connection timeoutMs must be a positive integer within timer range");
   }
+  return value;
 }
-
-class ConnectionRequestError extends Error {
-  connectionName;
-  status;
-  body;
-  constructor(connectionName, status, body) {
-    super(`Connection "${connectionName}" request failed with status ${status}`);
-    this.name = "ConnectionRequestError";
-    this.connectionName = connectionName;
-    this.status = status;
-    this.body = body;
+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");
   }
+  return value;
 }
-
-class ConnectionUrlError extends Error {
-  url;
-  constructor(message, url) {
-    super(message);
-    this.name = "ConnectionUrlError";
-    this.url = url;
+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);
   }
 }
-
-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;
+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);
   }
 }
-
-class ConnectionTimeoutError extends Error {
-  connectionName;
-  timeoutMs;
-  constructor(connectionName, timeoutMs) {
-    super(`Connection "${connectionName}" timed out after ${timeoutMs} ms`);
-    this.name = "ConnectionTimeoutError";
-    this.connectionName = connectionName;
-    this.timeoutMs = timeoutMs;
+async function readBoundedText(response, maxBytes, connectionName, context) {
+  context?.signal?.throwIfAborted();
+  if (!response.body)
+    return "";
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  let total = 0;
+  let text = "";
+  const cancel = () => void reader.cancel(context?.signal?.reason).catch(() => {
+    return;
+  });
+  context?.signal?.addEventListener("abort", cancel, { once: true });
+  try {
+    for (;; ) {
+      const { done, value } = await awaitConnection(reader.read(), context?.signal);
+      if (done)
+        break;
+      total += value.byteLength;
+      if (context)
+        context.observedReadBytes += value.byteLength;
+      if (total > maxBytes) {
+        throw new ConnectionResponseTooLargeError2(connectionName, maxBytes, {
+          ...context,
+          observedReadBytes: total
+        });
+      }
+      text += decoder.decode(value, { stream: true });
+    }
+    text += decoder.decode();
+    return text;
+  } finally {
+    context?.signal?.removeEventListener("abort", cancel);
+    cancel();
+    reader.releaseLock();
+  }
+}
+async function readBoundedJson(response, maxBytes, connectionName, context) {
+  return JSON.parse(await readBoundedText(response, maxBytes, connectionName, context));
+}
+async function readConnectionErrorText(response, connectionName, context) {
+  try {
+    return (await readBoundedText(response, context.maxResponseBytes, connectionName, context)).slice(0, 512);
+  } catch (error) {
+    context.signal?.throwIfAborted();
+    if (error instanceof ConnectionResponseTooLargeError2 || error instanceof ConnectionTimeoutError2) {
+      throw error;
+    }
+    return "";
   }
 }
 
-class ConnectionResponseTooLargeError extends Error {
-  connectionName;
-  maxBytes;
-  constructor(connectionName, maxBytes) {
-    super(`Connection "${connectionName}" response exceeded the ${maxBytes} byte limit`);
-    this.name = "ConnectionResponseTooLargeError";
-    this.connectionName = connectionName;
-    this.maxBytes = maxBytes;
+// src/tools/connections/operation-limits.ts
+function resolveMcpLimits(config) {
+  const shared = {
+    timeoutMs: connectionTimeoutMs(config.timeoutMs),
+    maxResponseBytes: connectionMaxResponseBytes(config.maxResponseBytes)
+  };
+  const resolve = (phase) => {
+    const override = config.limits?.[phase];
+    return {
+      timeoutMs: connectionTimeoutMs(override?.timeoutMs === undefined ? shared.timeoutMs : override.timeoutMs),
+      maxResponseBytes: connectionMaxResponseBytes(override?.maxResponseBytes === undefined ? shared.maxResponseBytes : override.maxResponseBytes)
+    };
+  };
+  return { discovery: resolve("discovery"), call: resolve("call") };
+}
+function mcpOperation(method) {
+  switch (method) {
+    case "initialize":
+    case "notifications/initialized":
+    case "tools/list":
+    case "tools/call":
+      return method;
+    default:
+      return "request";
   }
 }
+function connectionReadContext(operation, limits) {
+  const phase = operation === "initialize" || operation === "notifications/initialized" || operation === "tools/list" || operation === "endpoint" || operation === "openapi/spec" ? "discovery" : "call";
+  return { ...limits[phase], phase, operation, observedReadBytes: 0 };
+}
 
 // src/tools/connections/ssrf.ts
 function assertConnectionUrl(rawUrl, connectionName) {
@@ -90,10 +178,10 @@ function assertConnectionUrl(rawUrl, connectionName) {
   try {
     url = new URL(rawUrl);
   } catch {
-    throw new ConnectionUrlError(`Connection "${connectionName}" has an unparseable URL: ${rawUrl}`, rawUrl);
+    throw new ConnectionUrlError2(`Connection "${connectionName}" has an unparseable URL: ${rawUrl}`, rawUrl);
   }
   if (url.protocol !== "http:" && url.protocol !== "https:") {
-    throw new ConnectionUrlError(`Connection "${connectionName}" must use http(s), got "${url.protocol}"`, rawUrl);
+    throw new ConnectionUrlError2(`Connection "${connectionName}" must use http(s), got "${url.protocol}"`, rawUrl);
   }
   return url;
 }
@@ -105,7 +193,7 @@ function connectionAllowedHosts(connectionUrl, extra) {
 }
 function assertAllowedHost(url, allowedHosts, connectionName) {
   if (!allowedHosts.has(url.host.toLowerCase())) {
-    throw new ConnectionUrlError(`Connection "${connectionName}" refused request to host "${url.host}": not the connection host or an allowed host`, url.toString());
+    throw new ConnectionUrlError2(`Connection "${connectionName}" refused request to host "${url.host}": not the connection host or an allowed host`, url.toString());
   }
 }
 
@@ -114,6 +202,7 @@ function defineMcpClientConnection(config) {
   if (!config.name.trim())
     throw new Error("MCP connection requires a name");
   assertConnectionUrl(config.transport.url, config.name);
+  resolveMcpLimits(config);
   return { ...config, kind: "mcp" };
 }
 function defineOpenApiConnection(config) {
@@ -121,6 +210,8 @@ function defineOpenApiConnection(config) {
     throw new Error("OpenAPI connection requires a name");
   if (config.baseUrl)
     assertConnectionUrl(config.baseUrl, config.name);
+  connectionTimeoutMs(config.timeoutMs);
+  connectionMaxResponseBytes(config.maxResponseBytes);
   return { ...config, kind: "openapi" };
 }
 // src/tools/connections/instance.ts
@@ -132,65 +223,6 @@ function connectionInstanceId(name, url, instanceKey) {
 // src/tools/connections/mcp.ts
 import { z as z2 } from "zod";
 
-// src/tools/connections/limits.ts
-var DEFAULT_CONNECTION_TIMEOUT_MS = 30000;
-var DEFAULT_MAX_RESPONSE_BYTES = 1024 * 1024;
-function connectionTimeoutMs(value) {
-  return value !== undefined && value > 0 ? value : DEFAULT_CONNECTION_TIMEOUT_MS;
-}
-function connectionMaxResponseBytes(value) {
-  return value !== undefined && value > 0 ? value : DEFAULT_MAX_RESPONSE_BYTES;
-}
-async function withConnectionDeadline(connectionName, timeoutMs, callerSignal, body) {
-  const controller = new AbortController;
-  const timer = setTimeout(() => controller.abort(new ConnectionTimeoutError(connectionName, timeoutMs)), timeoutMs);
-  const onAbort = () => controller.abort(callerSignal?.reason);
-  if (callerSignal) {
-    if (callerSignal.aborted)
-      controller.abort(callerSignal.reason);
-    else
-      callerSignal.addEventListener("abort", onAbort, { once: true });
-  }
-  try {
-    return await body(controller.signal);
-  } finally {
-    clearTimeout(timer);
-    callerSignal?.removeEventListener("abort", onAbort);
-  }
-}
-async function readBoundedText(response, maxBytes, connectionName) {
-  const stream = response.body;
-  if (!stream)
-    return "";
-  const reader = stream.getReader();
-  const decoder = new TextDecoder;
-  let total = 0;
-  let text = "";
-  try {
-    for (;; ) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      total += value.byteLength;
-      if (total > maxBytes) {
-        await reader.cancel().catch(() => {
-          return;
-        });
-        throw new ConnectionResponseTooLargeError(connectionName, maxBytes);
-      }
-      text += decoder.decode(value, { stream: true });
-    }
-    text += decoder.decode();
-    return text;
-  } finally {
-    reader.releaseLock();
-  }
-}
-async function readBoundedJson(response, maxBytes, connectionName) {
-  const text = await readBoundedText(response, maxBytes, connectionName);
-  return JSON.parse(text);
-}
-
 // src/tools/connections/http.ts
 async function fetchConnection(target, init, allowedHosts, connectionName) {
   const url = assertConnectionUrl(target.toString(), connectionName);
@@ -198,7 +230,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 ConnectionUrlError(`Connection "${connectionName}" refused a redirect`, url.toString());
+    throw new ConnectionUrlError2(`Connection "${connectionName}" refused a redirect`, url.toString());
   }
   return response;
 }
@@ -213,54 +245,85 @@ function unwrap(payload, id, connectionName) {
 }
 
 // src/tools/connections/sse-frames.ts
-async function* readSseFrames(response, maxBytes, connectionName, totalLimit = false) {
+async function* readSseFrames(response, maxBytes, connectionName, options = {}) {
   if (!response.body)
     throw new Error("MCP stream ended with no body");
   const reader = response.body.getReader();
   const decoder = new TextDecoder;
-  let buffer = "";
+  const signal = options.signal ?? options.context?.signal;
+  const cancel = () => void reader.cancel(signal?.reason).catch(() => {
+    return;
+  });
+  signal?.addEventListener("abort", cancel, { once: true });
+  let pieces = [];
+  let frameBytes = 0;
+  let tail = 0;
   let bytes = 0;
+  const context = () => options.currentContext?.() ?? options.context;
+  const tooLarge = (observedReadBytes) => {
+    const current = context();
+    return new ConnectionResponseTooLargeError2(connectionName, current?.maxResponseBytes ?? maxBytes, { ...current, observedReadBytes });
+  };
   try {
     for (;; ) {
-      const { done, value } = await reader.read();
+      const { done, value } = await awaitConnection(reader.read(), signal);
       if (done)
         break;
-      if (totalLimit) {
-        bytes += value.byteLength;
-        if (bytes > maxBytes)
-          throw new ConnectionResponseTooLargeError(connectionName, maxBytes);
+      bytes += value.byteLength;
+      if (options.onChunk)
+        options.onChunk(value.byteLength);
+      else if (options.context)
+        options.context.observedReadBytes += value.byteLength;
+      if (options.totalLimit && bytes > (context()?.maxResponseBytes ?? maxBytes)) {
+        throw tooLarge(bytes);
       }
-      for (let offset = 0;offset < value.byteLength; offset += 1024) {
-        buffer += decoder.decode(value.subarray(offset, offset + 1024), { stream: true });
-        let match = /\r?\n\r?\n/.exec(buffer);
-        while (match) {
-          const frame = buffer.slice(0, match.index);
-          if (new TextEncoder().encode(frame).byteLength > maxBytes)
-            throw new ConnectionResponseTooLargeError(connectionName, maxBytes);
-          buffer = buffer.slice(match.index + match[0].length);
-          let event = "message";
-          const data = [];
-          for (const line of frame.split(/\r?\n/)) {
-            if (line.startsWith("event:"))
-              event = line.slice(6).trim();
-            if (line.startsWith("data:"))
-              data.push(line.slice(5).replace(/^ /, ""));
-          }
-          yield { event, data: data.join(`
-`) };
-          match = /\r?\n\r?\n/.exec(buffer);
-        }
-        if (new TextEncoder().encode(buffer).byteLength > maxBytes)
-          throw new ConnectionResponseTooLargeError(connectionName, maxBytes);
+      let start = 0;
+      let ceiling = context()?.maxResponseBytes ?? maxBytes;
+      for (let offset = 0;offset < value.byteLength; offset++) {
+        const byte = value[offset];
+        if (byte === undefined)
+          continue;
+        frameBytes++;
+        if (frameBytes > ceiling)
+          throw tooLarge(frameBytes);
+        tail = (tail << 8 | byte) >>> 0;
+        if ((tail & 65535) !== 2570 && (tail & 16777215) !== 658698)
+          continue;
+        pieces.push(value.subarray(start, offset + 1));
+        let text = "";
+        for (const piece of pieces)
+          text += decoder.decode(piece, { stream: true });
+        text += decoder.decode();
+        pieces = [];
+        frameBytes = 0;
+        tail = 0;
+        start = offset + 1;
+        yield parseSseFrame(text);
+        ceiling = context()?.maxResponseBytes ?? maxBytes;
+        signal?.throwIfAborted();
+      }
+      if (start < value.byteLength) {
+        pieces.push(value.subarray(start));
       }
     }
   } finally {
-    await reader.cancel().catch(() => {
-      return;
-    });
+    signal?.removeEventListener("abort", cancel);
+    cancel();
     reader.releaseLock();
   }
 }
+function parseSseFrame(text) {
+  let event = "message";
+  const data = [];
+  for (const line of text.split(/\r?\n/)) {
+    if (line.startsWith("event:"))
+      event = line.slice(6).trim();
+    if (line.startsWith("data:"))
+      data.push(line.slice(5).replace(/^ /, ""));
+  }
+  return { event, data: data.join(`
+`) };
+}
 
 // src/tools/connections/sse-session.ts
 class SseSession {
@@ -269,77 +332,125 @@ class SseSession {
   options;
   controller = new AbortController;
   pending = new Map;
+  active = new Set;
+  streamBytes = new WeakMap;
   endpoint = Promise.withResolvers();
+  limits;
+  endpointContext;
+  endpointReady = false;
   failure;
   constructor(connectionName, instanceId, options) {
     this.connectionName = connectionName;
     this.instanceId = instanceId;
     this.options = options;
+    this.limits = options.phaseLimits ?? resolveMcpLimits(options);
+    this.endpointContext = options.initialContext ?? connectionReadContext("endpoint", this.limits);
     this.endpoint.promise.catch(() => {
       return;
     });
     this.open();
   }
-  async ready(signal) {
-    return withConnectionDeadline(this.connectionName, this.options.timeoutMs, signal, async (deadline) => {
-      const onAbort = () => this.close(deadline.reason);
-      deadline.addEventListener("abort", onAbort, { once: true });
-      try {
-        deadline.throwIfAborted();
-        return await this.endpoint.promise;
-      } finally {
-        deadline.removeEventListener("abort", onAbort);
-      }
-    });
+  async ready(signal, context) {
+    if (context) {
+      this.endpointContext = context;
+      return this.waitForEndpoint(signal);
+    }
+    const readiness = this.endpointContext;
+    return withConnectionDeadline(this.connectionName, readiness.timeoutMs, signal, (deadline) => this.waitForEndpoint(deadline), readiness);
   }
   close(reason = new Error("MCP SSE session closed")) {
+    if (this.controller.signal.aborted)
+      return;
     this.failure = reason;
     this.controller.abort(reason);
     this.endpoint.reject(reason);
     for (const pending of this.pending.values())
       pending.reject(reason);
     this.pending.clear();
+    this.active.clear();
   }
-  async request(message, token, signal) {
-    return withConnectionDeadline(this.connectionName, this.options.timeoutMs, signal, async (deadline) => {
-      const abort = () => this.close(deadline.reason);
-      deadline.addEventListener("abort", abort, { once: true });
-      try {
-        deadline.throwIfAborted();
-        if (this.controller.signal.aborted)
-          throw this.failure;
-        const endpoint = await this.endpoint.promise;
-        const response = Promise.withResolvers();
-        response.promise.catch(() => {
-          return;
-        });
-        if (message.id !== undefined)
-          this.pending.set(message.id, response);
-        const post = await fetchConnection(endpoint, {
-          method: "POST",
-          headers: {
-            ...this.options.headers,
-            "content-type": "application/json",
-            ...token ? { authorization: `Bearer ${token}` } : {}
-          },
-          body: JSON.stringify(message),
-          signal: deadline
-        }, this.options.allowedHosts, this.connectionName);
-        this.assertStatus(post);
-        await post.body?.cancel();
-        return message.id === undefined ? undefined : await response.promise;
-      } finally {
-        if (message.id !== undefined)
-          this.pending.delete(message.id);
-        deadline.removeEventListener("abort", abort);
-      }
-    });
+  async waitForEndpoint(signal) {
+    const onAbort = () => this.close(signal?.reason);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+      signal?.throwIfAborted();
+      return await awaitConnection(this.endpoint.promise, signal);
+    } finally {
+      signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  async request(message, token, signal, context) {
+    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);
   }
-  assertStatus(response) {
-    if (response.status === 401)
-      throw new ConnectionAuthorizationRequiredError(this.connectionName, this.instanceId);
-    if (!response.ok)
-      throw new ConnectionRequestError(this.connectionName, response.status, "");
+  async requestWithin(message, token, context, signal) {
+    const abort = () => this.close(signal?.reason);
+    signal?.addEventListener("abort", abort, { once: true });
+    try {
+      signal?.throwIfAborted();
+      if (this.controller.signal.aborted)
+        throw this.failure;
+      const endpoint = await awaitConnection(this.endpoint.promise, signal);
+      const response = Promise.withResolvers();
+      response.promise.catch(() => {
+        return;
+      });
+      this.active.add(context);
+      if (message.id !== undefined)
+        this.pending.set(message.id, { ...response, context });
+      const post = await fetchConnection(endpoint, {
+        method: "POST",
+        headers: {
+          ...this.options.headers,
+          "content-type": "application/json",
+          ...token ? { authorization: `Bearer ${token}` } : {}
+        },
+        body: JSON.stringify(message),
+        signal
+      }, this.options.allowedHosts, this.connectionName);
+      await this.assertStatus(post, context);
+      await readBoundedText(post, context.maxResponseBytes, this.connectionName, context);
+      return message.id === undefined ? undefined : await awaitConnection(response.promise, signal);
+    } finally {
+      if (message.id !== undefined)
+        this.pending.delete(message.id);
+      this.active.delete(context);
+      signal?.removeEventListener("abort", abort);
+    }
+  }
+  async assertStatus(response, context) {
+    if (response.status === 401) {
+      response.body?.cancel().catch(() => {
+        return;
+      });
+      throw new ConnectionAuthorizationRequiredError2(this.connectionName, this.instanceId, context);
+    }
+    if (!response.ok) {
+      throw new ConnectionRequestError2(this.connectionName, response.status, await readConnectionErrorText(response, this.connectionName, context), context);
+    }
+  }
+  currentContext() {
+    if (!this.endpointReady)
+      return this.endpointContext;
+    let selected;
+    for (const context of this.active) {
+      if (!selected || context.maxResponseBytes < selected.maxResponseBytes)
+        selected = context;
+    }
+    return selected ?? connectionReadContext("endpoint", this.limits);
+  }
+  observeChunk(bytes) {
+    const active = this.endpointReady ? this.active : new Set([this.endpointContext]);
+    for (const context of active) {
+      context.observedReadBytes += bytes;
+      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 });
+      }
+    }
   }
   async open() {
     try {
@@ -348,11 +459,16 @@ class SseSession {
         headers: { ...this.options.headers, accept: "text/event-stream" },
         signal: this.controller.signal
       }, this.options.allowedHosts, this.connectionName);
-      this.assertStatus(response);
-      for await (const frame of readSseFrames(response, this.options.maxResponseBytes, this.connectionName)) {
+      await this.assertStatus(response, this.endpointContext);
+      for await (const frame of readSseFrames(response, this.options.maxResponseBytes, this.connectionName, {
+        signal: this.controller.signal,
+        currentContext: () => this.currentContext(),
+        onChunk: (bytes) => this.observeChunk(bytes)
+      })) {
         if (frame.event === "endpoint") {
           const url = assertConnectionUrl(new URL(frame.data, this.options.baseUrl).toString(), this.connectionName);
           assertAllowedHost(url, this.options.allowedHosts, this.connectionName);
+          this.endpointReady = true;
           this.endpoint.resolve(url.toString());
         } else if (frame.event === "message" && frame.data) {
           const message = JSON.parse(frame.data);
@@ -389,14 +505,18 @@ class McpHttpClient {
   protocolVersion;
   nextId = 1;
   initialized = false;
+  initialInitializePending = true;
   sse;
+  limits;
   constructor(connectionName, instanceId, options) {
     this.connectionName = connectionName;
     this.instanceId = instanceId;
     this.options = options;
+    this.limits = resolveMcpLimits(options);
   }
   teardown() {
     this.initialized = false;
+    this.initialInitializePending = true;
     this.sessionId = undefined;
     this.sse?.close();
     this.sse = undefined;
@@ -413,71 +533,85 @@ class McpHttpClient {
     if (isRecord(result) && typeof result.protocolVersion === "string") {
       this.protocolVersion = result.protocolVersion;
     }
-    this.initialized = true;
     try {
       await this.dispatch({ jsonrpc: "2.0", method: "notifications/initialized" }, token, signal);
-    } catch {}
+    } catch (error) {
+      signal?.throwIfAborted();
+      if (error instanceof ConnectionTimeoutError2 || error instanceof ConnectionResponseTooLargeError2) {
+        throw error;
+      }
+    }
+    this.initialized = true;
   }
   request(method, params, token, signal) {
     return this.dispatch({ jsonrpc: "2.0", id: this.nextId++, method, params }, token, signal);
   }
   async dispatch(message, token, signal) {
-    if (this.mode === "sse")
-      return this.sseRequest(message, token, signal);
-    try {
-      return await this.streamableRequest(message, token, signal);
-    } catch (error) {
-      if (error instanceof ConnectionRequestError && FALLBACK_STATUSES.has(error.status)) {
-        await this.openSse(token, signal);
-        this.mode = "sse";
-        return this.sseRequest(message, token, signal);
+    const context = connectionReadContext(mcpOperation(message.method), this.limits);
+    const negotiate = message.method === "initialize" && this.initialInitializePending;
+    if (message.method === "initialize")
+      this.initialInitializePending = false;
+    return withConnectionDeadline(this.connectionName, context.timeoutMs, signal, async () => {
+      if (this.mode === "sse")
+        return this.sseRequest(message, token, context);
+      try {
+        return await this.streamableRequest(message, token, context);
+      } catch (error) {
+        context.signal?.throwIfAborted();
+        if (negotiate && error instanceof ConnectionRequestError2 && FALLBACK_STATUSES.has(error.status)) {
+          await this.openSse(token, context);
+          this.mode = "sse";
+          return this.sseRequest(message, token, context);
+        }
+        throw error;
       }
-      throw error;
-    }
+    }, context);
   }
-  streamableRequest(message, token, signal) {
+  async streamableRequest(message, token, context) {
     const target = new URL(this.options.transport.url);
     assertAllowedHost(target, this.options.allowedHosts, this.connectionName);
-    return withConnectionDeadline(this.connectionName, this.options.timeoutMs, signal, async (deadline) => {
-      const response = await fetchConnection(target, {
-        method: "POST",
-        headers: this.headers(token),
-        body: JSON.stringify(message),
-        signal: deadline
-      }, this.options.allowedHosts, this.connectionName);
-      if (response.status === 401) {
-        throw new ConnectionAuthorizationRequiredError(this.connectionName, this.instanceId);
-      }
-      if (!response.ok) {
-        throw new ConnectionRequestError(this.connectionName, response.status, await this.safeText(response));
-      }
-      const session = response.headers.get("mcp-session-id");
-      if (session)
-        this.sessionId = session;
-      if (message.id === undefined) {
-        await response.body?.cancel();
+    context.signal?.throwIfAborted();
+    const response = await fetchConnection(target, {
+      method: "POST",
+      headers: this.headers(token),
+      body: JSON.stringify(message),
+      signal: context.signal
+    }, this.options.allowedHosts, this.connectionName);
+    if (response.status === 401) {
+      response.body?.cancel().catch(() => {
         return;
+      });
+      throw new ConnectionAuthorizationRequiredError2(this.connectionName, this.instanceId, context);
+    }
+    if (!response.ok) {
+      throw new ConnectionRequestError2(this.connectionName, response.status, await readConnectionErrorText(response, this.connectionName, context), context);
+    }
+    const session = response.headers.get("mcp-session-id");
+    if (session)
+      this.sessionId = session;
+    if (message.id === undefined) {
+      await readBoundedText(response, context.maxResponseBytes, this.connectionName, context);
+      return;
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("text/event-stream")) {
+      for await (const frame of readSseFrames(response, context.maxResponseBytes, this.connectionName, { totalLimit: true, context })) {
+        if (!frame.data)
+          continue;
+        const payload = JSON.parse(frame.data);
+        if (isRecord(payload) && payload.id === message.id)
+          return unwrap(payload, message.id, this.connectionName);
       }
-      const contentType = response.headers.get("content-type") ?? "";
-      if (contentType.includes("text/event-stream")) {
-        for await (const frame of readSseFrames(response, this.options.maxResponseBytes, this.connectionName, true)) {
-          if (!frame.data)
-            continue;
-          const payload = JSON.parse(frame.data);
-          if (isRecord(payload) && payload.id === message.id)
-            return unwrap(payload, message.id, this.connectionName);
-        }
-        throw new Error("MCP stream ended without a response");
-      }
-      const text = await readBoundedText(response, this.options.maxResponseBytes, this.connectionName);
-      let payload;
-      try {
-        payload = JSON.parse(text);
-      } catch {
-        throw new Error(`MCP response from "${this.connectionName}" was not JSON`);
-      }
-      return unwrap(payload, message.id, this.connectionName);
-    });
+      throw new Error("MCP stream ended without a response");
+    }
+    const text = await readBoundedText(response, context.maxResponseBytes, this.connectionName, context);
+    let payload;
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      throw new Error(`MCP response from "${this.connectionName}" was not JSON`);
+    }
+    return unwrap(payload, message.id, this.connectionName);
   }
   headers(token) {
     const headers = {
@@ -493,31 +627,26 @@ class McpHttpClient {
       headers["mcp-protocol-version"] = this.protocolVersion;
     return headers;
   }
-  async openSse(token, signal) {
+  async openSse(token, context) {
     this.sse?.close();
     this.sse = new SseSession(this.connectionName, this.instanceId, {
       baseUrl: this.options.transport.url,
       allowedHosts: this.options.allowedHosts,
       headers: this.headers(token),
       timeoutMs: this.options.timeoutMs,
-      maxResponseBytes: this.options.maxResponseBytes
+      maxResponseBytes: this.options.maxResponseBytes,
+      phaseLimits: this.limits,
+      initialContext: context
     });
-    await this.sse.ready(signal);
+    await this.sse.ready(context.signal, context);
   }
-  async sseRequest(message, token, signal) {
+  async sseRequest(message, token, context) {
     if (!this.sse)
-      await this.openSse(token, signal);
+      await this.openSse(token, context);
     const session = this.sse;
     if (!session)
       throw new Error("MCP SSE session failed to open");
-    return session.request(message, token, signal);
-  }
-  async safeText(response) {
-    try {
-      return (await readBoundedText(response, this.options.maxResponseBytes, this.connectionName)).slice(0, 512);
-    } catch {
-      return "";
-    }
+    return session.request(message, token, context.signal, context);
   }
 }
 
@@ -558,7 +687,7 @@ async function withConnectionToken(params, body) {
   try {
     return await body(token);
   } catch (error) {
-    if (error instanceof ConnectionAuthorizationRequiredError) {
+    if (error instanceof ConnectionAuthorizationRequiredError2) {
       params.client?.teardown();
     }
     throw error;
@@ -620,7 +749,8 @@ async function mountMcpConnection(connection, instanceId, onSkipped) {
     transport: connection.transport,
     allowedHosts,
     timeoutMs: connectionTimeoutMs(connection.timeoutMs),
-    maxResponseBytes: connectionMaxResponseBytes(connection.maxResponseBytes)
+    maxResponseBytes: connectionMaxResponseBytes(connection.maxResponseBytes),
+    ...connection.limits && { limits: connection.limits }
   });
   const discovery = createClient();
   const listed = await withConnectionToken({ instanceId, provider: connection.token, client: discovery }, async (token) => {
@@ -795,6 +925,10 @@ async function mountOpenApiConnection(connection, instanceId, onSkipped) {
         }
         const body = requestBody(entry.operation);
         applyAuth(auth, token, url, headers);
+        const readContext = connectionReadContext("openapi/call", {
+          discovery: { timeoutMs, maxResponseBytes },
+          call: { timeoutMs, maxResponseBytes }
+        });
         return withConnectionDeadline(connection.name, timeoutMs, context.signal, async (signal) => {
           const requestInit = { method: entry.method, headers, signal };
           if (body && args.body !== undefined) {
@@ -804,13 +938,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 ConnectionAuthorizationRequiredError(connection.name, instanceId);
+            throw new ConnectionAuthorizationRequiredError2(connection.name, instanceId, readContext);
           }
           if (!response.ok) {
-            throw new ConnectionRequestError(connection.name, response.status, (await safeText(response, maxResponseBytes)).slice(0, 512));
+            throw new ConnectionRequestError2(connection.name, response.status, await readConnectionErrorText(response, connection.name, readContext), readContext);
           }
-          return readResponse(response, maxResponseBytes, connection.name);
-        });
+          return readResponse(response, maxResponseBytes, connection.name, readContext);
+        }, readContext);
       })
     });
     recordForeignSchemaBytes(definition, jsonSchemaBytes(schema));
@@ -832,13 +966,17 @@ async function loadOpenApiDocument(connection, timeoutMs, maxResponseBytes) {
     return { document: parsed };
   }
   const url = assertConnectionUrl(text, connection.name);
+  const readContext = connectionReadContext("openapi/spec", {
+    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);
     if (!response.ok) {
-      throw new ConnectionRequestError(connection.name, response.status, "");
+      throw new ConnectionRequestError2(connection.name, response.status, await readConnectionErrorText(response, connection.name, readContext), readContext);
     }
-    return readBoundedJson(response, maxResponseBytes, connection.name);
-  });
+    return readBoundedJson(response, maxResponseBytes, connection.name, readContext);
+  }, readContext);
   if (!isRecord(parsed))
     throw new Error(`OpenAPI spec at ${url} is not an object`);
   return { document: parsed, url: url.toString() };
@@ -1045,20 +1183,13 @@ function buildOperationUrl(baseUrl, entry, args) {
   const resolved = `${origin.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
   return new URL(resolved);
 }
-async function readResponse(response, maxBytes, connectionName) {
+async function readResponse(response, maxBytes, connectionName, context) {
   if (response.status === 204)
     return null;
   const contentType = response.headers.get("content-type") ?? "";
   if (contentType.includes("json"))
-    return readBoundedJson(response, maxBytes, connectionName);
-  return readBoundedText(response, maxBytes, connectionName);
-}
-async function safeText(response, maxBytes) {
-  try {
-    return await readBoundedText(response, maxBytes, "response");
-  } catch {
-    return "";
-  }
+    return readBoundedJson(response, maxBytes, connectionName, context);
+  return readBoundedText(response, maxBytes, connectionName, context);
 }
 function asRecord(value) {
   return isRecord(value) ? value : undefined;
@@ -1075,13 +1206,13 @@ async function mountConnections(connections, options = {}) {
   }
   const limit = options.budget?.maxTools;
   if (limit !== undefined && tools.length > limit) {
-    throw new ConnectionBudgetExceededError(limit, tools.length);
+    throw new ConnectionBudgetExceededError2(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 ConnectionBudgetExceededError(schemaLimit, schemaBytes, "schema bytes");
+      throw new ConnectionBudgetExceededError2(schemaLimit, schemaBytes, "schema bytes");
     }
   }
   return tools;
@@ -1100,10 +1231,12 @@ function instanceIdOf(connection) {
   return connectionInstanceId(connection.name, url, connection.instanceKey);
 }
 export {
-  ConnectionAuthorizationRequiredError,
-  ConnectionBudgetExceededError,
-  ConnectionRequestError,
-  ConnectionUrlError,
+  ConnectionAuthorizationRequiredError2 as ConnectionAuthorizationRequiredError,
+  ConnectionBudgetExceededError2 as ConnectionBudgetExceededError,
+  ConnectionRequestError2 as ConnectionRequestError,
+  ConnectionResponseTooLargeError2 as ConnectionResponseTooLargeError,
+  ConnectionTimeoutError2 as ConnectionTimeoutError,
+  ConnectionUrlError2 as ConnectionUrlError,
   defineMcpClientConnection,
   defineOpenApiConnection,
   mountConnections