@zackbart/connecta 0.7.7 → 0.7.9

package/src/execute.ts

@@ -16,6 +16,7 @@ import {
   truncateExecuteText,
 } from "./executor-result.js";
 import { classifyCallError, ConnectorCallError } from "./errors.js";
+import { isCallAdmissionError } from "./call-admission.js";
 import {
   ExecutorAdmissionError,
   isAdmittingExecutor,
@@ -192,27 +193,37 @@ export async function buildSandboxProviders(
     const controller = new AbortController();
     const cancel = () => controller.abort(limits.signal?.reason);
     limits.signal?.addEventListener("abort", cancel, { once: true });
+    if (limits.signal?.aborted) cancel();
     let timer: ReturnType<typeof setTimeout> | undefined;
-    let rejectCancelled!: (reason: Error) => void;
-    const cancelled = new Promise<never>((_, reject) => {
-      rejectCancelled = reject;
-    });
-    const onAbort = () => {
-      rejectCancelled(
-        controller.signal.reason instanceof Error
-          ? controller.signal.reason
-          : new Error("execute_code host call cancelled"),
-      );
-    };
-    controller.signal.addEventListener("abort", onAbort, { once: true });
-    const ctx = registry.contextFor(
-      resolved.connector.id,
-      baseUrl,
-      requestScope,
-      { signal: controller.signal, timeoutMs: hostCallTimeoutMs },
-    );
+    let onAbort: (() => void) | undefined;
     const started = Date.now();
+    let permit: Awaited<ReturnType<RegistryView["admitCall"]>> | undefined;
     try {
+      permit = await registry.admitCall(resolved.connector.id, {
+        toolName: resolved.toolName,
+        args: args ?? {},
+        signal: controller.signal,
+      });
+      let rejectCancelled!: (reason: Error) => void;
+      const cancelled = new Promise<never>((_, reject) => {
+        rejectCancelled = reject;
+      });
+      onAbort = () => {
+        rejectCancelled(
+          controller.signal.reason instanceof Error
+            ? controller.signal.reason
+            : new Error("execute_code host call cancelled"),
+        );
+      };
+      controller.signal.addEventListener("abort", onAbort, { once: true });
+      if (controller.signal.aborted) onAbort();
+      if (controller.signal.aborted) await cancelled;
+      const ctx = registry.contextFor(
+        resolved.connector.id,
+        baseUrl,
+        requestScope,
+        { signal: controller.signal, timeoutMs: hostCallTimeoutMs },
+      );
       timer = setTimeout(() => {
         controller.abort(
           new ConnectorCallError(
@@ -242,14 +253,34 @@ export async function buildSandboxProviders(
       });
       return value;
     } catch (err) {
-      registry.recordFailure(resolved.connector.id, Date.now() - started, err);
-      const details = classifyCallError(err);
+      const callerCancelled =
+        limits.signal?.aborted === true ||
+        (isCallAdmissionError(err) && err.admissionKind === "cancelled");
+      if (!callerCancelled && !isCallAdmissionError(err)) {
+        registry.recordFailure(
+          resolved.connector.id,
+          Date.now() - started,
+          err,
+        );
+      }
+      const details = callerCancelled
+        ? {
+            code: "cancelled",
+            message: "Tool call was cancelled by the caller.",
+            retryable: false,
+          }
+        : classifyCallError(err);
       recordToolActivity(activity, {
         connectorId: resolved.connector.id,
         toolName: resolved.toolName,
         address: `${resolved.connector.id}.${resolved.toolName}`,
         source: "execute_code",
-        outcome: details.code === "timeout" ? "timeout" : "error",
+        outcome:
+          details.code === "timeout"
+            ? "timeout"
+            : details.code === "cancelled"
+              ? "cancelled"
+              : "error",
         durationMs: Date.now() - started,
         attempts: 1,
         errorCode: details.code,
@@ -257,8 +288,9 @@ export async function buildSandboxProviders(
       throw err;
     } finally {
       if (timer) clearTimeout(timer);
-      controller.signal.removeEventListener("abort", onAbort);
+      if (onAbort) controller.signal.removeEventListener("abort", onAbort);
       limits.signal?.removeEventListener("abort", cancel);
+      permit?.release();
     }
   };
   for (let i = 0; i < connectors.length; i++) {
@@ -369,20 +401,33 @@ export async function buildSandboxProviders(
           score: number;
           order: number;
         }> = [];
-        let orderBase = 0;
-        for (const connector of connectors) {
-          if (args.connector && connector.id !== args.connector) continue;
-          const tools = catalogs.get(connector.id);
-          if (!tools) continue;
-          for (const ranked of rankTools(tools, args.query ?? "")) {
-            matches.push({
-              connector: connector.id,
-              tool: ranked.tool,
-              score: ranked.score,
-              order: orderBase + ranked.order,
-            });
+        let matchMode: "all" | "partial" = "all";
+        const collectMatches = (mode: "all" | "partial") => {
+          matches.length = 0;
+          let orderBase = 0;
+          for (const connector of connectors) {
+            if (args.connector && connector.id !== args.connector) continue;
+            const tools = catalogs.get(connector.id);
+            if (!tools) continue;
+            for (const ranked of rankTools(
+              tools,
+              args.query ?? "",
+              mode,
+            )) {
+              matches.push({
+                connector: connector.id,
+                tool: ranked.tool,
+                score: ranked.score,
+                order: orderBase + ranked.order,
+              });
+            }
+            orderBase += tools.length;
           }
-          orderBase += tools.length;
+        };
+        collectMatches("all");
+        if ((args.query ?? "").trim() && matches.length === 0) {
+          matchMode = "partial";
+          collectMatches(matchMode);
         }
         matches.sort((a, b) => b.score - a.score || a.order - b.order);
         const offset = Math.max(0, Math.trunc(args.offset ?? 0));
@@ -428,6 +473,9 @@ export async function buildSandboxProviders(
           limit,
           hasMore: nextOffset !== undefined,
           ...(nextOffset !== undefined ? { nextOffset } : {}),
+          ...(matchMode === "partial" && matches.length > 0
+            ? { matchMode }
+            : {}),
         };
         assertDiscoveryResultSize(
           result,

package/src/index.ts

@@ -94,7 +94,7 @@ export interface ConnectaDiscoveryConfig {
   probeTimeoutMs?: number;
 }
 
-/** Deployment-wide call deadlines and inline-result paging threshold. */
+/** Deployment-wide call deadlines and inline-result paging thresholds. */
 export interface ConnectaCallsConfig {
   /**
    * Deadline (ms) for `call_tool`/`batch_call` calls that pass no `timeoutMs`.
@@ -111,6 +111,13 @@ export interface ConnectaCallsConfig {
    * 50_000. Connectors may override it individually.
    */
   maxResultBytes?: number;
+  /**
+   * Max serialized `batch_call` envelope size (bytes) before the full batch is
+   * stashed for `get_result` and only an ordered outcome summary is returned
+   * inline. Must be a finite whole number >= 1; invalid values warn and fall
+   * back to 100_000. This cap is independent of per-connector child caps.
+   */
+  maxBatchResultBytes?: number;
 }
 
 export interface AdmissionPoolConfig {
@@ -544,6 +551,7 @@ export function createConnecta(config: ConnectaConfig): Connecta {
     persistToolCatalog: config.discovery?.persistCatalog,
     toolCatalogStaleSeconds: config.discovery?.staleCatalogSeconds,
     maxResultBytes: config.calls?.maxResultBytes,
+    maxBatchResultBytes: config.calls?.maxBatchResultBytes,
     credentialHealth: config.credentials?.health,
   });
   // Throws on every structural mistake it can see (see resolveToolkits): a
@@ -640,6 +648,7 @@ export function createConnecta(config: ConnectaConfig): Connecta {
       closePromise ??= Promise.resolve().then(async () => {
         requestAdmission.close();
         codeAdmission?.close();
+        registry.closeCallAdmission();
         await config.executor?.close?.();
       });
       await closePromise;
@@ -690,6 +699,10 @@ export type {
 export type { ApiOptions, ApiTool } from "./connectors/api.js";
 export type {
   Connector,
+  ConnectorCallAdmissionInput,
+  ConnectorCallAdmissionPolicy,
+  ConnectorCallAdmissionRule,
+  ConnectorRollingWindowBudget,
   ConnectaBranding,
   ConnectorCredentialAccess,
   ConnectorCredentialConfig,