@zackbart/connecta 0.40.0 → 0.42.0

package/dist/http/hatch.js

@@ -25,6 +25,8 @@ import { Integer, isMaxChars, isMinChars } from "./json-schema.js";
 import { boundCursor, StandardPage } from "./paging.js";
 import { Classification, Dispatches, IdempotencyKey, RequestSecrets, Signal } from "./services.js";
 import { read, write } from "./tools.js";
+/** A page that reports more data it cannot continue must never read as the complete answer. */
+const CONTINUATION_WITHHELD = "This result is incomplete: more data exists and continuation was withheld.";
 const indexedOperations = new WeakMap();
 function operationsOf(index) {
     let operations = indexedOperations.get(index);
@@ -204,7 +206,7 @@ export function hatch(options) {
         }
         return fieldsInput(fieldsNote(first ?? preferred));
     };
-    const fieldsNote = (example) => fieldsDescription("data", example, `Copy declared paths from ${name}_api_details response.fields. Applied after value safety and privacy filtering.`);
+    const fieldsNote = (example) => fieldsDescription("data", example, `Copy declared paths from ${name}_api_details response.fields. A withheld value reads "[redacted]".`);
     const verdictOf = (op) => verdicts.get(`${op.method} ${op.path}`) ?? "refuse";
     const refusalOf = (op) => connection.safety.refusal?.({ method: op.method, template: op.path }) ?? options.binding?.refusal?.(op);
     const discoveryRefusals = new Map();
@@ -259,7 +261,7 @@ export function hatch(options) {
             }
             : {}),
         warnings: Schema.optionalKey(Schema.Array(Schema.String).annotate({
-            description: `${options.binding?.warnings ? "Reviewed warnings preserved after fields selection, and " : ""}fields entries that matched nothing in this nonempty response, with the properties declared where matching stopped. At most 10 warnings of 512 characters, then an omitted count.`,
+            description: `${options.binding?.warnings ? "Reviewed warnings preserved after fields selection, and " : ""}fields entries that matched nothing in this nonempty response, with the properties declared where matching stopped${pages.size ? ", and a notice when continuation was withheld" : ""}. At most 10 warnings of 512 characters, then an omitted count.`,
         })),
     });
     const hasTotals = [...pages.values()].some((adapters) => adapters.some((adapter) => adapter.total !== undefined));
