@zackbart/connecta 0.22.3 → 0.24.0

package/dist/catalog-service.js

@@ -336,59 +336,6 @@ export class CatalogService {
             catalogMs: Date.now() - started,
         };
     }
-    /**
-     * Resolve the JavaScript-safe property used by a lazy code-mode namespace
-     * back to exactly one catalog tool. Ambiguous aliases fail with an explicit
-     * escape hatch instead of silently choosing the first tool.
-     */
-    async resolveToolAlias(connectorId, alias, aliasFor, callOptions = {}) {
-        const connector = this.registry.getConnector(connectorId);
-        if (!connector) {
-            return this.unknownAddressFailure(`${connectorId}.${alias}`, alias);
-        }
-        const started = Date.now();
-        let tools;
-        try {
-            tools = await this.loadConnector(connector.id, callOptions);
-        }
-        catch (cause) {
-            return this.catalogLoadFailure(cause, started, connector, alias);
-        }
-        const [definition, ...collisions] = tools.filter((tool) => aliasFor(tool.name) === alias);
-        if (!definition) {
-            return this.unknownToolFailure(alias, connector, started);
-        }
-        if (collisions.length > 0) {
-            const names = [definition, ...collisions]
-                .map((tool) => `"${tool.name}"`)
-                .join(", ");
-            return {
-                ok: false,
-                error: {
-                    code: "ambiguous_tool_alias",
-                    message: `Tool alias "${boundedEchoText(alias)}" is ambiguous on connector "${connector.id}" because ${names} sanitize to the same name. Use connecta.call with an exact address.`,
-                    retryable: false,
-                    nextAction: {
-                        function: "connecta.call",
-                        addresses: [definition, ...collisions].map((tool) => `${connector.id}.${tool.name}`),
-                        purpose: "Choose the intended canonical address and call it with the original arguments.",
-                    },
-                },
-                catalogMs: Date.now() - started,
-                connector,
-                toolName: alias,
-            };
-        }
-        return {
-            ok: true,
-            resolved: {
-                connector,
-                toolName: definition.name,
-                definition,
-            },
-            catalogMs: Date.now() - started,
-        };
-    }
     async search(args) {
         const query = args.query ?? "";
         const retrievalQuery = lexicalSearchQuery(query);
@@ -894,6 +841,9 @@ export function flatSearchResult(page) {
     return {
         tools: page.entries.map((entry) => ({
             ...entry.tool,
+            ...(entry.connector.title
+                ? { connectorTitle: boundedEchoText(entry.connector.title.replace(/\s+/g, " ").trim(), 117) }
+                : {}),
             ...(entry.guide ? { guide: entry.guide } : {}),
             ...(entry.guideSummary
                 ? { guideSummary: entry.guideSummary }

package/dist/connectors/remote-mcp.js

@@ -505,7 +505,7 @@ export function remoteMcp(id, opts) {
     const newProvider = (ctx, state) => {
         if (state?.provider)
             return state.provider;
-        const provider = new KvOAuthProvider(id, ctx.storage, `${ctx.baseUrl}/oauth/callback/${id}`, refreshCoordinator);
+        const provider = new KvOAuthProvider(id, ctx.storage, `${ctx.baseUrl}/oauth/callback/${id}`, refreshCoordinator, ctx.allowAuthorization === true);
         if (state)
             state.provider = provider;
         return provider;
@@ -1025,12 +1025,8 @@ export function remoteMcp(id, opts) {
                     // Only an OAuth connector has a pending consent URL to offer. A
                     // credential connector's downstream 401 is repaired on /credentials,
                     // so do not reach into OAuth storage to look for one.
-                    const url = isOauth
-                        ? await newProvider(ctx, state).pendingAuthorizationUrl()
-                        : undefined;
                     return {
                         state: "auth_required",
-                        ...(url !== undefined ? { authorizationUrl: url } : {}),
                         message: credentialAuth
                             ? "Authorization required — the downstream rejected this connector's stored credential."
                             : "Authorization required — open the URL to connect.",
@@ -1070,7 +1066,9 @@ export function remoteMcp(id, opts) {
             await disconnectAuthorization(ctx, stateFor(ctx), true);
         };
         connector.startAuth = async (ctx, startOpts) => {
+            ctx = { ...ctx, requestScope: ctx.requestScope ?? ctx, allowAuthorization: true };
             const state = stateFor(ctx);
+            state.provider = null;
             const p = newProvider(ctx, state);
             if (startOpts?.force || (await p.operatorDisconnected())) {
                 await disconnectAuthorization(ctx, state);

package/dist/credential-contract.d.ts

@@ -0,0 +1,24 @@
+import type { ConnectorCredentialValues } from "./types.js";
+interface CredentialFieldMetadata {
+    configured: true;
+    /** Only emitted when the value is long enough that four chars don't leak much. */
+    lastFour?: string;
+    updatedAt: string;
+}
+export interface CredentialMetadata {
+    configured: true;
+    /** Backward-compatible metadata for the reserved single credential field. */
+    lastFour?: string;
+    updatedAt: string;
+    /** Per-field masked metadata for named multi-value credentials. */
+    fields?: Record<string, CredentialFieldMetadata>;
+}
+export interface CredentialVault {
+    get(connectorId: string, field?: string, owner?: string): Promise<string | null>;
+    getAll(connectorId: string, owner?: string): Promise<ConnectorCredentialValues | null>;
+    metadata(connectorId: string, owner?: string): Promise<CredentialMetadata | null>;
+    set(connectorId: string, value: string, updatedBy: string, owner?: string): Promise<CredentialMetadata>;
+    setAll(connectorId: string, values: ConnectorCredentialValues, updatedBy: string, owner?: string): Promise<CredentialMetadata>;
+    delete(connectorId: string, owner?: string): Promise<void>;
+}
+export {};

package/dist/credential-contract.js

@@ -0,0 +1 @@
+export {};

package/dist/credential-rules.d.ts

@@ -0,0 +1,85 @@
+import type { Connector, ConnectorCredentialConfig } from "./types.js";
+/** Which hook a testable credential is checked with. */
+type CredentialTestMode = "single" | "multiple";
+/** Operator-safe explanation shared by every surface that detects shape drift. */
+export declare const STORED_CREDENTIAL_SHAPE_MISMATCH_ERROR = "Stored credential fields do not match this connector's current declaration. Replace the credential before using or testing this connector.";
+export type StoredCredentialShape = {
+    state: "missing";
+} | {
+    state: "valid";
+    mode: CredentialTestMode;
+    /**
+     * Stored keys the connector no longer declares, sorted. Harmless — the
+     * credential works — but worth telling an operator about, since nothing
+     * else in `/ui` can show a field the declaration has stopped naming.
+     */
+    undeclared: string[];
+} | {
+    state: "mismatch";
+    mode: CredentialTestMode;
+    message: typeof STORED_CREDENTIAL_SHAPE_MISMATCH_ERROR;
+};
+/**
+ * Compare a connector's current declaration with the keys in its stored
+ * credential. Values are deliberately ignored: callers may pass decrypted
+ * values or `/credentials`' masked field metadata and get the same answer.
+ *
+ * The test is CONTAINMENT, not equality: the stored key set is compatible when
+ * it holds every field currently declared — the reserved `value` key for a
+ * single-value declaration, every declared name for a named one. Anything the
+ * declaration asks for and the vault does not have is `mismatch`, which is
+ * precisely what a renamed field, a newly added field, or a swap between the
+ * two shapes produces. The swap needs no special case: `value` is never one of
+ * the declared names, so single→named and named→single each leave the declared
+ * side unsatisfied. An empty stored map (reachable through a hand-written
+ * plaintext) satisfies nothing and is a mismatch too.
+ *
+ * Extra keys are NOT drift. They are what *dropping* a field leaves behind, and
+ * every accessor a connector actually uses — `ctx.credential.get("apiKey")`,
+ * `getAll().apiKey` — keeps returning the right secret across that redeploy.
+ * Calling it drift would order an operator to re-enter a working secret that
+ * many providers will not reissue in readable form. The leftovers come back as
+ * `undeclared` instead, for a surface to mention without blocking anything.
+ */
+export declare function storedCredentialShape(config: ConnectorCredentialConfig, stored: Readonly<Record<string, unknown>> | null): StoredCredentialShape;
+/**
+ * The one sentence describing leftover stored fields, so every surface words it
+ * the same way. Names only — the values stay in the vault, and a field name from
+ * a previous declaration is not a secret. Deliberately reassuring: nothing is
+ * broken, and the only thing an operator gains by acting is that a connector
+ * iterating `getAll()` stops seeing a field its code no longer knows about.
+ */
+export declare function describeUndeclaredCredentialFields(fields: string[]): string;
+/** A declared credential shape whose only test hook cannot test it. */
+export interface CredentialTestMismatch {
+    /** The shape the connector declared. */
+    shape: CredentialTestMode;
+    /** The hook it implements, which that shape cannot use. */
+    hook: "testCredential" | "testCredentials";
+}
+export interface CredentialTestRule {
+    /** The hook to call, or null when this credential cannot be tested at all. */
+    mode: CredentialTestMode | null;
+    /** Set only when the sole implemented hook is the one the shape cannot use. */
+    mismatch?: CredentialTestMismatch;
+}
+/**
+ * The one rule deciding whether a connector's credential can be tested — read
+ * by /credentials' `testable` flag, by `POST /ui/credentials/<id>/test` when
+ * it picks a hook, and by the construction-time mismatch warning, so those
+ * three cannot drift apart.
+ *
+ * The declared credential *shape* selects the hook: named `credential.fields`
+ * are tested as a set by `testCredentials`, a single-value `credential` by
+ * `testCredential` on the vault's reserved `value` field. The other hook is
+ * never substituted — it would be handed a shape the connector never declared —
+ * so a connector implementing only the mismatched hook is not testable, and
+ * says so at construction rather than under an operator's click.
+ */
+export declare function credentialTestRule(connector: Pick<Connector, "credential" | "testCredential" | "testCredentials">): CredentialTestRule;
+/**
+ * One clause naming a mismatch, shared by the startup warning and the test
+ * route's 400 so an operator reads the same explanation in both places.
+ */
+export declare function describeCredentialTestMismatch(mismatch: CredentialTestMismatch): string;
+export {};

package/dist/credential-rules.js

@@ -0,0 +1,107 @@
+/** Operator-safe explanation shared by every surface that detects shape drift. */
+export const STORED_CREDENTIAL_SHAPE_MISMATCH_ERROR = "Stored credential fields do not match this connector's current declaration. Replace the credential before using or testing this connector.";
+/**
+ * Compare a connector's current declaration with the keys in its stored
+ * credential. Values are deliberately ignored: callers may pass decrypted
+ * values or `/credentials`' masked field metadata and get the same answer.
+ *
+ * The test is CONTAINMENT, not equality: the stored key set is compatible when
+ * it holds every field currently declared — the reserved `value` key for a
+ * single-value declaration, every declared name for a named one. Anything the
+ * declaration asks for and the vault does not have is `mismatch`, which is
+ * precisely what a renamed field, a newly added field, or a swap between the
+ * two shapes produces. The swap needs no special case: `value` is never one of
+ * the declared names, so single→named and named→single each leave the declared
+ * side unsatisfied. An empty stored map (reachable through a hand-written
+ * plaintext) satisfies nothing and is a mismatch too.
+ *
+ * Extra keys are NOT drift. They are what *dropping* a field leaves behind, and
+ * every accessor a connector actually uses — `ctx.credential.get("apiKey")`,
+ * `getAll().apiKey` — keeps returning the right secret across that redeploy.
+ * Calling it drift would order an operator to re-enter a working secret that
+ * many providers will not reissue in readable form. The leftovers come back as
+ * `undeclared` instead, for a surface to mention without blocking anything.
+ */
+export function storedCredentialShape(config, stored) {
+    if (!stored)
+        return { state: "missing" };
+    const mode = config.fields?.length
+        ? "multiple"
+        : "single";
+    const declared = new Set(mode === "multiple" ? config.fields.map((field) => field.name) : ["value"]);
+    const actual = Object.keys(stored);
+    const present = new Set(actual);
+    for (const field of declared) {
+        if (!present.has(field)) {
+            return {
+                state: "mismatch",
+                mode,
+                message: STORED_CREDENTIAL_SHAPE_MISMATCH_ERROR,
+            };
+        }
+    }
+    return {
+        state: "valid",
+        mode,
+        undeclared: actual.filter((field) => !declared.has(field)).sort(),
+    };
+}
+/** How many leftover field names an advisory names before it summarizes. */
+const UNDECLARED_SAMPLE = 5;
+/**
+ * The one sentence describing leftover stored fields, so every surface words it
+ * the same way. Names only — the values stay in the vault, and a field name from
+ * a previous declaration is not a secret. Deliberately reassuring: nothing is
+ * broken, and the only thing an operator gains by acting is that a connector
+ * iterating `getAll()` stops seeing a field its code no longer knows about.
+ */
+export function describeUndeclaredCredentialFields(fields) {
+    const shown = fields.slice(0, UNDECLARED_SAMPLE);
+    const rest = fields.length - shown.length;
+    const named = shown.join(", ") + (rest > 0 ? `, and ${rest} more` : "");
+    return fields.length === 1
+        ? `Stored credential also holds a field this connector no longer declares (${named}). It keeps working; replace the credential to drop it.`
+        : `Stored credential also holds fields this connector no longer declares (${named}). It keeps working; replace the credential to drop them.`;
+}
+/**
+ * The one rule deciding whether a connector's credential can be tested — read
+ * by /credentials' `testable` flag, by `POST /ui/credentials/<id>/test` when
+ * it picks a hook, and by the construction-time mismatch warning, so those
+ * three cannot drift apart.
+ *
+ * The declared credential *shape* selects the hook: named `credential.fields`
+ * are tested as a set by `testCredentials`, a single-value `credential` by
+ * `testCredential` on the vault's reserved `value` field. The other hook is
+ * never substituted — it would be handed a shape the connector never declared —
+ * so a connector implementing only the mismatched hook is not testable, and
+ * says so at construction rather than under an operator's click.
+ */
+export function credentialTestRule(connector) {
+    if (!connector.credential)
+        return { mode: null };
+    if (connector.credential.fields?.length) {
+        if (connector.testCredentials)
+            return { mode: "multiple" };
+        return connector.testCredential
+            ? { mode: null, mismatch: { shape: "multiple", hook: "testCredential" } }
+            : { mode: null };
+    }
+    if (connector.testCredential)
+        return { mode: "single" };
+    return connector.testCredentials
+        ? { mode: null, mismatch: { shape: "single", hook: "testCredentials" } }
+        : { mode: null };
+}
+/**
+ * One clause naming a mismatch, shared by the startup warning and the test
+ * route's 400 so an operator reads the same explanation in both places.
+ */
+export function describeCredentialTestMismatch(mismatch) {
+    return mismatch.shape === "multiple"
+        ? "it declares named credential fields, which only " +
+            "`testCredentials(values, ctx)` can test, but implements " +
+            "`testCredential`"
+        : "it declares a single-value credential, which only " +
+            "`testCredential(value, ctx)` can test, but implements " +
+            "`testCredentials`";
+}

package/dist/credentials.d.ts

@@ -1,107 +1,11 @@
-import type { Connector, ConnectorCredentialConfig, ConnectorCredentialValues, KVStorage } from "./types.js";
-interface CredentialFieldMetadata {
-    configured: true;
-    /** Only emitted when the value is long enough that four chars don't leak much. */
-    lastFour?: string;
-    updatedAt: string;
-}
-export interface CredentialMetadata {
-    configured: true;
-    /** Backward-compatible metadata for the reserved single credential field. */
-    lastFour?: string;
-    updatedAt: string;
-    /** Per-field masked metadata for named multi-value credentials. */
-    fields?: Record<string, CredentialFieldMetadata>;
-}
-/** Which hook a testable credential is checked with. */
-type CredentialTestMode = "single" | "multiple";
-/** Operator-safe explanation shared by every surface that detects shape drift. */
-export declare const STORED_CREDENTIAL_SHAPE_MISMATCH_ERROR = "Stored credential fields do not match this connector's current declaration. Replace the credential before using or testing this connector.";
-export type StoredCredentialShape = {
-    state: "missing";
-} | {
-    state: "valid";
-    mode: CredentialTestMode;
-    /**
-     * Stored keys the connector no longer declares, sorted. Harmless — the
-     * credential works — but worth telling an operator about, since nothing
-     * else in `/ui` can show a field the declaration has stopped naming.
-     */
-    undeclared: string[];
-} | {
-    state: "mismatch";
-    mode: CredentialTestMode;
-    message: typeof STORED_CREDENTIAL_SHAPE_MISMATCH_ERROR;
-};
-/**
- * Compare a connector's current declaration with the keys in its stored
- * credential. Values are deliberately ignored: callers may pass decrypted
- * values or `/credentials`' masked field metadata and get the same answer.
- *
- * The test is CONTAINMENT, not equality: the stored key set is compatible when
- * it holds every field currently declared — the reserved `value` key for a
- * single-value declaration, every declared name for a named one. Anything the
- * declaration asks for and the vault does not have is `mismatch`, which is
- * precisely what a renamed field, a newly added field, or a swap between the
- * two shapes produces. The swap needs no special case: `value` is never one of
- * the declared names, so single→named and named→single each leave the declared
- * side unsatisfied. An empty stored map (reachable through a hand-written
- * plaintext) satisfies nothing and is a mismatch too.
- *
- * Extra keys are NOT drift. They are what *dropping* a field leaves behind, and
- * every accessor a connector actually uses — `ctx.credential.get("apiKey")`,
- * `getAll().apiKey` — keeps returning the right secret across that redeploy.
- * Calling it drift would order an operator to re-enter a working secret that
- * many providers will not reissue in readable form. The leftovers come back as
- * `undeclared` instead, for a surface to mention without blocking anything.
- */
-export declare function storedCredentialShape(config: ConnectorCredentialConfig, stored: Readonly<Record<string, unknown>> | null): StoredCredentialShape;
-/**
- * The one sentence describing leftover stored fields, so every surface words it
- * the same way. Names only — the values stay in the vault, and a field name from
- * a previous declaration is not a secret. Deliberately reassuring: nothing is
- * broken, and the only thing an operator gains by acting is that a connector
- * iterating `getAll()` stops seeing a field its code no longer knows about.
- */
-export declare function describeUndeclaredCredentialFields(fields: string[]): string;
-/** A declared credential shape whose only test hook cannot test it. */
-export interface CredentialTestMismatch {
-    /** The shape the connector declared. */
-    shape: CredentialTestMode;
-    /** The hook it implements, which that shape cannot use. */
-    hook: "testCredential" | "testCredentials";
-}
-export interface CredentialTestRule {
-    /** The hook to call, or null when this credential cannot be tested at all. */
-    mode: CredentialTestMode | null;
-    /** Set only when the sole implemented hook is the one the shape cannot use. */
-    mismatch?: CredentialTestMismatch;
-}
-/**
- * The one rule deciding whether a connector's credential can be tested — read
- * by /credentials' `testable` flag, by `POST /ui/credentials/<id>/test` when
- * it picks a hook, and by the construction-time mismatch warning, so those
- * three cannot drift apart.
- *
- * The declared credential *shape* selects the hook: named `credential.fields`
- * are tested as a set by `testCredentials`, a single-value `credential` by
- * `testCredential` on the vault's reserved `value` field. The other hook is
- * never substituted — it would be handed a shape the connector never declared —
- * so a connector implementing only the mismatched hook is not testable, and
- * says so at construction rather than under an operator's click.
- */
-export declare function credentialTestRule(connector: Pick<Connector, "credential" | "testCredential" | "testCredentials">): CredentialTestRule;
-/**
- * One clause naming a mismatch, shared by the startup warning and the test
- * route's 400 so an operator reads the same explanation in both places.
- */
-export declare function describeCredentialTestMismatch(mismatch: CredentialTestMismatch): string;
+import type { CredentialMetadata, CredentialVault as Vault } from "./credential-contract.js";
+import type { ConnectorCredentialValues, KVStorage } from "./types.js";
 /**
  * Encrypted, connector-scoped credential vault over the deployment's existing
  * KVStorage. Only ciphertext enters KV; the AES-GCM key remains an environment
  * secret outside the store.
  */
-export declare class CredentialVault {
+export declare class CredentialVault implements Vault {
     private readonly storage;
     private readonly key;
     constructor(storage: KVStorage, encryptionKey: string);
@@ -114,4 +18,4 @@ export declare class CredentialVault {
     setAll(connectorId: string, values: ConnectorCredentialValues, updatedBy: string, owner?: string): Promise<CredentialMetadata>;
     delete(connectorId: string, owner?: string): Promise<void>;
 }
-export {};
+export declare function encryptedCredentialVault(storage: KVStorage, encryptionKey: string): Vault;

package/dist/credentials.js

@@ -3,113 +3,6 @@ const IV_BYTES = 12;
 const MAX_CREDENTIAL_BYTES = 16_384;
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
-/** Operator-safe explanation shared by every surface that detects shape drift. */
-export const STORED_CREDENTIAL_SHAPE_MISMATCH_ERROR = "Stored credential fields do not match this connector's current declaration. Replace the credential before using or testing this connector.";
-/**
- * Compare a connector's current declaration with the keys in its stored
- * credential. Values are deliberately ignored: callers may pass decrypted
- * values or `/credentials`' masked field metadata and get the same answer.
- *
- * The test is CONTAINMENT, not equality: the stored key set is compatible when
- * it holds every field currently declared — the reserved `value` key for a
- * single-value declaration, every declared name for a named one. Anything the
- * declaration asks for and the vault does not have is `mismatch`, which is
- * precisely what a renamed field, a newly added field, or a swap between the
- * two shapes produces. The swap needs no special case: `value` is never one of
- * the declared names, so single→named and named→single each leave the declared
- * side unsatisfied. An empty stored map (reachable through a hand-written
- * plaintext) satisfies nothing and is a mismatch too.
- *
- * Extra keys are NOT drift. They are what *dropping* a field leaves behind, and
- * every accessor a connector actually uses — `ctx.credential.get("apiKey")`,
- * `getAll().apiKey` — keeps returning the right secret across that redeploy.
- * Calling it drift would order an operator to re-enter a working secret that
- * many providers will not reissue in readable form. The leftovers come back as
- * `undeclared` instead, for a surface to mention without blocking anything.
- */
-export function storedCredentialShape(config, stored) {
-    if (!stored)
-        return { state: "missing" };
-    const mode = config.fields?.length
-        ? "multiple"
-        : "single";
-    const declared = new Set(mode === "multiple" ? config.fields.map((field) => field.name) : ["value"]);
-    const actual = Object.keys(stored);
-    const present = new Set(actual);
-    for (const field of declared) {
-        if (!present.has(field)) {
-            return {
-                state: "mismatch",
-                mode,
-                message: STORED_CREDENTIAL_SHAPE_MISMATCH_ERROR,
-            };
-        }
-    }
-    return {
-        state: "valid",
-        mode,
-        undeclared: actual.filter((field) => !declared.has(field)).sort(),
-    };
-}
-/** How many leftover field names an advisory names before it summarizes. */
-const UNDECLARED_SAMPLE = 5;
-/**
- * The one sentence describing leftover stored fields, so every surface words it
- * the same way. Names only — the values stay in the vault, and a field name from
- * a previous declaration is not a secret. Deliberately reassuring: nothing is
- * broken, and the only thing an operator gains by acting is that a connector
- * iterating `getAll()` stops seeing a field its code no longer knows about.
- */
-export function describeUndeclaredCredentialFields(fields) {
-    const shown = fields.slice(0, UNDECLARED_SAMPLE);
-    const rest = fields.length - shown.length;
-    const named = shown.join(", ") + (rest > 0 ? `, and ${rest} more` : "");
-    return fields.length === 1
-        ? `Stored credential also holds a field this connector no longer declares (${named}). It keeps working; replace the credential to drop it.`
-        : `Stored credential also holds fields this connector no longer declares (${named}). It keeps working; replace the credential to drop them.`;
-}
-/**
- * The one rule deciding whether a connector's credential can be tested — read
- * by /credentials' `testable` flag, by `POST /ui/credentials/<id>/test` when
- * it picks a hook, and by the construction-time mismatch warning, so those
- * three cannot drift apart.
- *
- * The declared credential *shape* selects the hook: named `credential.fields`
- * are tested as a set by `testCredentials`, a single-value `credential` by
- * `testCredential` on the vault's reserved `value` field. The other hook is
- * never substituted — it would be handed a shape the connector never declared —
- * so a connector implementing only the mismatched hook is not testable, and
- * says so at construction rather than under an operator's click.
- */
-export function credentialTestRule(connector) {
-    if (!connector.credential)
-        return { mode: null };
-    if (connector.credential.fields?.length) {
-        if (connector.testCredentials)
-            return { mode: "multiple" };
-        return connector.testCredential
-            ? { mode: null, mismatch: { shape: "multiple", hook: "testCredential" } }
-            : { mode: null };
-    }
-    if (connector.testCredential)
-        return { mode: "single" };
-    return connector.testCredentials
-        ? { mode: null, mismatch: { shape: "single", hook: "testCredentials" } }
-        : { mode: null };
-}
-/**
- * One clause naming a mismatch, shared by the startup warning and the test
- * route's 400 so an operator reads the same explanation in both places.
- */
-export function describeCredentialTestMismatch(mismatch) {
-    return mismatch.shape === "multiple"
-        ? "it declares named credential fields, which only " +
-            "`testCredentials(values, ctx)` can test, but implements " +
-            "`testCredential`"
-        : "it declares a single-value credential, which only " +
-            "`testCredential(value, ctx)` can test, but implements " +
-            "`testCredentials`";
-}
 function storageKey(connectorId, owner) {
     return owner
         ? `principal:${owner}:conn:${connectorId}:credential:v1`
@@ -290,3 +183,6 @@ export class CredentialVault {
         await this.storage.delete(storageKey(connectorId, owner));
     }
 }
+export function encryptedCredentialVault(storage, encryptionKey) {
+    return new CredentialVault(storage, encryptionKey);
+}

package/dist/errors.d.ts

@@ -74,7 +74,7 @@ export declare class ConnectorCallError extends Error {
         validation?: ArgumentValidationDetails;
     });
 }
-/** The `error` object surfaced in value-mode call results and connecta.batch entries. */
+/** The `error` object surfaced in value-mode call results and rejected promises. */
 export interface CallErrorDetails {
     code: string;
     message: string;