@zackbart/connecta 0.37.0 → 0.38.0

package/dist/auth/vercel-agent.js

@@ -1,3 +1,4 @@
+import { decodeBase64url } from "../bytes.js";
 import { runEdge } from "../runtime/run.js";
 import { authCall, authCatch, authFetch, authFlow, authInvoke, authMethod, authProgram, registerAuth, } from "./native.js";
 import { AGENT_NAMESPACE, agentSubjectId, trustAgentProvider } from "../agent-identity.js";
@@ -14,7 +15,7 @@ const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false });
 function bytes(value) {
     if (!/^[A-Za-z0-9_-]+(?![\s\S])/.test(value))
         throw new Error("Invalid JWT encoding");
-    return Uint8Array.from(atob(value.replace(/-/g, "+").replace(/_/g, "/")), (char) => char.charCodeAt(0));
+    return decodeBase64url(value);
 }
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);

package/dist/auth-elicitation.js

@@ -1,3 +1,4 @@
+import { toolError } from "./tool-error.js";
 import { RequestScope, requestOwner } from "./runtime/request-scope.js";
 import { upwardStep } from "./upward.js";
 import { authAwait, authCall, authInvoke, authFlow, authMethod, registerAuthMethod, authOwnMethod, } from "./auth/native.js";
@@ -17,8 +18,7 @@ import { canonicalState as canonical, requestDigest as digest, stateObject as ob
 const INPUT_KEY = "connecta_auth";
 const MESSAGE = "Connect this service in your browser, then retry the request.";
 function failure(code, message) {
-    const structuredContent = { ok: false, error: { code, message, retryable: false } };
-    return { content: [{ type: "text", text: JSON.stringify(structuredContent) }], structuredContent, isError: true };
+    return toolError({ code, message, retryable: false }, { ok: false });
 }
 /** Request-local auth recovery at the MCP boundary, never inside a guest provider. */
 export class AuthElicitation {

package/dist/branding.d.ts

@@ -1,7 +1,7 @@
 import type { ConnectaBranding, ConnectaTheme, UiAuthConfig } from "./types.js";
 /** Connecta's default monochrome "C" mark. */
 export declare const CONNECTA_FAVICON_SVG = "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 32 32\">\n  <style>\n    .fg { fill: #000 }\n    @media (prefers-color-scheme: dark) { .fg { fill: #fff } }\n  </style>\n  <path class=\"fg\" d=\"M27 9.4A13 13 0 1 0 27 22.6l-4.4-2.5a8 8 0 1 1 0-8.2z\"/>\n</svg>";
-export interface ResolvedTheme {
+interface ResolvedTheme {
     accent?: string;
     radius?: string;
     fontFamily?: string;
@@ -28,26 +28,12 @@ interface ResolvedBranding {
     theme: ResolvedTheme;
 }
 export declare function resolveBranding(branding?: ConnectaBranding): ResolvedBranding;
-/**
- * Read a theme the way branding URLs are read: gate every field, drop what
- * fails, never throw. This runs during `createConnecta`, so a malformed value
- * has to fall back to the stylesheet default instead of refusing to serve the
- * page. `droppedThemeTokens` names the drops for the startup warning.
- */
-export declare function resolveTheme(theme?: ConnectaTheme): ResolvedTheme;
 /**
  * Names of the theme tokens the operator set that failed their gate. Same
  * contract as `droppedBrandingUrls`: rendering falls back silently, so this is
  * the only place an operator learns their value never reached the page.
  */
 export declare function droppedThemeTokens(theme?: ConnectaTheme): string[];
-/**
- * The resolved theme as a `:root` block, or "" when a deployment configured
- * nothing. It is emitted after the stylesheet so it overrides the defaults.
- * There is no escaping here: every value has already passed a gate above, and
- * anything that would need escaping is dropped rather than rewritten.
- */
-export declare function themeCss(theme: ResolvedTheme): string;
 /** Text or attribute value, escaped for any position in an HTML document. */
 export declare function escapeHtml(value: string): string;
 export interface PageLayout {

package/dist/branding.js

@@ -71,7 +71,7 @@ const COLOR_SCHEMES = ["system", "light", "dark"];
  * has to fall back to the stylesheet default instead of refusing to serve the
  * page. `droppedThemeTokens` names the drops for the startup warning.
  */
-export function resolveTheme(theme) {
+function resolveTheme(theme) {
     const accent = trimmedString(theme?.accent);
     const fontFamily = trimmedString(theme?.fontFamily);
     const monoFamily = trimmedString(theme?.monoFamily);
@@ -175,7 +175,7 @@ function accentTokens(accent) {
  * There is no escaping here: every value has already passed a gate above, and
  * anything that would need escaping is dropped rather than rewritten.
  */
-export function themeCss(theme) {
+function themeCss(theme) {
     const derived = theme.accent ? accentTokens(theme.accent) : undefined;
     const declarations = [
         theme.accent ? `--accent:${theme.accent}` : "",

package/dist/bytes.js

@@ -0,0 +1,42 @@
+/** Lowercase hexadecimal, preserving each byte's leading zero. */
+export function bytesToHex(bytes) {
+    return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+export async function sha256Hex(value) {
+    return bytesToHex(new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value))));
+}
+/** UTF-8 byte count without allocating encoded bytes; stops once the limit is exceeded. */
+export function utf8Length(value, limit = Infinity) {
+    let bytes = 0;
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code < 0x80)
+            bytes++;
+        else if (code < 0x800)
+            bytes += 2;
+        else if (code >= 0xd800 &&
+            code <= 0xdbff &&
+            value.charCodeAt(i + 1) >= 0xdc00 &&
+            value.charCodeAt(i + 1) <= 0xdfff) {
+            bytes += 4;
+            i++;
+        }
+        else
+            bytes += 3;
+        if (bytes > limit)
+            return bytes;
+    }
+    return bytes;
+}
+export function decodeBase64(value) {
+    const binary = atob(value);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1)
+        bytes[index] = binary.charCodeAt(index);
+    return bytes;
+}
+/** Optional padding preserves callers that pad before handing input to atob. */
+export function decodeBase64url(value, pad = false) {
+    const base64 = value.replace(/-/g, "+").replace(/_/g, "/");
+    return decodeBase64(pad ? base64 + "=".repeat((4 - (base64.length % 4)) % 4) : base64);
+}

package/dist/call-admission-context.js

@@ -1,8 +1,5 @@
-import { Budget, callScopeKnown, chargeView, recordedService, setViewService } from "./runtime/call.js";
-import { chargeCallBudget } from "./runtime/call-admission.js";
-export function attachCallAdmission(ctx, permit) {
-    setViewService(ctx, Budget, { charge: chargeCallBudget(permit, ctx.signal) });
-}
+// The Promise view of the call's admission service; authority stays internal.
+import { Budget, callScopeKnown, chargeView, recordedService } from "./runtime/call.js";
 export function chargeConnectorCall(ctx) {
     return recordedService(ctx, Budget) || callScopeKnown(ctx) ? chargeView(ctx) : Promise.resolve();
 }

package/dist/call-admission.js

@@ -195,6 +195,11 @@ export class ConnectorCallAdmissionController {
             // The waiter's own clock: the fiber's Clock for an Effect caller, the
             // live `Date.now` for a Promise one.
             const now = waiter.now();
+            if (now - waiter.queuedAt >= this.queueTimeoutMs) {
+                this.rejectedTotal++;
+                waiter.outcome.settle(Exit.fail(this.concurrencyLimited(`queue wait exceeded ${this.queueTimeoutMs}ms`)));
+                continue;
+            }
             this.pruneBudget(state, now);
             const retryAfterMs = this.budgetRetryAfterMs(state, now);
             if (retryAfterMs !== undefined) {

package/dist/call-recovery.js

@@ -43,6 +43,3 @@ export function recordRecovery(ctx, facts) {
         recordFor(ctx);
     serviceFor(ctx, Recovery)?.recordNow?.(facts);
 }
-export function recoveryFor(ctx) {
-    return ctx ? serviceFor(ctx, RecordedRecovery)?.facts : undefined;
-}

package/dist/catalog-cache.js

@@ -2,6 +2,7 @@ import { detach, runEdge } from "./runtime/run.js";
 import { Deferred, Effect } from "effect";
 import { authFlow, authCall, authInvoke, authValue, authMethod, authProgram, registerAuth, authStorage, authMap, authAwait, } from "./auth/native.js";
 import { MAX_CACHE_TTL_MS, specTypeSchemas } from "@modelcontextprotocol/client";
+import { advanceCatalogRevision, catalogRevision } from "./catalog-revision.js";
 import { callerOf } from "./connector-caller.js";
 import { CONFIG_DEFAULTS } from "./config-defaults.js";
 import { Context } from "effect";
@@ -208,6 +209,17 @@ class CatalogPolicy extends Context.Service()("connecta/operation/CatalogPolicy"
 export function attachCatalogCache(ctx, value) {
     setViewService(ctx, CatalogPolicy, value);
 }
+/** Revalidate retained reads without storage I/O or credential material. */
+export function retainedCatalogIdentity(ctx) {
+    const policy = serviceFor(ctx, CatalogPolicy);
+    return JSON.stringify([
+        policy?.partition ?? JSON.stringify(callerOf(ctx) ?? null),
+        ctx.baseUrl,
+        ctx.publicUrl,
+        catalogRevision(policy?.storage ?? ctx.storage),
+        policy?.credentialRevision?.() ?? 0,
+    ]);
+}
 const defaultOwner = {};
 const scopes = new WeakMap();
 function cacheScope(ctx, connectorId, owner = defaultOwner) {
@@ -353,13 +365,20 @@ export function invalidateCatalogCache(storage, connectorId) {
     return runEdge(authProgram(invalidateCatalogCacheNative, [storage, connectorId]));
 }
 const invalidateCatalogCacheNative = /* @__PURE__ */ registerAuth(invalidateCatalogCache, (storage, connectorId) => authFlow(function* () {
-    (yield authStorage(storage, "set", [
-        responseCacheKeys.generation(connectorId),
-        crypto.randomUUID(),
-        {
-            ttlSeconds: GENERATION_TTL_SECONDS,
-        },
-    ]));
+    advanceCatalogRevision(storage);
+    try {
+        (yield authStorage(storage, "set", [
+            responseCacheKeys.generation(connectorId),
+            crypto.randomUUID(),
+            {
+                ttlSeconds: GENERATION_TTL_SECONDS,
+            },
+        ]));
+    }
+    finally {
+        // A read started while the durable fence was pending must also expire.
+        advanceCatalogRevision(storage);
+    }
 }));
 /** Keys ignore self-reported serverInfo and bind the configured connector instead. */
 export function catalogClientOptions(ctx, connectorId, config, authPartition, connectionSignal, owner, sharing = "private", resolveCredentialIdentity) {

package/dist/catalog-fingerprint.js

@@ -1,7 +1,8 @@
+import { bytesToHex } from "./bytes.js";
 const encoder = new TextEncoder();
 async function fingerprintBytes(bytes) {
     const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", new Uint8Array(bytes)));
-    const hex = [...digest].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+    const hex = bytesToHex(digest);
     return `sha256:${bytes.byteLength}:${hex}`;
 }
 /** Fingerprint an already serialized catalog without parsing/reserializing it. */
@@ -12,20 +13,3 @@ export async function fingerprintSerializedCatalog(serializedTools) {
         byteLength: bytes.byteLength,
     };
 }
-/**
- * Capture every persisted/discovered field in one deterministic snapshot.
- * Object key order is allowed to cause a conservative extra write; changing
- * any serialized field must change the digest.
- */
-export async function snapshotCatalog(tools) {
-    const serializedTools = JSON.stringify(tools);
-    if (serializedTools === undefined) {
-        throw new TypeError("Tool catalog is not JSON-serializable.");
-    }
-    const bytes = encoder.encode(serializedTools);
-    return {
-        tools,
-        fingerprint: await fingerprintBytes(bytes),
-        serializedBytes: bytes,
-    };
-}

package/dist/catalog-revision.js

@@ -0,0 +1,9 @@
+// Only counters cross request boundaries. No catalogs, identities or secrets
+// are retained here; weak owners are the deployment's cache store and vault.
+const revisions = new WeakMap();
+export function catalogRevision(owner) {
+    return owner ? (revisions.get(owner) ?? 0) : 0;
+}
+export function advanceCatalogRevision(owner) {
+    revisions.set(owner, catalogRevision(owner) + 1);
+}

package/dist/catalog-service.js

@@ -1,6 +1,7 @@
 import { registerAuthMethod } from "./auth/native.js";
 import { withAuthorizationHandoffEffect } from "./authorization-handoff.js";
 import { carryCatalogFreshness, catalogIsFresh } from "./catalog-freshness.js";
+import { retainedCatalogIdentity } from "./catalog-cache.js";
 import { cloneTool } from "./tool-safety.js";
 import { hasControlCharacters } from "./tool-name.js";
 import { Effect, Result } from "effect";
@@ -402,9 +403,10 @@ export class CatalogService {
     readOnly;
     // The request-scoped catalog cache: one shared read per connector asked
     // about, started by the first asker and joined by every later one. A
-    // success stays for the rest of the request, so a search and the call after
-    // it see one catalog. The cache owns a deep copy and each asker receives
-    // another, so discovery, invocation, and guest code never hold its objects.
+    // success stays while its in-process invalidation fence matches, so a search
+    // and the call after it see one current catalog. The cache owns a deep copy;
+    // each asker receives another at public boundaries. Search keeps private, stable safety views
+    // so its lexical index can be reused without exposing cached definitions.
     // A failure, or a read cancelled because every asker
     // left it, is dropped so the next ask reads again. The service lives and
     // dies with one request, so no read here is ever awaited from another.
@@ -415,6 +417,10 @@ export class CatalogService {
     // the success for the rest of the request, recorded by the read itself
     // rather than by an asker, whose probe deadline may have ended its wait.
     catalogs = new Map();
+    // Key by the private source array, never connector id: a replacement read
+    // gets new views and indexes. Each service belongs to one request and one
+    // registry visibility view (caller/pool, hidden tools and classification).
+    searchViews = new WeakMap();
     constructor(registry, baseUrl, options = {}) {
         this.registry = registry;
         this.baseUrl = baseUrl;
@@ -452,7 +458,7 @@ export class CatalogService {
         return runEdge(this.loadConnectorEffect(id, callOptions));
     }
     loadConnectorEffect(id, callOptions = {}) {
-        return Effect.suspend(() => duringViewEffect({ requestScope: this.requestScope, signal: callOptions.signal ?? this.requestSignal }, (signal) => this.catalog(id, { ...callOptions, signal }))).pipe(Effect.catchDefect((error) => Effect.fail(error)));
+        return Effect.suspend(() => duringViewEffect({ requestScope: this.requestScope, signal: callOptions.signal ?? this.requestSignal }, (signal) => Effect.map(this.catalog(id, { ...callOptions, signal }), (tools) => carryCatalogFreshness(tools, tools.map(cloneTool))))).pipe(Effect.catchDefect((error) => Effect.fail(error)));
     }
     // One connector's catalog from the request-scoped cache, reading it through
     // the registry when this request has not yet. No asker's options govern the
@@ -460,11 +466,16 @@ export class CatalogService {
     // timeout, whichever asker starts it. Each asker waits under its own signal
     // and deadline, so a short-deadline call that starts the read and a search
     // that joins it each end on their own terms, and the read is cancelled only
-    // once every asker has gone (#571).
+    // once every asker has gone.
     catalog(id, callOptions) {
         return Effect.suspend(() => {
-            let read = this.catalogs.get(id);
-            if (!read) {
+            // Authored static definitions never depend on a downstream cache or
+            // credentials. Keep their discovery independent of credential reads.
+            const identity = this.registry.getConnector(id)?.staticTools
+                ? "static"
+                : retainedCatalogIdentity(this.registry.contextFor(id, this.baseUrl, this.requestScope, callOptions));
+            let retained = this.catalogs.get(id);
+            if (!retained || retained.identity !== identity) {
                 const started = new SharedRead((signal) => registryProgram(this.registry, "getTools", id, this.baseUrl, this.requestScope, {
                     signal,
                     timeoutMs: this.probeTimeoutMs,
@@ -472,16 +483,31 @@ export class CatalogService {
                 }).pipe(Effect.map((tools) => carryCatalogFreshness(tools, tools.map(cloneTool)))), (succeeded) => {
                     // Evicted before the read resumes anyone, so an asker that
                     // retries on hearing of the failure starts a fresh read.
-                    if (!succeeded && this.catalogs.get(id) === started) {
+                    if (!succeeded && this.catalogs.get(id)?.read === started) {
                         this.catalogs.delete(id);
                     }
                 }, this.requestScope);
-                this.catalogs.set(id, started);
-                read = started;
+                retained = { identity, read: started };
+                this.catalogs.set(id, retained);
             }
-            return Effect.map(read.join(callOptions.signal), (tools) => carryCatalogFreshness(tools, tools.map(cloneTool)));
+            return retained.read.join(callOptions.signal);
         });
     }
+    searchView(id, tools, includeWrites, safety) {
+        const readOnly = !includeWrites && (this.readOnly || this.registry.getConnector(id)?.readOnly === true);
+        const key = `${readOnly}:${safety ?? "all"}`;
+        let views = this.searchViews.get(tools);
+        if (!views) {
+            views = new Map();
+            this.searchViews.set(tools, views);
+        }
+        let view = views.get(key);
+        if (!view) {
+            view = toolsForSafety(readOnly ? tools.filter((tool) => tool.classification === "read") : tools, safety ?? "all");
+            views.set(key, view);
+        }
+        return view;
+    }
     // Every named catalog under its own probe deadline, `concurrency` at a time,
     // each settling in its input slot: an unavailable catalog is a Failure
     // there, not a failed discovery. `route` names the surface in a timeout.
@@ -489,9 +515,7 @@ export class CatalogService {
     // that asked for it. On a read-only endpoint a write is absent from search
     // and describe, as if the connector never had it. Guides are not filtered.
     discoveryCatalogs(ids, route, includeWrites = false) {
-        return Effect.forEach(ids, (id) => Effect.result(withDeadlineEffect((signal) => !includeWrites && (this.readOnly || this.registry.getConnector(id)?.readOnly === true)
-            ? Effect.map(this.catalog(id, { signal }), (tools) => tools.filter((tool) => tool.classification === "read"))
-            : this.catalog(id, { signal }), {
+        return Effect.forEach(ids, (id) => Effect.result(withDeadlineEffect((signal) => Effect.map(this.catalog(id, { signal }), (tools) => this.searchView(id, tools, includeWrites, "all")), {
             ...(this.requestSignal ? { signal: this.requestSignal } : {}),
             timeoutMs: this.probeTimeoutMs,
             timeoutError: new ConnectorCallError("timeout", `${route} probe of "${id}" timed out after ${this.probeTimeoutMs}ms`),
@@ -512,7 +536,7 @@ export class CatalogService {
             return Effect.map(this.discoveryCatalogs(visible.map((connector) => connector.id), "tools/list", includeWrites), (results) => results.map((result, index) => {
                 const connector = visible[index];
                 return Result.isSuccess(result)
-                    ? { connector, tools: result.success }
+                    ? { connector, tools: carryCatalogFreshness(result.success, result.success.map(cloneTool)) }
                     : { connector, error: result.failure };
             }));
         })).pipe(Effect.catchDefect((error) => Effect.fail(error)));
@@ -581,7 +605,12 @@ export class CatalogService {
                     }
                     return {
                         ok: true,
-                        resolved: { connector, toolName, definition, classificationFresh: catalogIsFresh(tools) },
+                        resolved: {
+                            connector,
+                            toolName,
+                            definition: cloneTool(definition),
+                            classificationFresh: catalogIsFresh(tools),
+                        },
                         catalogMs: Date.now() - started,
                     };
                 },
@@ -672,7 +701,7 @@ export class CatalogService {
             const connectors = absence ? [] : args.connector ? (scopedConnector ? [scopedConnector] : []) : visibleConnectors;
             // Timeout messages name the route the caller used.
             const catalogs = yield* this.discoveryCatalogs(connectors.map((connector) => connector.id), this.searchRoute);
-            const searchableCatalogs = catalogs.map((catalog) => Result.map(catalog, (tools) => toolsForSafety(tools, safety)));
+            const searchableCatalogs = catalogs.map((catalog, index) => Result.map(catalog, (tools) => this.searchView(connectors[index].id, tools, true, safety)));
             const matches = [];
             let matchMode = "all";
             const statistics = lexicalCorpusStatistics(searchableCatalogs.flatMap((catalog) => (Result.isSuccess(catalog) ? [catalog.success] : [])), retrievalQuery);
@@ -784,7 +813,8 @@ export class CatalogService {
             });
             const pageMatches = matches.slice(offset, offset + limit);
             const withSchemas = args.includeSchemas;
-            const entries = pageMatches.map((match) => {
+            const entries = pageMatches.map((selected) => {
+                const match = { ...selected, tool: cloneTool(selected.tool) };
                 const output = withSchemas ? this.outputSchema(match.connector.id, match.tool) : {};
                 const input = match.tool.inputSchema ?? { type: "object" };
                 const signature = withSchemas === "typescript"
@@ -1143,8 +1173,8 @@ export class CatalogService {
                     };
                 }
                 const tools = catalog?.success ?? [];
-                const tool = tools.find((item) => item.name === addressResolution.toolName);
-                if (!tool) {
+                const selected = tools.find((item) => item.name === addressResolution.toolName);
+                if (!selected) {
                     const message = `Unknown tool "${boundedEchoText(addressResolution.toolName)}" on connector "${addressResolution.connector.id}"`;
                     const suggestions = describeSuggestions(addressResolution.connector.id, addressResolution.toolName, tools);
                     return {
@@ -1160,6 +1190,7 @@ export class CatalogService {
                         },
                     };
                 }
+                const tool = cloneTool(selected);
                 const input = tool.inputSchema ?? { type: "object" };
                 const output = this.outputSchema(addressResolution.connector.id, tool);
                 const description = summarizeDescription(tool.description, args.fullDescriptions === true);

package/dist/config-defaults.d.ts

@@ -20,6 +20,7 @@ export declare const CONFIG_DEFAULTS: {
         readonly hostCallTimeoutMs: 15000;
         readonly watchdogMs: 120000;
         readonly maxWrites: 10;
+        readonly maxResultChars: 24000;
     };
     readonly admission: {
         readonly requests: {

package/dist/config-defaults.js

@@ -27,6 +27,7 @@ export const CONFIG_DEFAULTS = {
         hostCallTimeoutMs: 15_000,
         watchdogMs: 120_000,
         maxWrites: 10,
+        maxResultChars: 24_000,
     },
     admission: {
         requests: {

package/dist/config-schema.d.ts

@@ -62,7 +62,7 @@ export declare class ConfigError extends TypeError {
 }
 interface WholeOptions {
     /** Smallest accepted value. */
-    min: 0 | 1;
+    min: number;
     /** Largest accepted value, when there is one. */
     max?: number;
     /** Unit named in the `max` refusal, e.g. "milliseconds". */

package/dist/config-schema.js

@@ -27,12 +27,16 @@ function ownValue(value, key) {
     return Object.prototype.hasOwnProperty.call(value, key) ? value[key] : undefined;
 }
 export function whole(options) {
-    const kind = options.min === 1 ? "positive" : "non-negative";
+    const kind = options.min === 0
+        ? "a non-negative whole number"
+        : options.min === 1
+            ? "a positive whole number"
+            : `a whole number of at least ${options.min.toLocaleString("en-US")}`;
     return {
         optional: true,
         parse: (value, path) => {
             if (typeof value !== "number" || !Number.isSafeInteger(value) || value < options.min) {
-                fail(`${path} must be a ${kind} whole number.`);
+                fail(`${path} must be ${kind}.`);
             }
             if (options.max !== undefined && value > options.max) {
                 fail(`${path} must be at most ${options.max.toLocaleString("en-US")}` + (options.unit ? ` ${options.unit}.` : "."));

package/dist/config.d.ts

@@ -28,11 +28,12 @@ declare const discovery: {
 declare const calls: {
     /**
      * Deadline (ms) for `call_tool`/`call_destructive_tool` calls that pass no
-     * `timeoutMs`. An explicit per-call value wins. Opt-in: unset by default, so
-     * existing long-running calls gain no surprise deadline.
+     * `timeoutMs`. An explicit per-call value wins. Unset by default, when those
+     * calls fall back to `execute.hostCallTimeoutMs`.
      *
-     * Each call makes one attempt. `execute_code` host calls are
-     * unaffected because they already carry their own bound.
+     * Each call makes one attempt. `connecta.call` inside `execute_code` uses
+     * it too, ahead of `execute.hostCallTimeoutMs`; `connecta.result`,
+     * `connecta.skill` and `connecta.read` do not.
      */
     defaultTimeoutMs: import("./config-schema.js").Field<number, number | undefined, true>;
     /**
@@ -60,9 +61,12 @@ declare const execute: {
     /** Host calls one program may make. Default 20. */
     maxHostCalls: import("./config-schema.js").Field<number, number, true>;
     /**
-     * Deadline for each host call a program makes, in milliseconds. Default
-     * 15_000. Raise it for providers whose legitimate calls run longer, such as
-     * analytics queries; `call_tool`'s own `timeoutMs` is unaffected.
+     * Deadline for a program's `connecta.result`, `connecta.skill` and
+     * `connecta.read`, in milliseconds. Default 15_000. Discovery uses
+     * `discovery.probeTimeoutMs`. `connecta.call` and the direct call tools use it only when
+     * `calls.defaultTimeoutMs` is unset, and an explicit per-call `timeoutMs`
+     * always wins. Raise it for providers whose legitimate calls run longer,
+     * such as analytics queries.
      */
     hostCallTimeoutMs: import("./config-schema.js").Field<number, number, true>;
     /**
@@ -78,6 +82,14 @@ declare const execute: {
      * budget every call already spends. Default 10.
      */
     maxWrites: import("./config-schema.js").Field<number, number, true>;
+    /**
+     * Serialized characters a program may return, shared with emitted text,
+     * before Connecta stashes the return and answers with a paging notice.
+     * Default 24_000 (~6k tokens). Raise it when agents need large results whole
+     * and the model's context can afford them: each paging round trip costs a
+     * model step. From 4_000 to 1_000_000.
+     */
+    maxResultChars: import("./config-schema.js").Field<number, number, true>;
 };
 declare const codeAdmission: {
     /** Simultaneous work admitted to this pool. */
@@ -333,11 +345,12 @@ declare const connectaConfig: {
         readonly shape: {
             /**
              * Deadline (ms) for `call_tool`/`call_destructive_tool` calls that pass no
-             * `timeoutMs`. An explicit per-call value wins. Opt-in: unset by default, so
-             * existing long-running calls gain no surprise deadline.
+             * `timeoutMs`. An explicit per-call value wins. Unset by default, when those
+             * calls fall back to `execute.hostCallTimeoutMs`.
              *
-             * Each call makes one attempt. `execute_code` host calls are
-             * unaffected because they already carry their own bound.
+             * Each call makes one attempt. `connecta.call` inside `execute_code` uses
+             * it too, ahead of `execute.hostCallTimeoutMs`; `connecta.result`,
+             * `connecta.skill` and `connecta.read` do not.
              */
             defaultTimeoutMs: import("./config-schema.js").Field<number, number | undefined, true>;
             /**
@@ -371,6 +384,7 @@ declare const connectaConfig: {
         hostCallTimeoutMs?: number | undefined;
         watchdogMs?: number | undefined;
         maxWrites?: number | undefined;
+        maxResultChars?: number | undefined;
     }, {
         readonly maxEmittedBytes: number;
         readonly maxEmittedBlocks: number;
@@ -378,6 +392,7 @@ declare const connectaConfig: {
         readonly hostCallTimeoutMs: number;
         readonly watchdogMs: number;
         readonly maxWrites: number;
+        readonly maxResultChars: number;
     }, true> & {
         readonly shape: {
             /**
@@ -391,9 +406,12 @@ declare const connectaConfig: {
             /** Host calls one program may make. Default 20. */
             maxHostCalls: import("./config-schema.js").Field<number, number, true>;
             /**
-             * Deadline for each host call a program makes, in milliseconds. Default
-             * 15_000. Raise it for providers whose legitimate calls run longer, such as
-             * analytics queries; `call_tool`'s own `timeoutMs` is unaffected.
+             * Deadline for a program's `connecta.result`, `connecta.skill` and
+             * `connecta.read`, in milliseconds. Default 15_000. Discovery uses
+             * `discovery.probeTimeoutMs`. `connecta.call` and the direct call tools use it only when
+             * `calls.defaultTimeoutMs` is unset, and an explicit per-call `timeoutMs`
+             * always wins. Raise it for providers whose legitimate calls run longer,
+             * such as analytics queries.
              */
             hostCallTimeoutMs: import("./config-schema.js").Field<number, number, true>;
             /**
@@ -409,6 +427,14 @@ declare const connectaConfig: {
              * budget every call already spends. Default 10.
              */
             maxWrites: import("./config-schema.js").Field<number, number, true>;
+            /**
+             * Serialized characters a program may return, shared with emitted text,
+             * before Connecta stashes the return and answers with a paging notice.
+             * Default 24_000 (~6k tokens). Raise it when agents need large results whole
+             * and the model's context can afford them: each paging round trip costs a
+             * model step. From 4_000 to 1_000_000.
+             */
+            maxResultChars: import("./config-schema.js").Field<number, number, true>;
         };
     };
     /**
@@ -654,5 +680,6 @@ export declare function executeLimits(config: ResolvedConfig): {
     hostCallTimeoutMs: number;
     watchdogMs: number;
     maxWrites: number;
+    maxResultChars: number;
 };
 export {};