@zackbart/connecta 0.22.3 → 0.23.0

package/dist/execute.js

@@ -1,15 +1,13 @@
 import { z } from "zod";
-import { PROGRAM_UI_META_KEY, PROGRAM_UI_RESOURCE_URI, } from "./apps-shell.js";
 import { boundedDiscoveryText, CatalogService, DiscoveryPolicyError, flatSearchResult, } from "./catalog-service.js";
 import { errorResult, jsonResult } from "./meta-tools.js";
 import { guardExecuteResultValue, MAX_EXECUTE_LOG_CHARS, truncateExecuteText, } from "./executor-result.js";
 import { ExecutorAdmissionError, ExecutorExecutionError, isAdmittingExecutor, } from "./executor-admission.js";
-import { boundedEchoText, classifyCallError, msg } from "./errors.js";
+import { boundedEchoText, msg } from "./errors.js";
 import { InvocationFailure, InvocationService, } from "./invocation.js";
 import { connectorGuide, connectorGuideRequired, connectorSkillName, hasConnectorGuides, } from "./skills.js";
 /** Keep one model-written program from amplifying into an unbounded fan-out. */
 const EXECUTE_MAX_HOST_CALLS = 20;
-export const EXECUTE_MAX_BATCH_CALLS = 10;
 const EXECUTE_HOST_CALL_TIMEOUT_MS = 15_000;
 /** Complete entries plus an exact omission count, all inside this byte cap. */
 export const CONNECTOR_INVENTORY_MAX_BYTES = 256;
