@zackbart/connecta 0.7.8 → 0.8.0

package/src/executor-result.ts

@@ -1,14 +1,14 @@
 import type { ExecuteResult } from "./types.js";
 
 /** ~6k tokens. Sandbox code should filter data down before returning. */
-export const MAX_EXECUTE_RESULT_CHARS = 24_000;
+const MAX_EXECUTE_RESULT_CHARS = 24_000;
 export const MAX_EXECUTE_LOG_CHARS = 4_000;
 
 function msg(err: unknown): string {
   return err instanceof Error ? err.message : String(err);
 }
 
-export function serializeExecuteValue(value: unknown): string {
+function serializeExecuteValue(value: unknown): string {
   const serialized = JSON.stringify(value, null, 2);
   return serialized === undefined ? String(value) : serialized;
 }

package/src/executors/quickjs-child.ts

@@ -37,7 +37,11 @@ function send(message: ChildToParentMessage): void {
   process.send(message);
 }
 
-function provider(name: string, jobId: number): ExecutorProvider {
+function provider(
+  name: string,
+  jobId: number,
+  prelude?: string,
+): ExecutorProvider {
   const functions = new Proxy(
     Object.create(null) as ExecutorProvider["fns"],
     {
@@ -72,7 +76,7 @@ function provider(name: string, jobId: number): ExecutorProvider {
           : undefined,
     },
   );
-  return { name, fns: functions };
+  return { name, fns: functions, ...(prelude ? { prelude } : {}) };
 }
 
 function fixedTransportFailure(message: string): ExecutionPayload {
@@ -90,8 +94,8 @@ async function run(payload: RunPayload): Promise<void> {
   }
   activeJobId = payload.id;
   try {
-    const providers = payload.providerNames.map((name) =>
-      provider(name, payload.id),
+    const providers = payload.providers.map(({ name, prelude }) =>
+      provider(name, payload.id, prelude),
     );
     const raw = await executeQuickJs(
       payload.code,

package/src/executors/quickjs-protocol.ts

@@ -15,7 +15,7 @@ export const MAX_QUICKJS_HOST_RPC_BYTES = 256 * 1024;
 export interface RunPayload {
   id: number;
   code: string;
-  providerNames: string[];
+  providers: Array<{ name: string; prelude?: string }>;
   options: QuickJsRuntimeOptions;
 }
 

package/src/executors/quickjs-runtime.ts

@@ -88,7 +88,8 @@ function exceedsUtf8ByteLimit(value: string, limit: number): boolean {
 export function normalizeCode(code: string): string {
   let c = code.trim();
   const fence = /^```[\w-]*\s*\n([\s\S]*?)\n?```$/.exec(c);
-  if (fence) c = fence[1].trim();
+  const fencedCode = fence?.[1];
+  if (fencedCode !== undefined) c = fencedCode.trim();
   // Sniff for an existing function expression past any leading comments/blank
   // lines — models routinely prefix their code with a `//` or `/* */` note,
   // which would otherwise defeat the detection and wrap the whole thing.
@@ -122,6 +123,9 @@ function setupScript(providers: ExecutorProvider[]): string {
     const ns = JSON.stringify(p.name);
     lines.push(`globalThis[${ns}] = __namespace(${ns});`);
   }
+  for (const p of providers) {
+    if (p.prelude) lines.push(p.prelude);
+  }
   lines.push(`delete globalThis.__namespace;`);
   return lines.join("\n");
 }

package/src/executors/quickjs.ts

@@ -67,13 +67,13 @@ interface ActiveRun {
 }
 
 interface ChildSlot {
-  child?: ChildProcess;
-  ready?: Promise<void>;
-  resolveReady?: () => void;
-  rejectReady?: (error: Error) => void;
-  readyTimer?: ReturnType<typeof setTimeout>;
-  active?: ActiveRun;
-  expectedExit?: ChildProcess;
+  child?: ChildProcess | undefined;
+  ready?: Promise<void> | undefined;
+  resolveReady?: (() => void) | undefined;
+  rejectReady?: ((error: Error) => void) | undefined;
+  readyTimer?: ReturnType<typeof setTimeout> | undefined;
+  active?: ActiveRun | undefined;
+  expectedExit?: ChildProcess | undefined;
   consecutiveCrashes: number;
   notBefore: number;
 }
@@ -360,7 +360,10 @@ class QuickJsChildPool implements AdmittingExecutor {
         {
           id,
           code,
-          providerNames: providers.map((item) => item.name),
+          providers: providers.map((item) => ({
+            name: item.name,
+            ...(item.prelude ? { prelude: item.prelude } : {}),
+          })),
           options: this.runtimeOptions,
         } satisfies RunPayload,
         "QuickJS run payload",

package/src/favicon.ts

@@ -41,8 +41,8 @@ function buildIco(): Uint8Array {
       const pixel = pixels + (row * size + x) * 4;
       ico[pixel + 3] = opaque ? 255 : 0;
       if (!opaque) {
-        ico[mask + row * maskRowLength + Math.floor(x / 8)] |=
-          0x80 >> (x % 8);
+        const maskIndex = mask + row * maskRowLength + Math.floor(x / 8);
+        ico[maskIndex] = (ico[maskIndex] ?? 0) | (0x80 >> (x % 8));
       }
     }
   }

package/src/index.ts

@@ -72,6 +72,11 @@ export interface ConnectaCredentialsConfig {
 
 /** Tool-catalog caching, persistence, stale fallback, and probe deadlines. */
 export interface ConnectaDiscoveryConfig {
+  /**
+   * Maximum connector catalogs/status probes fetched at once by discovery
+   * operations. Default 4.
+   */
+  concurrency?: number;
   /** Tool-list cache TTL (seconds). Default 300. */
   catalogTtlSeconds?: number;
   /**
@@ -546,13 +551,25 @@ export function createConnecta(config: ConnectaConfig): Connecta {
   const registry = new Registry(config.connectors, {
     storage,
     logger,
-    credentialVault,
-    toolCacheTtlSeconds: config.discovery?.catalogTtlSeconds,
-    persistToolCatalog: config.discovery?.persistCatalog,
-    toolCatalogStaleSeconds: config.discovery?.staleCatalogSeconds,
-    maxResultBytes: config.calls?.maxResultBytes,
-    maxBatchResultBytes: config.calls?.maxBatchResultBytes,
-    credentialHealth: config.credentials?.health,
+    ...(credentialVault !== undefined ? { credentialVault } : {}),
+    ...(config.discovery?.catalogTtlSeconds !== undefined
+      ? { toolCacheTtlSeconds: config.discovery.catalogTtlSeconds }
+      : {}),
+    ...(config.discovery?.persistCatalog !== undefined
+      ? { persistToolCatalog: config.discovery.persistCatalog }
+      : {}),
+    ...(config.discovery?.staleCatalogSeconds !== undefined
+      ? { toolCatalogStaleSeconds: config.discovery.staleCatalogSeconds }
+      : {}),
+    ...(config.calls?.maxResultBytes !== undefined
+      ? { maxResultBytes: config.calls.maxResultBytes }
+      : {}),
+    ...(config.calls?.maxBatchResultBytes !== undefined
+      ? { maxBatchResultBytes: config.calls.maxBatchResultBytes }
+      : {}),
+    ...(config.credentials?.health !== undefined
+      ? { credentialHealth: config.credentials.health }
+      : {}),
   });
   // Throws on every structural mistake it can see (see resolveToolkits): a
   // typo must not become a scope the operator never wrote. Note this is about
@@ -588,23 +605,38 @@ export function createConnecta(config: ConnectaConfig): Connecta {
   const handler = createFetchHandler({
     registry,
     auth: inboundAuth,
-    publicUrl: config.publicUrl,
+    ...(config.publicUrl !== undefined ? { publicUrl: config.publicUrl } : {}),
     serverInfo: {
       ...config.serverInfo,
       name: config.serverInfo?.name ?? "connecta",
       version: config.serverInfo?.version ?? CONNECTA_VERSION,
     },
     logger,
-    activity: config.activity?.store,
-    activityReadGate: config.activity?.readGate,
-    activityDeploymentId: config.activity?.deploymentId,
-    executor,
+    ...(config.activity?.store !== undefined
+      ? { activity: config.activity.store }
+      : {}),
+    ...(config.activity?.readGate !== undefined
+      ? { activityReadGate: config.activity.readGate }
+      : {}),
+    ...(config.activity?.deploymentId !== undefined
+      ? { activityDeploymentId: config.activity.deploymentId }
+      : {}),
+    ...(executor !== undefined ? { executor } : {}),
     requestAdmission,
-    defaultToolTimeoutMs: config.calls?.defaultTimeoutMs,
-    probeTimeoutMs: config.discovery?.probeTimeoutMs,
-    credentialVault,
-    deploymentInfo: config.deploymentInfo,
-    branding: config.branding,
+    ...(config.calls?.defaultTimeoutMs !== undefined
+      ? { defaultToolTimeoutMs: config.calls.defaultTimeoutMs }
+      : {}),
+    ...(config.discovery?.probeTimeoutMs !== undefined
+      ? { probeTimeoutMs: config.discovery.probeTimeoutMs }
+      : {}),
+    ...(config.discovery?.concurrency !== undefined
+      ? { discoveryConcurrency: config.discovery.concurrency }
+      : {}),
+    ...(credentialVault !== undefined ? { credentialVault } : {}),
+    ...(config.deploymentInfo !== undefined
+      ? { deploymentInfo: config.deploymentInfo }
+      : {}),
+    ...(config.branding !== undefined ? { branding: config.branding } : {}),
     ...(toolkits ? { toolkits } : {}),
   });
   let closePromise: Promise<void> | undefined;
@@ -648,6 +680,7 @@ export function createConnecta(config: ConnectaConfig): Connecta {
       closePromise ??= Promise.resolve().then(async () => {
         requestAdmission.close();
         codeAdmission?.close();
+        registry.closeCallAdmission();
         await config.executor?.close?.();
       });
       await closePromise;
@@ -698,6 +731,10 @@ export type {
 export type { ApiOptions, ApiTool } from "./connectors/api.js";
 export type {
   Connector,
+  ConnectorCallAdmissionInput,
+  ConnectorCallAdmissionPolicy,
+  ConnectorCallAdmissionRule,
+  ConnectorRollingWindowBudget,
   ConnectaBranding,
   ConnectorCredentialAccess,
   ConnectorCredentialConfig,