@@ -268,11 +270,14 @@ export function hatch(options) {
             ...callEnvelope.fields,
             page: Schema.optionalKey(Schema.Struct({
                 ...StandardPage.fields,
+                hasMore: Schema.Boolean.annotate({
+                    description: "True without nextCursor means this data is incomplete and continuation was withheld.",
+                }),
                 ...(hasTotals ? { total: Schema.optionalKey(Integer.check(Schema.isGreaterThanOrEqualTo(0))) } : {}),
                 param: Schema.String.annotate({
                     description: options.pageCursor === "argument"
                         ? "Vendor parameter restored from cursor; pass nextCursor as the top-level cursor."
-                        : "Put nextCursor in this vendor parameter, unchanged.",
+                        : "Put nextCursor unchanged in query[param] or body[param], as page.in says, and keep every other argument.",
                 }),
                 in: Schema.Literals(["query", "body"]),
             })),
@@ -1171,6 +1176,8 @@ export function hatch(options) {
         const send = options.binding
             ? options.binding.send(call(), sendOptions)
             : connection.sendPath(request, sendOptions);
+        // Both send paths share the binding result contract. Keep its optional
+        // metadata typed even when the plain HTTP branch omits those properties.
         const answer = yield* send.pipe(Effect.catch((failure) => Effect.gen(function* () {
             if (!key || args.idempotencyKey)
                 return yield* Effect.fail(failure);
@@ -1221,6 +1228,7 @@ export function hatch(options) {
         // Roots were checked before dispatch; the pinned index cannot say whether a
         // deeper level is closed, so a nested miss is reported, never refused.
         const warnings = boundWarnings([
+            ...(page?.hasMore && page.nextCursor === undefined ? [CONTINUATION_WITHHELD] : []),
             ...(options.binding?.warnings && "warnings" in answer ? (answer.warnings ?? []) : []),
             ...fieldsMisses(answered, args.fields, index
                 .fields(op)

package/dist/http/node-transport.js

@@ -1,9 +1,68 @@
 // Node-only: owned undici dispatcher and Node stream adapters, reached via /node.
+import { Resolver } from "node:dns/promises";
+import { learnedDestination } from "../guarded-transport.js";
+import { learnedUrlRefusal } from "../url-safety.js";
+import { OAuthRequestNotSentError } from "../auth/oauth-request-not-sent.js";
 import { Readable } from "node:stream";
 import { isIP } from "node:net";
 import { createBrotliDecompress, createGunzip, createInflate } from "node:zlib";
 import { Client, ProxyAgent } from "undici";
 import { ConnectorCallError } from "../errors.js";
+/** Each lookup owns its DNS channels; cancellation closes them before returning. */
+async function resolveAddresses(hostname, signal) {
+    const resolver = new Resolver();
+    const cancel = () => resolver.cancel();
+    signal.throwIfAborted();
+    signal.addEventListener("abort", cancel, { once: true });
+    try {
+        const results = await Promise.allSettled([resolver.resolve4(hostname), resolver.resolve6(hostname)]);
+        signal.throwIfAborted();
+        for (const result of results) {
+            if (result.status === "rejected" && !["ENODATA", "ENOTFOUND"].includes(result.reason?.code))
+                throw result.reason;
+        }
+        return results.flatMap((result, index) => result.status === "fulfilled" ? result.value.map((address) => ({ address, family: index === 0 ? 4 : 6 })) : []);
+    }
+    finally {
+        signal.removeEventListener("abort", cancel);
+        resolver.cancel();
+    }
+}
+/** Observe even a misbehaving injected resolver, without holding the request open. */
+async function boundedLookup(lookup, hostname, requestSignal) {
+    const controller = new AbortController();
+    const abort = () => controller.abort(requestSignal?.reason);
+    const timer = setTimeout(() => controller.abort(new Error("DNS resolution timed out.")), 10_000);
+    requestSignal?.addEventListener("abort", abort, { once: true });
+    let onAbort;
+    let resolution;
+    try {
+        if (requestSignal?.aborted)
+            abort();
+        controller.signal.throwIfAborted();
+        resolution = lookup(hostname, controller.signal);
+        return await Promise.race([
+            resolution,
+            new Promise((_, reject) => {
+                onAbort = () => reject(controller.signal.reason);
+                controller.signal.addEventListener("abort", onAbort, { once: true });
+                if (controller.signal.aborted)
+                    onAbort();
+            }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+        requestSignal?.removeEventListener("abort", abort);
+        if (onAbort)
+            controller.signal.removeEventListener("abort", onAbort);
+        controller.abort();
+        // Drain the owned resolver after cancelling its channels (INV-7). Test
+        // injections may ignore cancellation, but cannot hold send() open.
+        if (lookup === resolveAddresses)
+            await resolution?.catch(() => { });
+    }
+}
 /** Pull-based bridge: Node 22's Readable.toWeb can enqueue after Web cancellation. */
 function responseBody(body, signal) {
     const chunks = body[Symbol.asyncIterator]();
@@ -43,7 +102,7 @@ function responseBody(body, signal) {
  * HTTP/2 REFUSED_STREAM and pipeline recovery paths, for every method.
  * The response/abort owns the client until the body ends or is cancelled.
  */
-export function createNodeGuardedTransport(proxy) {
+export function createNodeGuardedTransport(proxy, lookup = resolveAddresses) {
     let proxyUri;
     let proxyToken;
     if (proxy !== undefined) {
@@ -68,7 +127,41 @@ export function createNodeGuardedTransport(proxy) {
     return {
         delaysDispatch: true,
         async send(url, init, beforeDispatch = () => { }) {
+            const configured = init[learnedDestination];
+            let pinned;
+            if (configured && url.origin !== configured.origin) {
+                const refuse = () => new OAuthRequestNotSentError("connector_call_failed", "The learned URL resolved to an unsafe destination; nothing was sent.", { retryable: false });
+                if (learnedUrlRefusal(configured, url))
+                    throw refuse();
+                const hostname = url.hostname.replace(/^\[|\]$/g, "");
+                let addresses;
+                try {
+                    addresses = isIP(hostname)
+                        ? [{ address: hostname, family: isIP(hostname) }]
+                        : await boundedLookup(lookup, hostname, init.signal);
+                }
+                catch {
+                    init.signal?.throwIfAborted();
+                    throw refuse();
+                }
+                init.signal?.throwIfAborted();
+                if (addresses.length === 0 ||
+                    addresses.some(({ address, family }) => {
+                        if (!isIP(address) || isIP(address) !== family)
+                            return true;
+                        const resolved = new URL(url);
+                        resolved.hostname = family === 6 ? `[${address}]` : address;
+                        return learnedUrlRefusal(configured, resolved) !== undefined;
+                    }))
+                    throw refuse();
+                pinned = addresses[0];
+            }
+            const destination = new URL(url);
+            if (pinned && proxyUri)
+                destination.hostname = pinned.family === 6 ? `[${pinned.address}]` : pinned.address;
             const framed = new Request(url, init);
+            if (pinned)
+                framed.headers.set("host", url.host);
             if (!framed.headers.has("user-agent"))
                 framed.headers.set("user-agent", "connecta");
             let dispatched = false;
@@ -86,6 +179,7 @@ export function createNodeGuardedTransport(proxy) {
                     uri: proxyUri,
                     ...(proxyToken ? { token: proxyToken } : {}),
                     proxyTunnel: true,
+                    ...(pinned ? { requestTls: { servername: isIP(url.hostname) ? "" : url.hostname } } : {}),
                     ...clientOptions,
                     interceptors: { Agent: [], Client: [] },
                     // Neither side of CONNECT uses a Pool, interceptor or global dispatcher.
@@ -99,7 +193,7 @@ export function createNodeGuardedTransport(proxy) {
                                 // ProxyAgent 6 explicitly sets SNI to the proxy hostname.
                                 // Node 26 rejects IP SNI. Omit it for literal IPs; tls.connect
                                 // still checks the certificate against its connection host.
-                                connect({ ...parameters, ...(name && isIP(name.replace(/^\[|\]$/g, "")) ? { servername: "" } : {}) }, callback);
+                                connect({ ...parameters, ...(name ? { servername: isIP(name.replace(/^\[|\]$/g, "")) ? "" : name } : {}) }, callback);
                             },
                         }));
                     },
@@ -135,7 +229,19 @@ export function createNodeGuardedTransport(proxy) {
                         });
                     },
                 })
-                : new Client(url.origin, clientOptions);
+                : new Client(url.origin, {
+                    ...clientOptions,
+                    ...(pinned
+                        ? {
+                            connect: {
+                                // No second resolver can replace the checked address. The Client
+                                // retains the URL hostname for SNI and certificate verification.
+                                lookup: (_hostname, _options, callback) => callback(null, pinned.address, pinned.family),
+                                autoSelectFamily: false,
+                            },
+                        }
+                        : {}),
+                });
             const destroy = () => Promise.allSettled([tunnelClient?.destroy(), client.destroy()]);
             const abort = () => {
                 void destroy();
@@ -146,7 +252,7 @@ export function createNodeGuardedTransport(proxy) {
                 if (!proxyUri)
                     dispatch();
                 const answer = await client.request({
-                    origin: url.origin,
+                    origin: destination.origin,
                     path: `${url.pathname}${url.search}`,
                     method: framed.method,
                     headers: Object.fromEntries(framed.headers),

package/dist/http/oauth.js

@@ -30,7 +30,7 @@ import * as HttpClientResponse from "effect/http/HttpClientResponse";
 import { readRequest, renewedAfterUnauthorized } from "../provider-call.js";
 import { renewableGrantFor } from "../auth/renewable-grant.js";
 import { ConnectorCallError } from "../errors.js";
-import { responseRequest } from "./client.js";
+import { failedResponseRequest, responseRequest } from "./client.js";
 import { Refusal, RequestRefused } from "./errors.js";
 import { Dispatches, Signal, duringCall } from "./services.js";
 /** The calling owner's renewable token, as the operations a transport needs from it. */
@@ -53,6 +53,9 @@ export function grantFromOAuth(oauth) {
     return {
         token: use(grant ? () => grant.token() : missing),
         refresh: (stale) => use(grant ? () => grant.refresh(stale) : missing),
+        ...(grant?.observe
+            ? { observe: (token, outcome) => use(() => grant.observe(token, outcome)) }
+            : {}),
         rejected: use(grant ? () => grant.rejected() : missing),
     };
 }
@@ -80,12 +83,21 @@ export function refreshOnce(guarded, options) {
         return yield* Effect.fail(refusal);
     });
     const execute = (request) => Effect.gen(function* () {
-        const response = yield* inner.execute(request).pipe(Effect.catchTag("ResponseTooLarge", (failure) => {
+        const grant = yield* Grant;
+        const observeOversized = (failure) => {
+            const sent = failedResponseRequest(failure);
+            return responseRequest(failure)?.status === 401 && sent && grant.observe
+                ? grant.observe(sentToken(sent), "refused")
+                : Effect.void;
+        };
+        const response = yield* inner.execute(request).pipe(Effect.tapErrorTag("ResponseTooLarge", observeOversized), Effect.catchTag("ResponseTooLarge", (failure) => {
             const entry = responseRequest(failure);
             return options?.challengeMaxBytes !== undefined && entry?.status === 401
                 ? challengeFailure(entry)
                 : Effect.fail(failure);
         }));
+        if (grant.observe && (response.status === 401 || (response.status >= 200 && response.status < 300)))
+            yield* grant.observe(sentToken(response.request), response.status === 401 ? "refused" : "accepted");
         if (response.status !== 401)
             return response;
         // Read under the ceiling now, so nothing is left open while renewing.
@@ -94,7 +106,6 @@ export function refreshOnce(guarded, options) {
             .pipe(Effect.catchTag("ResponseTooLarge", (failure) => options?.challengeMaxBytes !== undefined
             ? challengeFailure(responseRequest(response))
             : Effect.fail(failure)));
-        const grant = yield* Grant;
         const stale = sentToken(response.request);
         const entry = responseRequest(response);
         if (!readRequest(entry ?? {}) && options?.writeRenewal === "discard") {
@@ -135,11 +146,11 @@ export function refreshOnce(guarded, options) {
             return yield* Effect.fail(new RequestRefused({ message: "This call has ended; no renewal work may continue." }));
         renewedAfterUnauthorized(entry, stale, fresh);
         // `authenticate` runs again on the replay and reads the renewed token.
-        const replay = yield* inner
-            .execute(request)
-            .pipe(Effect.catchTag("ResponseTooLarge", (failure) => options?.challengeMaxBytes !== undefined && responseRequest(failure)?.status === 401
+        const replay = yield* inner.execute(request).pipe(Effect.tapErrorTag("ResponseTooLarge", observeOversized), Effect.catchTag("ResponseTooLarge", (failure) => options?.challengeMaxBytes !== undefined && responseRequest(failure)?.status === 401
             ? grant.rejected
             : Effect.fail(failure)));
+        if (grant.observe && (replay.status === 401 || (replay.status >= 200 && replay.status < 300)))
+            yield* grant.observe(sentToken(replay.request), replay.status === 401 ? "refused" : "accepted");
         if (replay.status !== 401)
             return replay;
         if (options?.replayRejection === "answer") {

package/dist/http/paging.js

@@ -20,7 +20,7 @@ export const StandardPage = Schema.Struct({
 });
 /** The input field that carries a cursor back. */
 export const Cursor = Schema.String.check(Schema.isMinLength(1)).annotate({
-    description: "Opaque nextCursor from the previous page. Pass it back unchanged.",
+    description: "Opaque page.nextCursor from the previous page. Pass it back unchanged with the same arguments.",
 });
 /**
  * Lookahead paging, for a vendor that returns no `has_more`: ask for one row

package/dist/http/provider.js

@@ -46,7 +46,7 @@ const missingGrant = {
 };
 /** An ordinary Promise connector factory; Effect remains inside the kit. */
 export function defineApiProvider(definition) {
-    const { displayTitle, description, authScope, vendor, baseUrl, maxResponseBytes, timeoutMs, headers, admit, transport, defaultCallAdmission, pageSize: declaredPageSize, idempotencyKey, credential, oauth, oauthWrite401, grant, grantRenewal, authenticate, errors, safety, result, inBandRefusals, probe, guide, transformGuide, hatch: declaredHatch, tools, tagConnector, searchSynonyms, ...metadata } = definition;
+    const { displayTitle, description, authScope, vendor, baseUrl, maxResponseBytes, timeoutMs, headers, admit, transport, defaultCallAdmission, pageSize: declaredPageSize, idempotencyKey, credential, oauth, oauthWrite401, grant, grantRenewal, authenticate, publicIdentifierHeaders, errors, safety, result, inBandRefusals, probe, guide, transformGuide, hatch: declaredHatch, tools, tagConnector, searchSynonyms, ...metadata } = definition;
     if (searchSynonyms !== undefined &&
         !(Array.isArray(searchSynonyms) &&
             searchSynonyms.length > 0 &&
@@ -95,18 +95,13 @@ export function defineApiProvider(definition) {
         kind: "api",
         kit: {
             operations: operations(vendor),
-            ...(pageSize ? { pageSize } : {}),
             ...(hatchOptions
                 ? {
                     hatch: {
                         name: hatchOptions.name,
                         verdicts: hatchOptions.verdicts,
                         ...(hatchOptions.fieldsRoot ? { fieldsRoot: hatchOptions.fieldsRoot } : {}),
-                        ...(hatchOptions.pageCursor && Object.keys(hatchOptions.pages ?? {}).length
-                            ? { paging: hatchOptions.pageCursor }
-                            : {}),
                     },
-                    refusesWithheld: true,
                 }
                 : {}),
             ...(meanings ? { errors: meanings } : {}),
@@ -134,6 +129,7 @@ export function defineApiProvider(definition) {
                 ...(headers === undefined ? {} : { headers }),
                 ...(admit === undefined ? {} : { admit }),
                 authenticate: typeof authenticate === "function" ? authenticate(options) : authenticate,
+                ...(publicIdentifierHeaders === undefined ? {} : { publicIdentifierHeaders }),
                 ...configured,
             });
             const connected = connect(vendor, oauth || machineGrant

package/dist/http/vendor.js

@@ -342,6 +342,7 @@ export function connect(vendor, guarded, options) {
                 method: declared.method,
                 template: declared.path,
                 ...(sendOptions?.flags ? { flags: sendOptions.flags } : {}),
+                ...(sendOptions?.context ? { context: sendOptions.context } : {}),
             };
             return Effect.flatMap(admitAddress({
                 params: request.params,
@@ -370,7 +371,11 @@ export function connect(vendor, guarded, options) {
                     request.form !== undefined ||
                     request.emptyForm))
                 return Effect.fail(new RequestRefused({ message: "A raw body cannot accompany a bulk item or another body encoding." }));
-            return Effect.flatMap(admitAddress({ path, query: request.query }), () => Effect.flatMap(options.safety.resolve(method, path), (operation) => settle({ ...operation, ...(sendOptions?.flags ? { flags: sendOptions.flags } : {}) }, Effect.suspend(() => {
+            return Effect.flatMap(admitAddress({ path, query: request.query }), () => Effect.flatMap(options.safety.resolve(method, path), (operation) => settle({
+                ...operation,
+                ...(sendOptions?.flags ? { flags: sendOptions.flags } : {}),
+                ...(sendOptions?.context ? { context: sendOptions.context } : {}),
+            }, Effect.suspend(() => {
                 let built = HttpClientRequest.make(method)(path, request.query ? { urlParams: parameterPairs(request.query) } : {});
                 if (request.headers)
                     built = HttpClientRequest.setHeaders(built, request.headers);

package/dist/index.d.ts

@@ -41,6 +41,6 @@ export type { Registry } from "./registry.js";
 export type { RemoteMcpOptions, RemoteMcpAuth, RemoteMcpRequestAuth, RemoteMcpRedirectPolicy, } from "./connectors/remote-mcp.js";
 export type { AgentRequestPrincipal, HumanRequestPrincipal, PrincipalForwarding, PrincipalRequestToken, RequestPrincipal, RequestPrincipalPolicy, RequestToken, RequestTokenInput, } from "./request-token.js";
 export type { ApiHandlerContext, ApiOAuthAccess, ApiOAuthClientAuthentication, ApiOAuthConfig, ApiOptions, ApiTool, } from "./connectors/api.js";
-export type { ConnectaBranding, ConnectaTheme, Connector, ConnectorCallAdmissionInput, ConnectorCallAdmissionPolicy, ConnectorCallAdmissionRule, ConnectorRollingWindowBudget, ConnectorCredentialAccess, ConnectorCredentialConfig, ConnectorCredentialFieldConfig, ConnectorCredentialValues, AgentRouteNames, ConnectorContext, ConnectorAuthDescription, ConnectorDescription, ConnectorToolDescription, ConnectorUsageGuide, ConnectorSkill, ConnectorSkillResourceContents, DescribedEndpoint, ConnectorStatus, CredentialFailureClass, CredentialTestResult, AdmittingExecutor, AdmissionSnapshot, ExecuteResult, Executor, ExecutorLease, ExecutorProvider, InboundAuth, InboundAuthRuntimeContext, UiAuthConfig, AuthResult, AuthenticatedIdentity, IdentityReference, JsonSchema, KVStorage, Logger, ToolDef, ToolAnnotations, } from "./types.js";
+export type { ConnectaBranding, ConnectaTheme, Connector, ConnectorCallAdmissionInput, ConnectorCallAdmissionPolicy, ConnectorCallAdmissionRule, ConnectorRollingWindowBudget, ConnectorCredentialAccess, ConnectorCredentialConfig, ConnectorCredentialFieldConfig, ConnectorCatalogPeek, ConnectorCredentialValues, AgentRouteNames, ConnectorContext, ConnectorAuthDescription, ConnectorDescription, ConnectorToolDescription, ConnectorUsageGuide, ConnectorSkill, ConnectorSkillResourceContents, DescribedEndpoint, ConnectorStatus, CredentialFailureClass, CredentialTestResult, AdmittingExecutor, AdmissionSnapshot, ExecuteResult, Executor, ExecutorLease, ExecutorProvider, InboundAuth, InboundAuthRuntimeContext, UiAuthConfig, AuthResult, AuthenticatedIdentity, IdentityReference, JsonSchema, KVStorage, Logger, ToolDef, ToolAnnotations, } from "./types.js";
 export type { ActivityActor, ActivityCatalogChange, ActivityCallSource, ActivityOutcome, ActivityPage, ActivityReadActor, ActivityReadEvent, ActivityReader, ActivityReadGate, ActivityReadPage, ActivitySink, ActivityStore, AgentFriction, ToolCallActivityEvent, } from "./activity.js";
 export { META_TOOL_NAMES } from "./meta-tool-names.js";

package/dist/index.js

@@ -92,14 +92,16 @@ function warnInsecureConfig(config) {
                 : "") +
             "Configure Clerk, Cloudflare Access on Workers, or accessTokens(storage) to gate access.");
     }
-    // Unset publicUrl with OAuth connectors: the downstream redirect_uri is
-    // derived per-request from the attacker-influenced inbound Host header.
-    if (oauthConnectors.length > 0 && !config.publicUrl) {
-        logger.warn("[connecta] publicUrl is unset while OAuth connectors are configured: " +
-            "the downstream OAuth redirect_uri is derived per-request from the " +
-            "inbound Host header, so an attacker who controls that header can point " +
-            "it at their own host and capture the authorization code. Set " +
-            "`publicUrl` to a fixed https origin.");
+    // Unset publicUrl: everything built from the deployment's own URL follows the
+    // inbound request, whose Host (and X-Forwarded-Proto on Node) the caller
+    // chooses. Clerk without any publicUrl has already refused construction.
+    if (!config.publicUrl && (oauthConnectors.length > 0 || inboundAuth.length > 0)) {
+        logger.warn("[connecta] publicUrl is unset: the URLs this deployment hands out, including " +
+            "protected-resource metadata, authorization handoffs and the downstream OAuth " +
+            "redirect_uri, are derived per-request from the inbound Host header (and " +
+            "X-Forwarded-Proto on Node). A caller who controls those can point them at " +
+            "their own host and, with OAuth connectors, capture the authorization code. " +
+            "Set `publicUrl` to a fixed https origin.");
     }
     // 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
@@ -156,19 +158,6 @@ function warnInsecureConfig(config) {
             `action and POST /ui/credentials/${connector.id}/test answers 400 ` +
             "until the matching hook is implemented.");
     }
-    // A vault written before seal/open existed encrypts credentials but cannot
-    // seal downstream OAuth state, so tokens stay plaintext at rest beside them.
-    const vault = config.vault;
-    if (vault && (typeof vault.seal !== "function" || typeof vault.open !== "function")) {
-        for (const connector of config.connectors) {
-            if (!connector.startAuth)
-                continue;
-            logger.warn(`[connecta] connector "${connector.id}" stores its downstream OAuth ` +
-                "tokens, client registration, and PKCE verifier as plaintext: the " +
-                "configured vault implements no `seal`/`open`. Use " +
-                "encryptedCredentialVault(...) or add both methods to seal them.");
-        }
-    }
     // OAuth connectors whose callback cannot perform a state/CSRF check. The
     // public route refuses every callback for these connectors rather than hand
     // an unverified code to finishAuth, so this warning explains why auth cannot
@@ -222,6 +211,11 @@ export function createConnecta(config) {
     const requestAdmission = new AdmissionController(resolved.admission.requests);
     let codeAdmission;
     let executor = resolved.executor;
+    if (executor.deadlineMs !== undefined && executor.deadlineMs >= resolved.execute.watchdogMs) {
+        logger.warn(`[connecta] The executor's ${executor.deadlineMs}ms deadline does not end before execute.watchdogMs ` +
+            `(${resolved.execute.watchdogMs}ms), so programs end at the watchdog. Raise execute.watchdogMs ` +
+            "above it if your MCP clients allow requests that long.");
+    }
     // Read the identity off the configured executor, before any wrapper hides
     // it behind an anonymous object literal.
     const configuredExecutorName = executorName(executor);

package/dist/invocation-failure.js

@@ -0,0 +1,28 @@
+import { keepErrorName } from "./redaction-identity.js";
+export class InvocationFailure extends Error {
+    details;
+    code;
+    retryable;
+    retryAfterMs;
+    connector;
+    operation;
+    recovery;
+    nextAction;
+    retry;
+    data;
+    constructor(details) {
+        super(details.message);
+        this.details = details;
+        this.name = "InvocationFailure";
+        this.code = details.code;
+        this.retryable = details.retryable;
+        this.retryAfterMs = details.retryAfterMs;
+        this.connector = details.connector;
+        this.operation = details.operation;
+        this.recovery = details.recovery;
+        this.nextAction = details.nextAction;
+        this.retry = details.retry;
+        this.data = details;
+    }
+}
+keepErrorName(InvocationFailure, "InvocationFailure");