@@ -30,21 +28,12 @@ class ExecuteDiagnostics {
     setupMs = 0;
     executorWallMs = 0;
     emitted;
-    ui;
     /** Numbers only, per R8 — and only once something was emitted, so a
      * non-emitting run's diagnostics stay byte-for-byte what they were. */
     recordEmitted(count, bytes) {
         if (count > 0)
             this.emitted = { count, bytes };
     }
-    /**
-     * U9: the UI payload gets its own aggregate — one number, the payload's
-     * serialized size. Folding it into `emitted` would desync that aggregate's
-     * pair, which reports the bytes a specific block count cost.
-     */
-    recordUi(bytes) {
-        this.ui = bytes;
-    }
     stats(operation) {
         let stats = this.operations.get(operation);
         if (!stats) {
@@ -70,36 +59,16 @@ class ExecuteDiagnostics {
         if (ok)
             stats.resultBytes += serializedDiagnosticBytes(result);
     }
-    recordCall(operation, outcome) {
-        const stats = this.stats(operation);
-        if (operation === "call") {
-            stats.count++;
-            if (outcome.ok) {
-                stats.resultBytes += serializedDiagnosticBytes(outcome.value);
-            }
-        }
-        else {
-            stats.calls = (stats.calls ?? 0) + 1;
-        }
+    recordCall(outcome) {
+        const stats = this.stats("call");
+        stats.count++;
+        if (outcome.ok)
+            stats.resultBytes += serializedDiagnosticBytes(outcome.value);
         stats.failures += outcome.ok ? 0 : 1;
-        if (operation === "call")
-            stats.durationMs += outcome.durationMs;
+        stats.durationMs += outcome.durationMs;
         stats.catalogMs += outcome.timing.catalogMs;
         stats.connectorMs += outcome.timing.connectorMs;
     }
-    recordBatch(durationMs, ok, calls, result) {
-        const stats = this.stats("batch");
-        stats.count++;
-        // Calls normally accrue while each child runs. Invalid batch input never
-        // starts children, so retain the attempted cardinality here.
-        if (!ok)
-            stats.calls = Math.max(stats.calls ?? 0, calls);
-        stats.durationMs += durationMs;
-        if (!ok)
-            stats.failures++;
-        else
-            stats.resultBytes += serializedDiagnosticBytes(result);
-    }
     finish() {
         const operations = [...this.operations.values()];
         return {
@@ -113,7 +82,6 @@ class ExecuteDiagnostics {
             },
             operations,
             ...(this.emitted ? { emitted: this.emitted } : {}),
-            ...(this.ui !== undefined ? { ui: this.ui } : {}),
         };
     }
 }
@@ -148,58 +116,12 @@ function requireEmittedBlock(raw) {
     }
     return raw;
 }
-const UI_SHAPE_HINT = "connecta.ui accepts exactly one argument: a non-empty string of HTML";
-/** What the argument was, named the way the emit validator names a bad field. */
-function describeUiArgument(raw) {
-    if (raw === null)
-        return "null";
-    if (raw === undefined)
-        return "undefined";
-    if (Array.isArray(raw))
-        return "an array";
-    if (typeof raw === "string")
-        return "an empty string";
-    const kind = typeof raw;
-    return `${/^[aeiou]/.test(kind) ? "an" : "a"} ${kind}`;
-}
-/**
- * Strict U1 validation. There is no options parameter and no sugar form, for
- * M1's reason: sugar is how a one-shape contract grows hair. An options bag or
- * an MCP block object is just a non-string, and fails as one.
- */
-function requireUiHtml(raw) {
-    if (typeof raw !== "string" || raw.length === 0) {
-        throw guestFailure("invalid_args", `${UI_SHAPE_HINT}; got ${describeUiArgument(raw)}`);
-    }
-    return raw;
-}
-function requireUiPayload(values) {
-    if (values.length !== 1) {
-        throw guestFailure("invalid_args", `${UI_SHAPE_HINT}; got ${values.length} arguments`);
-    }
-    return { html: requireUiHtml(values[0]) };
-}
-/**
- * Request-local collection for `connecta.emit` and `connecta.ui`. Budgets fail
- * loudly at the crossing call — nothing is partially accepted and prior blocks
- * are unaffected — so a program learns it is over budget while it can still
- * choose differently (M5, U4). Accepted output never rides `ExecuteResult`; the
- * handler that owns this collector delivers it on the final tool result.
- *
- * The two channels share the byte aggregate and nothing else: a UI payload is
- * not a block, so it spends no block count, and at most one is ever accepted.
- */
 export class EmitCollector {
     maxBytes;
     maxBlocks;
     diagnostics;
     blocks = [];
-    /** The shared transport aggregate: emitted blocks plus the UI payload. */
     bytes = 0;
-    /** The one accepted UI payload (U2), delivered in result `_meta` on success. */
-    ui;
-    /** What the blocks alone cost, so the `emitted` aggregate stays a true pair. */
-    blockBytes = 0;
     constructor(maxBytes, maxBlocks, diagnostics) {
         this.maxBytes = maxBytes;
         this.maxBlocks = maxBlocks;
@@ -216,45 +138,7 @@ export class EmitCollector {
         }
         this.blocks.push(block);
         this.bytes += size;
-        this.blockBytes += size;
-        this.diagnostics?.recordEmitted(this.blocks.length, this.blockBytes);
-    }
-    /**
-     * U2 and U4: one payload per run, measured as the serialized bytes of
-     * `{ html }` against the same aggregate emit spends. A second call throws
-     * naming the constraint rather than replacing the first — one tool result
-     * renders one view, and last-wins would silently discard a payload the
-     * program deliberately supplied.
-     *
-     * Multiplicity is checked before shape, so the second call is told what it
-     * actually broke. A program whose second payload is also malformed has one
-     * problem worth naming — that there is a second payload at all — and a
-     * complaint about its type would send the author to fix the wrong thing.
-     */
-    acceptUi(...values) {
-        this.assertUiVacant();
-        this.acceptUiPayload(requireUiPayload(values));
-    }
-    assertUiVacant() {
-        if (this.ui) {
-            throw guestFailure("invalid_args", "connecta.ui accepts at most one payload per run: a view was already accepted and stands");
-        }
-    }
-    acceptUiPayload(payload) {
-        let serialized;
-        try {
-            serialized = JSON.stringify(payload);
-        }
-        catch {
-            throw guestFailure("invalid_args", "connecta.ui payload must be JSON-serializable");
-        }
-        const size = diagnosticsEncoder.encode(serialized).byteLength;
-        if (this.bytes + size > this.maxBytes) {
-            throw guestFailure("budget_exceeded", `connecta.ui byte budget exceeded: payload is ${size} serialized bytes with ${this.maxBytes - this.bytes} of ${this.maxBytes} remaining`);
-        }
-        this.ui = payload;
-        this.bytes += size;
-        this.diagnostics?.recordUi(size);
+        this.diagnostics?.recordEmitted(this.blocks.length, this.bytes);
     }
 }
 /** A configured emit budget must be a finite number >= 1; anything else falls back. */
@@ -276,85 +160,6 @@ function serializedDiagnosticBytes(value) {
         return 0;
     }
 }
-// deno-fmt-ignore
-const RESERVED = new Set([
-    "break",
-    "case",
-    "catch",
-    "class",
-    "const",
-    "continue",
-    "debugger",
-    "default",
-    "delete",
-    "do",
-    "else",
-    "enum",
-    "export",
-    "extends",
-    "false",
-    "finally",
-    "for",
-    "function",
-    "if",
-    "import",
-    "in",
-    "instanceof",
-    "let",
-    "new",
-    "null",
-    "return",
-    "static",
-    "super",
-    "switch",
-    "this",
-    "throw",
-    "true",
-    "try",
-    "typeof",
-    "var",
-    "void",
-    "while",
-    "with",
-    "yield",
-    "await",
-    "async",
-]);
-/** Convert a connector/tool name into a valid JS identifier. */
-export function sanitizeIdentifier(name) {
-    let id = name.replace(/[^A-Za-z0-9_$]/g, "_");
-    if (/^[0-9]/.test(id))
-        id = `_${id}`;
-    if (RESERVED.has(id))
-        id = `${id}_`;
-    return id;
-}
-const SANDBOX_RESERVED_NAMES = new Set([
-    "connecta",
-    "console",
-    "arguments",
-    "result",
-    "undefined",
-    "setTimeout",
-    "Promise",
-    "Error",
-    "WorkerEntrypoint",
-    "CodeExecutor",
-    "__invoke",
-    "__namespace",
-    "__call",
-    "__log",
-    "__dispatchers",
-    "__connectors",
-    "__logs",
-    "__CODEMODE_BINARY_TAG",
-    "__bytesToBase64",
-    "__base64ToBytes",
-    "__encodeCodemodeValue",
-    "__decodeCodemodeValue",
-    "__stringifyForCodemode",
-    "__parseForCodemode",
-]);
 function guestFailure(code, message, retryable = false) {
     return new InvocationFailure({ code, message, retryable });
 }
@@ -373,15 +178,8 @@ function framedGuestFailure(secret, failure) {
     guestFailureFrames.set(failure, framed.message);
     return framed;
 }
-/**
- * Rebuilds host failures as guest Error instances, then installs connector
- * shortcuts. The random frame is hidden in this closure and Error is locked:
- * connector prose and model code can neither collide with nor forge its frame.
- */
-function lazyNamespacePrelude(connectors, failureSecret) {
-    const declarations = connectors
-        .map(({ id, namespace }) => `globalThis[${JSON.stringify(namespace)}] = __makeConnectaNamespace(${JSON.stringify(id)});`)
-        .join("\n");
+/** Rebuild host failures as guest errors without exposing the private frame. */
+function guestErrorPrelude(failureSecret) {
     return `((failurePrefix) => {
   const NativeError = globalThis.Error;
   const startsWith = Function.prototype.call.bind(String.prototype.startsWith);
@@ -417,20 +215,13 @@ function lazyNamespacePrelude(connectors, failureSecret) {
     writable: false,
     configurable: false
   });
-  const __makeConnectaNamespace = (connectorId) => Object.freeze(new Proxy(Object.create(null), {
-    get: (_target, toolName) => typeof toolName === "string"
-      ? (args) => connecta.__callNamespace(connectorId, toolName, args)
-      : undefined
-  }));
-${declarations}
 })(${JSON.stringify(`${GUEST_FAILURE_FRAME}${failureSecret}:`)});`;
 }
 /**
- * Expose one fixed host provider plus trusted sandbox setup that creates a
- * lazy proxy global per connector. No connector catalog is touched until code
- * calls that namespace or explicitly asks search/describe.
+ * Expose one host provider and typed guest errors. Catalogs load only when
+ * the program calls a tool or asks search/describe.
  */
-export async function buildSandboxProviders(registry, baseUrl, logger, activity, limits = {}) {
+export async function buildSandboxProviders(registry, baseUrl, _logger, activity, limits = {}) {
     // All host calls made by one execute_code invocation share a downstream
     // connection, while a later invocation receives a fresh request scope.
     const requestScope = {};
@@ -447,24 +238,6 @@ export async function buildSandboxProviders(registry, baseUrl, logger, activity,
     const hostCallTimeoutMs = Math.max(1, Math.trunc(limits.hostCallTimeoutMs ?? EXECUTE_HOST_CALL_TIMEOUT_MS));
     const failureSecret = guestFailureSecret();
     let hostCalls = 0;
-    const connectors = registry.listConnectors();
-    const namespaces = [];
-    const namespaceOwners = new Map();
-    for (const connector of connectors) {
-        const namespace = sanitizeIdentifier(connector.id);
-        const owner = namespaceOwners.get(namespace);
-        const problem = SANDBOX_RESERVED_NAMES.has(namespace)
-            ? `Connector "${connector.id}" sanitizes to reserved execute_code namespace "${namespace}". Rename or exclude the connector before using execute_code.`
-            : owner
-                ? `Connector ids "${owner}" and "${connector.id}" both sanitize to execute_code namespace "${namespace}". Rename or exclude one connector before using execute_code.`
-                : undefined;
-        if (problem) {
-            logger.warn(`[connecta] execute_code: ${problem}`);
-            throw new Error(problem);
-        }
-        namespaceOwners.set(namespace, connector.id);
-        namespaces.push({ id: connector.id, namespace });
-    }
     const invocationContext = () => ({
         source: "execute_code",
         timeoutMs: hostCallTimeoutMs,
@@ -504,21 +277,14 @@ export async function buildSandboxProviders(registry, baseUrl, logger, activity,
             throw err;
         }
     };
-    const called = async (operation, invoke) => {
-        const outcome = await invoke();
-        limits.diagnostics?.recordCall(operation, outcome);
+    const callAddress = async (address, args) => {
+        const outcome = await invocation.invoke(String(address), args ?? {}, invocationContext());
+        limits.diagnostics?.recordCall(outcome);
         if (!outcome.ok)
             throw new InvocationFailure(outcome.error);
         return outcome.value;
     };
-    const callAddress = async (address, args, diagnosticOperation = "call") => {
-        return called(diagnosticOperation, () => invocation.invoke(String(address), args ?? {}, invocationContext()));
-    };
-    const callNamespace = async (connectorId, toolAlias, args) => {
-        return called("call", () => invocation.invokeToolAlias(String(connectorId), String(toolAlias), sanitizeIdentifier, args ?? {}, invocationContext()));
-    };
     const fns = {
-        __callNamespace: callNamespace,
         call: (address, args) => callAddress(address, args),
         // Emission is a provider function, never an ExecuteResult field —
         // that is what keeps the Executor contract untouched and parity
@@ -530,55 +296,6 @@ export async function buildSandboxProviders(registry, baseUrl, logger, activity,
             }
             limits.emitCollector.accept(block);
         },
-        // The rendered-output channel rides the same bridge for the same
-        // reason (U7): one more provider fn, no change to ExecuteResult or
-        // the Executor contract. Delivery is the handler's job, not the
-        // guest's — nothing here becomes addressable.
-        ui: async (...values) => {
-            if (!limits.emitCollector) {
-                throw guestFailure("unavailable", "connecta.ui is unavailable: no emission collector was configured for this execution", true);
-            }
-            limits.emitCollector.acceptUi(...values);
-        },
-        batch: async (calls) => {
-            const started = Date.now();
-            const callCount = Array.isArray(calls) ? calls.length : 0;
-            try {
-                if (!Array.isArray(calls)) {
-                    throw guestFailure("invalid_args", "calls must be an array");
-                }
-                if (calls.length > EXECUTE_MAX_BATCH_CALLS) {
-                    throw guestFailure("invalid_args", `connecta.batch accepts at most ${EXECUTE_MAX_BATCH_CALLS} calls`);
-                }
-                const result = await Promise.all(calls.map(async (call) => {
-                    const item = call;
-                    try {
-                        return {
-                            address: String(item.address),
-                            ok: true,
-                            data: await callAddress(item.address, item.args, "batch"),
-                        };
-                    }
-                    catch (err) {
-                        const details = err instanceof InvocationFailure
-                            ? err.details
-                            : classifyCallError(err, "batch_call_failed");
-                        return {
-                            address: String(item.address),
-                            ok: false,
-                            error: details.message,
-                            errorDetails: details,
-                        };
-                    }
-                }));
-                limits.diagnostics?.recordBatch(Date.now() - started, true, callCount, result);
-                return result;
-            }
-            catch (err) {
-                limits.diagnostics?.recordBatch(Date.now() - started, false, callCount);
-                throw err;
-            }
-        },
         search: async (raw) => timedCatalog("search", () => typedDiscovery(async () => {
             const args = (raw ?? {});
             const result = flatSearchResult(await catalog.search({
@@ -614,7 +331,7 @@ export async function buildSandboxProviders(registry, baseUrl, logger, activity,
     return [
         {
             name: "connecta",
-            prelude: lazyNamespacePrelude(namespaces, failureSecret),
+            prelude: guestErrorPrelude(failureSecret),
             fns: transportedFns,
         },
     ];
@@ -790,19 +507,9 @@ export function createExecuteTool(registry, baseUrl, executor, logger, activity,
         const response = jsonResult({
             result,
             ...(emitted.blocks.length > 0 ? { emitted: emitted.blocks.length } : {}),
-            // U3: the model learns a view rendered without seeing its bytes. Spread
-            // conditionally so a program that never called connecta.ui produces
-            // today's byte-for-byte response.
-            ...(emitted.ui ? { ui: true } : {}),
             ...(logs ? { logs } : {}),
             ...(diagnostics ? { diagnostics: diagnostics.finish() } : {}),
         });
-        if (emitted.ui) {
-            // _meta is where the Apps spec's best practices put data "not intended
-            // for model context", and how shipped hosts behave. The shell reads
-            // exactly this key out of the tool result the host delivers to it.
-            response._meta = { [PROGRAM_UI_META_KEY]: emitted.ui };
-        }
         if (emitted.blocks.length > 0) {
             // Emitted image/audio blocks are valid MCP content that ToolResult's
             // text-only typing does not model — the same acknowledged gap
@@ -829,42 +536,35 @@ function failureResponse(message, options) {
     return errorResult(`${message}${logs ? `\n\nLogs:\n${logs}` : ""}${emitted ? discardedEmitsText(emitted) : ""}`);
 }
 /**
- * M4 and U3: a failed program delivers no blocks and no view, but each
- * discard is visible — and one failure can discard both.
+ * A failed program delivers no blocks and reports how many were discarded.
  */
 function discardedEmits(emitted) {
-    return {
-        ...(emitted.blocks.length > 0
-            ? { emittedDiscarded: emitted.blocks.length }
-            : {}),
-        ...(emitted.ui ? { uiDiscarded: true } : {}),
-    };
+    return emitted.blocks.length > 0
+        ? { emittedDiscarded: emitted.blocks.length }
+        : {};
 }
 /** The same visibility for the plain-text error paths. */
 function discardedEmitsText(emitted) {
-    const lines = [
-        ...(emitted.blocks.length > 0
-            ? [`emittedDiscarded: ${emitted.blocks.length}`]
-            : []),
-        ...(emitted.ui ? ["uiDiscarded: true"] : []),
-    ];
-    return lines.length > 0 ? `\n\n${lines.join("\n")}` : "";
+    return emitted.blocks.length > 0
+        ? `\n\nemittedDiscarded: ${emitted.blocks.length}`
+        : "";
 }
 function connectorInventory(connectors) {
     const prefix = "Connectors: ";
     if (connectors.length === 0)
         return `${prefix}none.`;
     const entries = connectors.map((connector) => {
-        const shortcut = sanitizeIdentifier(connector.id);
-        const address = shortcut === connector.id
-            ? connector.id
-            : `${connector.id} (shortcut ${shortcut})`;
+        const address = connector.id;
+        const title = connector.title?.replace(/\s+/g, " ").trim();
+        const label = title && title !== connector.id
+            ? `${address}: ${boundedEchoText(title, 45)}`
+            : address;
         if (!connectorGuide(connector))
-            return address;
+            return label;
         const requirement = connectorGuideRequired(connector)
             ? "required guide"
             : "guide";
-        return `${address} (${requirement} ${connectorSkillName(connector.id)})`;
+        return `${label} (${requirement} ${connectorSkillName(connector.id)})`;
     });
     const shown = [];
     for (let index = 0; index < entries.length; index++) {
@@ -885,18 +585,19 @@ function connectorInventory(connectors) {
         return `${prefix}${shown.join(", ")}.`;
     return `${prefix}${shown.join(", ")}${shown.length > 0 ? "; " : ""}+${omitted} more.`;
 }
-const executeDescription = (emitBudgets, connectorGuides, connectors) => `Choose the route before discovery. A known address uses call_tool. Unknown-address and wider read-only work use exactly one execute_code call that discovers, calls, and returns the answer. Finish in that program; don't return catalog matches for a later call. Only readOnlyHint: true tools are available. Limits: ${EXECUTE_MAX_HOST_CALLS} host calls per run, ${EXECUTE_MAX_BATCH_CALLS} per batch, ${EXECUTE_HOST_CALL_TIMEOUT_MS / 1_000}-second host deadline.
+const executeDescription = (emitBudgets, connectorGuides, connectors) => `Use the configured services below to answer the task. A known address uses call_tool. Unknown-address and wider read-only work uses one execute_code program for discovery, calls, and reduction. Do not return catalog matches alone. Only readOnlyHint: true tools are available. Limits: ${EXECUTE_MAX_HOST_CALLS} host calls, ${EXECUTE_HOST_CALL_TIMEOUT_MS / 1_000}s/host call.
 
 ${connectorInventory(connectors)}
 
-Fetch required guides named above before executing. Write one plain-JavaScript async arrow function. Use only:
-- <connectorId>.<toolName>(args) for a sanitized shortcut, or connecta.call(address, args) for a canonical address.
-- connecta.search(args) returns { tools }; connecta.describe(args) returns { tools }; use entry key lists. connecta.batch(calls) accepts canonical connector addresses only.
-- connecta.emit(block) — { type: "text", text } or { type: "image" | "audio", data (base64), mimeType }. Success-only; ${emitBudgets.maxBlocks} blocks/${emitBudgets.maxBytes} bytes; invalid/over-budget throws.
-- connecta.ui(html) for one display-only, success-only view; return the same summary the HTML renders.
-- console.log(...) — captured.
+Read relevant guides using top-level skills, not sandbox code. Write a plain-JavaScript async arrow:
+- connecta.search({ connector, query, safety: "readOnly", includeSchemas: "json" }) returns { tools }. Search each operation separately; choose by connectorTitle and schemas. Use schema.required and .properties to build args, never guessed fields. Compact schemas are text.
+- connecta.describe({ address }) returns { tools } for unclear schemas.
+- connecta.call(address, args) returns the provider value directly.
+- Use Promise.all for independent calls, or Promise.allSettled to retain failures. Check status before reading value; rejected calls and missing fields are unknown, never false or zero.
+- connecta.emit(block): { type: "text", text } or { type: "image" | "audio", data (base64), mimeType }; success-only, ${emitBudgets.maxBlocks} blocks/${emitBudgets.maxBytes} bytes.
+- console.log(...) is captured. Return data for the client to render.
 
-No portable ambient capabilities. Return JSON; reduce large results before truncation. Build arguments from required input keys and schemas, never descriptions or output keys. Fetch skills({ name: "usage" }) only when this is insufficient or repair is needed; it has full rules, examples${connectorGuides ? ", guide handling" : ""}, and runtime details.`;
+No portable ambient capabilities. Return reduced JSON. If a provider result has an unfamiliar shape, return a small sample and continue in another call; never guess fields or use the whole text as an id. Top-level skills({ name: "usage" }): repair${connectorGuides ? ", guide handling" : ""}; skills({ name: "investigate" }): task planning.`;
 /** Register the execute_code meta-tool. Only called when an executor is configured. */
 export function registerExecuteTool(server, registry, ctx) {
     // Resolved once so the description and the collector cannot disagree about
@@ -932,14 +633,6 @@ export function registerExecuteTool(server, registry, ctx) {
             destructiveHint: false,
             openWorldHint: true,
         },
-        // U5 and U10 are specified in documentation/code-mode.md; explicit model
-        // visibility prevents hosts from offering execute_code to the view.
-        _meta: {
-            ui: {
-                resourceUri: PROGRAM_UI_RESOURCE_URI,
-                visibility: ["model"],
-            },
-        },
     }, async (args, extra) => {
         const controller = new AbortController();
         const signals = [extra.mcpReq.signal, ctx.requestSignal].filter((signal) => signal !== undefined);

package/dist/executors/quickjs-protocol.d.ts

@@ -54,13 +54,6 @@ export interface ExecutionPayload {
      */
     timedOut?: boolean;
 }
-/**
- * How a host call should be named in an error a program will read. The lazy
- * connector namespaces all dispatch through one internal function, so the raw
- * provider/function pair would report every shortcut call as
- * `connecta.__callNamespace` — an internal name that appears nowhere in the
- * documented surface. Report the address the program actually called.
- */
 export declare function hostCallLabel(payload: {
     namespace: string;
     functionName: string;

package/dist/executors/quickjs-protocol.js

@@ -8,17 +8,9 @@ export const MAX_QUICKJS_IPC_BYTES = 1024 * 1024;
 export const MAX_QUICKJS_LOG_TRANSPORT_BYTES = 512 * 1024;
 /** Preserve #84's stopgap before a host value enters the child/WASM process. */
 export const MAX_QUICKJS_HOST_RPC_BYTES = 256 * 1024;
-/**
- * How a host call should be named in an error a program will read. The lazy
- * connector namespaces all dispatch through one internal function, so the raw
- * provider/function pair would report every shortcut call as
- * `connecta.__callNamespace` — an internal name that appears nowhere in the
- * documented surface. Report the address the program actually called.
- */
 export function hostCallLabel(payload) {
-    if (payload.functionName === "__callNamespace") {
-        const [connectorId, toolAlias] = payload.args;
-        return `${String(connectorId)}.${String(toolAlias)}`;
+    if (payload.namespace === "connecta" && payload.functionName === "call") {
+        return String(payload.args[0]);
     }
     return `${payload.namespace}.${payload.functionName}`;
 }

package/dist/executors/quickjs.js

@@ -411,7 +411,7 @@ class QuickJsChildPool {
             }
             catch (err) {
                 // The guest reads this text, so it names the address the program called
-                // rather than the internal dispatcher every shortcut namespace shares.
+                // rather than only the generic connecta.call bridge function.
                 const label = hostCallLabel(payload);
                 const detail = err instanceof RangeError
                     ? `Host result from ${label} exceeds the ${MAX_QUICKJS_HOST_RPC_BYTES}-byte serialized bridge limit.`

package/dist/index.d.ts

@@ -65,7 +65,7 @@ export interface ConnectaCallsConfig {
      * `timeoutMs`. An explicit per-call value wins. Opt-in: unset by default, so
      * existing long-running calls gain no surprise deadline.
      *
-     * This bounds one attempt, not all retries. `execute_code` host calls are
+     * Each call makes one attempt. `execute_code` host calls are
      * unaffected because they already carry their own bound.
      */
     defaultTimeoutMs?: number;

package/dist/invocation.d.ts

@@ -2,36 +2,10 @@ import { type ActivityCallSource, type ActivityRequestContext, type AgentFrictio
 import { CatalogService, type ResolvedCatalogTool } from "./catalog-service.js";
 import { type CallErrorDetails } from "./errors.js";
 import { type RegistryView } from "./registry.js";
-/**
- * The longest the engine will park a synchronous inbound request in *waiting
- * alone*. The engine already treats ~15 s as the outer bound of one reasonable
- * connector call (EXECUTE_HOST_CALL_TIMEOUT_MS), so sleeping for minutes trades
- * a fast, informative failure for a hung one. A connector-reported window this
- * long isn't truncated — it's declined (see `retryBackoffMs`) and reported
- * verbatim as `error.retryAfterMs`, so the agent, which can afford to wait,
- * decides when to re-issue.
- */
-export declare const MAX_RETRY_BACKOFF_MS = 10000;
-/**
- * How long to wait before the next attempt, or `undefined` for "don't retry".
- *
- * A connector that read a `Retry-After` header knows the window exactly, so it
- * is honoured **exactly or not at all**: truncating an exponential *guess* is
- * harmless, but truncating a *known* window means deliberately retrying inside
- * a rate limit — the harm this channel exists to prevent. A window longer than
- * `MAX_RETRY_BACKOFF_MS` therefore declines the retry rather than shortening
- * it. (`retryAfterMs` is normalized non-negative, so `0` means "retry now".)
- * Connectors that report no window keep the historical exponential guess.
- *
- * Waits are per attempt, matching the per-attempt `timeoutMs` race in
- * `InvocationService.invoke`. Exported for direct testing.
- */
-export declare function retryBackoffMs(attempt: number, retryAfterMs: number | undefined): number | undefined;
 export interface InvocationTiming {
     catalogMs: number;
     admissionMs: number;
     connectorMs: number;
-    backoffMs: number;
     resultProcessingMs: number;
     totalMs: number;
 }
@@ -53,7 +27,6 @@ export interface InvocationContext<T> {
     source: ActivityCallSource;
     allowDestructive?: boolean;
     timeoutMs?: number;
-    maxRetries?: number;
     requestSignal?: AbortSignal;
     unwrapResult?: boolean;
     /**
@@ -97,11 +70,5 @@ export declare class InvocationService {
     private readonly activity?;
     constructor(registry: RegistryView, catalog: CatalogService, activity?: ActivityRequestContext | undefined);
     invoke<T = unknown>(address: string, args: unknown, context: InvocationContext<T>): Promise<InvocationOutcome<T>>;
-    /**
-     * Code-mode namespace dispatch preserves JavaScript-safe tool aliases while
-     * still feeding the resolved catalog entry through the one invocation path.
-     */
-    invokeToolAlias<T = unknown>(connectorId: string, toolAlias: string, aliasFor: (toolName: string) => string, args: unknown, context: InvocationContext<T>): Promise<InvocationOutcome<T>>;
-    private invokeWithResolution;
 }
 export {};