@zackbart/connecta 0.22.3 → 0.24.0

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

@@ -1,34 +1,9 @@
+import type { CredentialVault } from "./credential-contract.js";
 import { Registry } from "./registry.js";
-import type { ActivityReadGate, ActivityStore } from "./activity.js";
-import type { AuthenticatedIdentity, Connector, ConnectaBranding, Executor, IdentityReference, InboundAuth, KVStorage, Logger } from "./types.js";
-/** Payload-free activity storage and operator-read policy. */
-export interface ConnectaActivityConfig {
-    /**
-     * Privacy-minimal downstream tool activity storage. Writes are best-effort
-     * and never change tool results. Implement `list` to enable the Activity UI.
-     */
-    store: ActivityStore;
-    /**
-     * Optional authorization gate for the Activity read API. MCP authentication
-     * is still required first. Omit to admit every authenticated actor.
-     */
-    readGate?: ActivityReadGate;
-    /** Stable deployment label included in activity events, e.g. "production". */
-    deploymentId?: string;
-}
-/** Operator-vault encryption. */
-export interface ConnectaCredentialsConfig {
-    /**
-     * Base64-encoded 32-byte AES key for credentials managed on /credentials.
-     * Keep this in the runtime's secret store, never in KV or source control.
-     */
-    encryptionKey?: string;
-}
-/** Operator-issued credentials for clients connecting to this deployment. */
-export interface ConnectaAccessTokensConfig {
-    /** Maximum simultaneously active access tokens. Defaults to 100. */
-    maxActive?: number;
-}
+import type { ActivityModule, OperatorSurface } from "./module-contracts.js";
+export type { ActivityModule, OperatorSurface } from "./module-contracts.js";
+export type { CredentialVault, CredentialMetadata } from "./credential-contract.js";
+import type { AuthenticatedIdentity, Connector, Executor, IdentityReference, InboundAuth, KVStorage, Logger } from "./types.js";
 /** Tool-catalog caching, persistence, stale fallback, and probe deadlines. */
 export interface ConnectaDiscoveryConfig {
     /**
@@ -65,7 +40,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;
@@ -116,22 +91,22 @@ export interface ConnectaAdmissionConfig {
     code?: AdmissionPoolConfig;
 }
 /** Config-owned identity rules for one deployment and tenant. */
+export type ConnectorPermission = "all" | "none" | readonly string[];
 export interface ConnectaIdentityConfig {
     /** Connector ids this admitted identity may discover and call. */
     connectorAccess?(identity: Readonly<AuthenticatedIdentity>): "all" | readonly string[] | Promise<"all" | readonly string[]>;
-    /**
-     * Whether a human may manage deployment access tokens and global activity.
-     * Connector access already permits that human to manage the visible
-     * connector's shared or personal auth. Omit to preserve the existing
-     * all-interactive-humans operator rule.
-     */
-    operatorAccess?(principal: Readonly<IdentityReference>): boolean | Promise<boolean>;
+    /** Global payload-free activity reads. Defaults to interactive humans. */
+    activityAccess?(principal: Readonly<IdentityReference>): boolean | Promise<boolean>;
+    /** Shared credential and OAuth administration. Defaults to none. */
+    credentialAdministration?(identity: Readonly<AuthenticatedIdentity>): ConnectorPermission | Promise<ConnectorPermission>;
+    /** Connecting or changing the caller's personal account. Defaults to none. */
+    personalConnection?(identity: Readonly<AuthenticatedIdentity>): ConnectorPermission | Promise<ConnectorPermission>;
 }
 export interface ConnectaConfig {
     connectors: Connector[];
     /** Inbound auth adapters. Includes bearerToken(...); omit for open (dev). */
     auth?: InboundAuth | InboundAuth[];
-    /** Identity-derived connector visibility and deployment operator membership. */
+    /** Code-derived connection visibility and independent management permissions. */
     identity?: ConnectaIdentityConfig;
     /** KVStorage impl. Defaults to memoryStorage(). */
     storage?: KVStorage;
@@ -140,15 +115,12 @@ export interface ConnectaConfig {
      * HTTPS URL also redirects matching inbound HTTP requests to HTTPS.
      */
     publicUrl?: string;
-    /** Payload-free tool activity storage and operator-read policy. */
-    activity?: ConnectaActivityConfig;
-    /** Operator credential vault settings. */
-    credentials?: ConnectaCredentialsConfig;
-    /**
-     * Named, revocable Bearer tokens for MCP clients. Creation and mutation
-     * require an eligible interactive operator; token secrets are returned once.
-     */
-    accessTokens?: ConnectaAccessTokensConfig;
+    /** Optional recorder and reader, created by activityHistory() from /activity. */
+    activity?: ActivityModule;
+    /** Replaceable owner-partitioned credential storage. Omit for config-owned secrets. */
+    vault?: CredentialVault;
+    /** Optional connection UI, created by operatorUi() from /ui. */
+    ui?: OperatorSurface;
     /** Tool-catalog caching, persistence, stale fallback, and probe deadlines. */
     discovery?: ConnectaDiscoveryConfig;
     /** Deployment-wide call deadlines and result paging threshold. */
@@ -157,9 +129,8 @@ export interface ConnectaConfig {
     execute?: ConnectaExecuteConfig;
     /** Bounded MCP and fallback code-mode admission. */
     admission?: ConnectaAdmissionConfig;
-    /** Optional browser UI and OAuth result-page labels. */
-    branding?: ConnectaBranding;
-    logger?: Logger;
+    /** Diagnostic output. Use "silent" to disable all diagnostic logging. */
+    logger?: Logger | "silent";
     serverInfo?: {
         name?: string;
         version?: string;
@@ -198,14 +169,10 @@ export { ConnectorCallError } from "./errors.js";
 export type { ConnectorCallErrorCode, CallErrorDetails } from "./errors.js";
 export { validateToolInput } from "./validate.js";
 export type { ValidateToolInputOptions } from "./validate.js";
-export { bearerToken } from "./auth/bearer.js";
-export type { BearerTokenOptions } from "./auth/bearer.js";
-export type { AccessTokenMetadata, CreatedAccessToken, } from "./access-tokens.js";
 export { memoryStorage } from "./storage/memory.js";
 export { CONNECTA_VERSION } from "./version.js";
 export type { Registry } from "./registry.js";
 export type { RemoteMcpOptions, RemoteMcpAuth, RemoteMcpRedirectPolicy, } from "./connectors/remote-mcp.js";
 export type { ApiOptions, ApiTool } from "./connectors/api.js";
-export type { CatalogDriftCounts, CatalogDriftReport, Connector, ConnectorCallAdmissionInput, ConnectorCallAdmissionPolicy, ConnectorCallAdmissionRule, ConnectorRollingWindowBudget, ConnectaBranding, ConnectorCredentialAccess, ConnectorCredentialConfig, ConnectorCredentialFieldConfig, ConnectorCredentialValues, ConnectorContext, ConnectorUsageGuide, ConnectorStatus, CredentialTestResult, AdmittingExecutor, AdmissionSnapshot, ExecuteResult, Executor, ExecutorLease, ExecutorProvider, InboundAuth, InboundAuthRuntimeContext, UiAuthConfig, AuthResult, AuthenticatedIdentity, IdentityReference, JsonSchema, KVStorage, Logger, ToolDef, ToolAnnotations, } from "./types.js";
+export type { CatalogDriftCounts, CatalogDriftReport, ConnectaBranding, Connector, ConnectorCallAdmissionInput, ConnectorCallAdmissionPolicy, ConnectorCallAdmissionRule, ConnectorRollingWindowBudget, ConnectorCredentialAccess, ConnectorCredentialConfig, ConnectorCredentialFieldConfig, ConnectorCredentialValues, ConnectorContext, ConnectorUsageGuide, ConnectorStatus, CredentialTestResult, AdmittingExecutor, AdmissionSnapshot, ExecuteResult, Executor, ExecutorLease, ExecutorProvider, InboundAuth, InboundAuthRuntimeContext, UiAuthConfig, AuthResult, AuthenticatedIdentity, IdentityReference, JsonSchema, KVStorage, Logger, ToolDef, ToolAnnotations, } from "./types.js";
 export type { ActivityActor, ActivityCallSource, ActivityOutcome, ActivityPage, ActivityReadActor, ActivityReadEvent, ActivityReader, ActivityReadGate, ActivityReadPage, ActivitySink, ActivityStore, AgentFriction, CatalogDriftActivityEvent, ToolCallActivityEvent, } from "./activity.js";
-export { InvalidActivityCursorError } from "./activity.js";

package/dist/index.js

@@ -1,8 +1,7 @@
-import { CredentialVault, credentialTestRule, describeCredentialTestMismatch, } from "./credentials.js";
-import { AccessTokenManager } from "./access-tokens.js";
+import { credentialTestRule, describeCredentialTestMismatch, } from "./credential-rules.js";
 import { Registry } from "./registry.js";
 import { createFetchHandler } from "./server.js";
-import { droppedBrandingUrls, droppedUiAuthUrls } from "./ui.js";
+import { droppedBrandingUrls, droppedUiAuthUrls } from "./branding.js";
 import { memoryStorage } from "./storage/memory.js";
 import { CONNECTA_VERSION } from "./version.js";
 import { AdmissionController, executorName, isAdmittingExecutor, withExecutorAdmission, } from "./executor-admission.js";
@@ -53,21 +52,15 @@ const CONFIG_SCHEMA = {
     auth: null,
     identity: {
         connectorAccess: null,
-        operatorAccess: null,
+        activityAccess: null,
+        credentialAdministration: null,
+        personalConnection: null,
     },
     storage: null,
     publicUrl: null,
-    activity: {
-        store: null,
-        readGate: null,
-        deploymentId: null,
-    },
-    credentials: {
-        encryptionKey: null,
-    },
-    accessTokens: {
-        maxActive: null,
-    },
+    activity: null,
+    vault: null,
+    ui: null,
     discovery: {
         concurrency: null,
         catalogTtlSeconds: null,
@@ -87,20 +80,6 @@ const CONFIG_SCHEMA = {
         requests: admissionPoolSchema,
         code: admissionPoolSchema,
     },
-    branding: {
-        productName: null,
-        productUrl: null,
-        ownerName: null,
-        ownerUrl: null,
-        description: null,
-        pageTitle: null,
-        favicon: {
-            svg: null,
-            ico: null,
-            href: null,
-        },
-        themeColor: null,
-    },
     logger: null,
     serverInfo: {
         name: null,
@@ -144,17 +123,24 @@ function rejectUnknownOptions(paths) {
     if (paths.length === 0)
         return;
     throw new Error(`Unknown Connecta configuration option${paths.length === 1 ? "" : "s"}:\n` +
-        paths.map((path) => `- ${path}`).join("\n"));
+        paths.map((path) => `- ${path}`).join("\n") +
+        (paths.includes("ConnectaConfig.credentials") ? "\nUse vault: encryptedCredentialVault(storage, key) from @zackbart/connecta/credentials." : "") +
+        (paths.includes("ConnectaConfig.accessTokens") ? "\nConnecta-issued tokens were removed. Configure an inbound auth adapter instead." : "") +
+        (paths.includes("ConnectaConfig.branding") ? "\nMove branding into ui: operatorUi({ branding }) from @zackbart/connecta/ui." : ""));
 }
 /** Reject JavaScript typos and removed options before construction does work. */
 function assertKnownConfig(config) {
     rejectUnknownOptions(unknownOptionPaths(config, "ConnectaConfig", CONFIG_SCHEMA));
+    if (config.vault && ["get", "getAll", "set", "setAll", "metadata", "delete"].some(key => typeof config.vault[key] !== "function"))
+        throw new Error("ConnectaConfig.vault must implement CredentialVault");
+    if (config.ui && (typeof config.ui.handle !== "function" || typeof config.ui.credentialHandoffUrl !== "function" || !Array.isArray(config.ui.reservedPaths)))
+        throw new Error("ConnectaConfig.ui must be created with operatorUi(...)");
     const activity = config.activity;
     if (activity !== undefined &&
         (typeof activity !== "object" ||
             activity === null ||
-            typeof activity.store?.record !== "function")) {
-        throw new Error("ConnectaConfig.activity.store must implement record(event)");
+            typeof activity.recordTool !== "function")) {
+        throw new Error("ConnectaConfig.activity must be created with activityHistory(...)");
     }
 }
 /**
@@ -171,7 +157,7 @@ function warnInsecureConfig(config, inboundAuth, logger) {
     if (inboundAuth.length === 0 &&
         (hasCredentialConnector || oauthConnectors.length > 0)) {
         logger.warn("[connecta] running with no inbound authentication: any caller can " +
-            "invoke every connector and read or overwrite stored credentials. " +
+            "invoke every shared connector. " +
             "Configure `auth` (for example bearerToken(...) or Clerk) to gate access.");
     }
     // Unset publicUrl with OAuth connectors: the downstream redirect_uri is
@@ -186,7 +172,7 @@ function warnInsecureConfig(config, inboundAuth, logger) {
     // Branding URLs that failed their scheme gate. Rendering silently falls back
     // (a bad URL must not take the page down), so this warning is the only way an
     // operator learns their value never reached the page.
-    const dropped = droppedBrandingUrls(config.branding);
+    const dropped = droppedBrandingUrls(config.ui?.branding);
     if (dropped.length > 0) {
         logger.warn(`[connecta] branding ${dropped.join(", ")} dropped: a branding URL is ` +
             "used as an href, so it must be an absolute http(s) URL (favicon.href " +
@@ -250,26 +236,11 @@ export function createConnecta(config) {
             '"@cloudflare/codemode" on Workers.');
     }
     const storage = config.storage ?? memoryStorage();
-    const logger = config.logger ?? defaultLogger();
-    const credentialConnectors = config.connectors.filter((c) => c.credential);
-    const encryptionKey = config.credentials?.encryptionKey;
-    if (credentialConnectors.length > 0 && !encryptionKey) {
-        logger.warn("Human-managed credentials are unavailable because " +
-            "credentials.encryptionKey is not configured for connectors: " +
-            credentialConnectors.map((c) => c.id).join(", "));
-    }
-    const credentialVault = encryptionKey
-        ? new CredentialVault(storage, encryptionKey)
-        : undefined;
+    const logger = config.logger === "silent"
+        ? { debug() { }, info() { }, warn() { }, error() { } }
+        : config.logger ?? defaultLogger();
+    const credentialVault = config.vault;
     const configuredAuth = normalizeAuth(config.auth);
-    const accessTokens = config.accessTokens
-        ? new AccessTokenManager(storage, config.accessTokens)
-        : undefined;
-    if (accessTokens &&
-        !configuredAuth.some((provider) => provider.interactiveOperator)) {
-        throw new Error("accessTokens requires an interactive operator auth provider: only an eligible " +
-            "operator may create, rename, or revoke deployment access tokens");
-    }
     const serverInfo = {
         ...config.serverInfo,
         name: config.serverInfo?.name ?? "connecta",
@@ -279,9 +250,11 @@ export function createConnecta(config) {
         storage,
         logger,
         credentialVault,
+        credentialUi: Boolean(config.ui),
         catalogDriftActivity: config.activity?.store
             ? {
                 sink: config.activity.store,
+                recordDrift: config.activity.recordDrift,
                 serverInfo,
                 ...(config.activity.deploymentId !== undefined
                     ? { deploymentId: config.activity.deploymentId }
@@ -293,7 +266,7 @@ export function createConnecta(config) {
         toolCatalogStaleSeconds: config.discovery?.staleCatalogSeconds,
         maxResultBytes: config.calls?.maxResultBytes,
     });
-    const inboundAuth = normalizeAuth(accessTokens ? [accessTokens.auth, ...configuredAuth] : configuredAuth);
+    const inboundAuth = configuredAuth;
     warnInsecureConfig(config, inboundAuth, logger);
     const requestAdmission = admissionController(config.admission?.requests, REQUEST_ADMISSION_DEFAULTS);
     const configuredCodeAdmission = admissionController(config.admission?.code, CODE_ADMISSION_DEFAULTS);
@@ -319,6 +292,7 @@ export function createConnecta(config) {
         serverInfo,
         logger,
         activity: config.activity?.store,
+        activityModule: config.activity,
         activityReadGate: config.activity?.readGate,
         activityDeploymentId: config.activity?.deploymentId,
         executor,
@@ -330,9 +304,9 @@ export function createConnecta(config) {
         maxEmittedBytes: config.execute?.maxEmittedBytes,
         maxEmittedBlocks: config.execute?.maxEmittedBlocks,
         credentialVault,
-        accessTokens,
+        ui: config.ui,
         deploymentInfo: config.deploymentInfo,
-        branding: config.branding,
+        branding: config.ui?.branding,
     });
     let closePromise;
     return {
@@ -358,7 +332,5 @@ export { ConnectorCallError } from "./errors.js";
 // implement the Connector interface directly. Returns the error rather than
 // throwing so the caller decides what to do with it.
 export { validateToolInput } from "./validate.js";
-export { bearerToken } from "./auth/bearer.js";
 export { memoryStorage } from "./storage/memory.js";
 export { CONNECTA_VERSION } from "./version.js";
-export { InvalidActivityCursorError } from "./activity.js";

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 {};