@zackbart/connecta 0.37.1 → 0.38.0

package/dist/catalog-service.js

@@ -466,7 +466,7 @@ export class CatalogService {
     // timeout, whichever asker starts it. Each asker waits under its own signal
     // and deadline, so a short-deadline call that starts the read and a search
     // that joins it each end on their own terms, and the read is cancelled only
-    // once every asker has gone (#571).
+    // once every asker has gone.
     catalog(id, callOptions) {
         return Effect.suspend(() => {
             // Authored static definitions never depend on a downstream cache or

package/dist/config-defaults.d.ts

@@ -20,6 +20,7 @@ export declare const CONFIG_DEFAULTS: {
         readonly hostCallTimeoutMs: 15000;
         readonly watchdogMs: 120000;
         readonly maxWrites: 10;
+        readonly maxResultChars: 24000;
     };
     readonly admission: {
         readonly requests: {

package/dist/config-defaults.js

@@ -27,6 +27,7 @@ export const CONFIG_DEFAULTS = {
         hostCallTimeoutMs: 15_000,
         watchdogMs: 120_000,
         maxWrites: 10,
+        maxResultChars: 24_000,
     },
     admission: {
         requests: {

package/dist/config-schema.d.ts

@@ -62,7 +62,7 @@ export declare class ConfigError extends TypeError {
 }
 interface WholeOptions {
     /** Smallest accepted value. */
-    min: 0 | 1;
+    min: number;
     /** Largest accepted value, when there is one. */
     max?: number;
     /** Unit named in the `max` refusal, e.g. "milliseconds". */

package/dist/config-schema.js

@@ -27,12 +27,16 @@ function ownValue(value, key) {
     return Object.prototype.hasOwnProperty.call(value, key) ? value[key] : undefined;
 }
 export function whole(options) {
-    const kind = options.min === 1 ? "positive" : "non-negative";
+    const kind = options.min === 0
+        ? "a non-negative whole number"
+        : options.min === 1
+            ? "a positive whole number"
+            : `a whole number of at least ${options.min.toLocaleString("en-US")}`;
     return {
         optional: true,
         parse: (value, path) => {
             if (typeof value !== "number" || !Number.isSafeInteger(value) || value < options.min) {
-                fail(`${path} must be a ${kind} whole number.`);
+                fail(`${path} must be ${kind}.`);
             }
             if (options.max !== undefined && value > options.max) {
                 fail(`${path} must be at most ${options.max.toLocaleString("en-US")}` + (options.unit ? ` ${options.unit}.` : "."));

package/dist/config.d.ts

@@ -28,11 +28,12 @@ declare const discovery: {
 declare const calls: {
     /**
      * Deadline (ms) for `call_tool`/`call_destructive_tool` calls that pass no
-     * `timeoutMs`. An explicit per-call value wins. Opt-in: unset by default, so
-     * existing long-running calls gain no surprise deadline.
+     * `timeoutMs`. An explicit per-call value wins. Unset by default, when those
+     * calls fall back to `execute.hostCallTimeoutMs`.
      *
-     * Each call makes one attempt. `execute_code` host calls are
-     * unaffected because they already carry their own bound.
+     * Each call makes one attempt. `connecta.call` inside `execute_code` uses
+     * it too, ahead of `execute.hostCallTimeoutMs`; `connecta.result`,
+     * `connecta.skill` and `connecta.read` do not.
      */
     defaultTimeoutMs: import("./config-schema.js").Field<number, number | undefined, true>;
     /**
@@ -60,9 +61,12 @@ declare const execute: {
     /** Host calls one program may make. Default 20. */
     maxHostCalls: import("./config-schema.js").Field<number, number, true>;
     /**
-     * Deadline for each host call a program makes, in milliseconds. Default
-     * 15_000. Raise it for providers whose legitimate calls run longer, such as
-     * analytics queries; `call_tool`'s own `timeoutMs` is unaffected.
+     * Deadline for a program's `connecta.result`, `connecta.skill` and
+     * `connecta.read`, in milliseconds. Default 15_000. Discovery uses
+     * `discovery.probeTimeoutMs`. `connecta.call` and the direct call tools use it only when
+     * `calls.defaultTimeoutMs` is unset, and an explicit per-call `timeoutMs`
+     * always wins. Raise it for providers whose legitimate calls run longer,
+     * such as analytics queries.
      */
     hostCallTimeoutMs: import("./config-schema.js").Field<number, number, true>;
     /**
@@ -78,6 +82,14 @@ declare const execute: {
      * budget every call already spends. Default 10.
      */
     maxWrites: import("./config-schema.js").Field<number, number, true>;
+    /**
+     * Serialized characters a program may return, shared with emitted text,
+     * before Connecta stashes the return and answers with a paging notice.
+     * Default 24_000 (~6k tokens). Raise it when agents need large results whole
+     * and the model's context can afford them: each paging round trip costs a
+     * model step. From 4_000 to 1_000_000.
+     */
+    maxResultChars: import("./config-schema.js").Field<number, number, true>;
 };
 declare const codeAdmission: {
     /** Simultaneous work admitted to this pool. */
@@ -333,11 +345,12 @@ declare const connectaConfig: {
         readonly shape: {
             /**
              * Deadline (ms) for `call_tool`/`call_destructive_tool` calls that pass no
-             * `timeoutMs`. An explicit per-call value wins. Opt-in: unset by default, so
-             * existing long-running calls gain no surprise deadline.
+             * `timeoutMs`. An explicit per-call value wins. Unset by default, when those
+             * calls fall back to `execute.hostCallTimeoutMs`.
              *
-             * Each call makes one attempt. `execute_code` host calls are
-             * unaffected because they already carry their own bound.
+             * Each call makes one attempt. `connecta.call` inside `execute_code` uses
+             * it too, ahead of `execute.hostCallTimeoutMs`; `connecta.result`,
+             * `connecta.skill` and `connecta.read` do not.
              */
             defaultTimeoutMs: import("./config-schema.js").Field<number, number | undefined, true>;
             /**
@@ -371,6 +384,7 @@ declare const connectaConfig: {
         hostCallTimeoutMs?: number | undefined;
         watchdogMs?: number | undefined;
         maxWrites?: number | undefined;
+        maxResultChars?: number | undefined;
     }, {
         readonly maxEmittedBytes: number;
         readonly maxEmittedBlocks: number;
@@ -378,6 +392,7 @@ declare const connectaConfig: {
         readonly hostCallTimeoutMs: number;
         readonly watchdogMs: number;
         readonly maxWrites: number;
+        readonly maxResultChars: number;
     }, true> & {
         readonly shape: {
             /**
@@ -391,9 +406,12 @@ declare const connectaConfig: {
             /** Host calls one program may make. Default 20. */
             maxHostCalls: import("./config-schema.js").Field<number, number, true>;
             /**
-             * Deadline for each host call a program makes, in milliseconds. Default
-             * 15_000. Raise it for providers whose legitimate calls run longer, such as
-             * analytics queries; `call_tool`'s own `timeoutMs` is unaffected.
+             * Deadline for a program's `connecta.result`, `connecta.skill` and
+             * `connecta.read`, in milliseconds. Default 15_000. Discovery uses
+             * `discovery.probeTimeoutMs`. `connecta.call` and the direct call tools use it only when
+             * `calls.defaultTimeoutMs` is unset, and an explicit per-call `timeoutMs`
+             * always wins. Raise it for providers whose legitimate calls run longer,
+             * such as analytics queries.
              */
             hostCallTimeoutMs: import("./config-schema.js").Field<number, number, true>;
             /**
@@ -409,6 +427,14 @@ declare const connectaConfig: {
              * budget every call already spends. Default 10.
              */
             maxWrites: import("./config-schema.js").Field<number, number, true>;
+            /**
+             * Serialized characters a program may return, shared with emitted text,
+             * before Connecta stashes the return and answers with a paging notice.
+             * Default 24_000 (~6k tokens). Raise it when agents need large results whole
+             * and the model's context can afford them: each paging round trip costs a
+             * model step. From 4_000 to 1_000_000.
+             */
+            maxResultChars: import("./config-schema.js").Field<number, number, true>;
         };
     };
     /**
@@ -654,5 +680,6 @@ export declare function executeLimits(config: ResolvedConfig): {
     hostCallTimeoutMs: number;
     watchdogMs: number;
     maxWrites: number;
+    maxResultChars: number;
 };
 export {};

package/dist/config.js

@@ -79,11 +79,12 @@ const discovery = {
 const calls = {
     /**
      * Deadline (ms) for `call_tool`/`call_destructive_tool` calls that pass no
-     * `timeoutMs`. An explicit per-call value wins. Opt-in: unset by default, so
-     * existing long-running calls gain no surprise deadline.
+     * `timeoutMs`. An explicit per-call value wins. Unset by default, when those
+     * calls fall back to `execute.hostCallTimeoutMs`.
      *
-     * Each call makes one attempt. `execute_code` host calls are
-     * unaffected because they already carry their own bound.
+     * Each call makes one attempt. `connecta.call` inside `execute_code` uses
+     * it too, ahead of `execute.hostCallTimeoutMs`; `connecta.result`,
+     * `connecta.skill` and `connecta.read` do not.
      */
     defaultTimeoutMs: whole({ min: 1 }),
     /**
@@ -111,9 +112,12 @@ const execute = {
     /** Host calls one program may make. Default 20. */
     maxHostCalls: whole({ min: 1, default: D.execute.maxHostCalls }),
     /**
-     * Deadline for each host call a program makes, in milliseconds. Default
-     * 15_000. Raise it for providers whose legitimate calls run longer, such as
-     * analytics queries; `call_tool`'s own `timeoutMs` is unaffected.
+     * Deadline for a program's `connecta.result`, `connecta.skill` and
+     * `connecta.read`, in milliseconds. Default 15_000. Discovery uses
+     * `discovery.probeTimeoutMs`. `connecta.call` and the direct call tools use it only when
+     * `calls.defaultTimeoutMs` is unset, and an explicit per-call `timeoutMs`
+     * always wins. Raise it for providers whose legitimate calls run longer,
+     * such as analytics queries.
      */
     hostCallTimeoutMs: whole({ min: 1, default: D.execute.hostCallTimeoutMs }),
     /**
@@ -129,6 +133,14 @@ const execute = {
      * budget every call already spends. Default 10.
      */
     maxWrites: whole({ min: 1, default: D.execute.maxWrites }),
+    /**
+     * Serialized characters a program may return, shared with emitted text,
+     * before Connecta stashes the return and answers with a paging notice.
+     * Default 24_000 (~6k tokens). Raise it when agents need large results whole
+     * and the model's context can afford them: each paging round trip costs a
+     * model step. From 4_000 to 1_000_000.
+     */
+    maxResultChars: whole({ min: 4_000, max: 1_000_000, default: D.execute.maxResultChars }),
 };
 function admissionPool(defaults) {
     return {
@@ -492,48 +504,6 @@ const connectaConfig = {
     readOnly: required(opaque({ check: assertFlag }), (path) => READ_ONLY_REQUIRED(path)),
 };
 const CONFIG = object(connectaConfig);
-/** Pause-only options #672 removed with `resume_execution`. */
-const RETIRED_PAUSE_OPTIONS = ["ConnectaConfig.execute.resumableWrites", "ConnectaConfig.execute.pausedRunTtlSeconds"];
-/** Access options pools replaced (#837, decisions/0006). */
-const isRetiredPoolGrant = (path) => /^ConnectaConfig\.pools\.[^.]+\.grant$/.test(path);
-/** Management resolvers maintainers and pool membership replaced (#837, decisions/0006). */
-const RETIRED_IDENTITY = [
-    ["credentialAdministration", "maintainers administer shared credentials and OAuth grants. List them in maintainers."],
-    [
-        "personalConnection",
-        "pool members connect and disconnect their own personal connectors in their pools, and maintainers their own. Add people to a pool's members.",
-    ],
-    [
-        "accessTokenManagement",
-        "maintainers issue, rotate, and revoke agent tokens from an interactive session. List them in maintainers.",
-    ],
-    ["activityAccess", "maintainers read activity; activity.readGate can still narrow it. List them in maintainers."],
-];
-/** `trust`, on the deployment or a pool, was replaced by `readOnly` (#820). */
-const isRetiredTrust = (path) => path === "ConnectaConfig.trust" || (path.startsWith("ConnectaConfig.pools.") && path.endsWith(".trust"));
-/**
- * `identity` was removed whole (#837), so the walk reports only the section.
- * Name each key it still holds, read by descriptor without running a getter
- * or echoing a value, so a retired resolver's message names its replacement.
- */
-function expandRetiredIdentity(config, paths) {
-    if (!paths.includes("ConnectaConfig.identity"))
-        return paths;
-    let keys = [];
-    try {
-        const descriptor = Reflect.getOwnPropertyDescriptor(config, "identity");
-        const value = descriptor && "value" in descriptor ? descriptor.value : undefined;
-        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-            keys = Reflect.ownKeys(value).filter((key) => typeof key === "string");
-        }
-    }
-    catch {
-        keys = [];
-    }
-    if (keys.length === 0)
-        return paths;
-    return paths.flatMap((path) => path === "ConnectaConfig.identity" ? keys.map((key) => `ConnectaConfig.identity.${key}`) : [path]);
-}
 function rejectUnknownOptions(paths) {
     if (paths.length === 0)
         return;
@@ -547,27 +517,6 @@ function rejectUnknownOptions(paths) {
             : "") +
         (paths.includes("ConnectaConfig.execute.approval")
             ? "\nexecute.approval was removed. The MCP client owns approval; set readOnly: true on the deployment or a pool to refuse writes."
-            : "") +
-        (paths.some((path) => RETIRED_PAUSE_OPTIONS.includes(path))
-            ? "\nPrograms no longer pause at writes, so there is nothing to configure: writable endpoints let programs and call_destructive_tool write; readOnly endpoints refuse every write (issue #672). Delete the option."
-            : "") +
-        (paths.includes("ConnectaConfig.identity.connectorAccess")
-            ? "\nidentity.connectorAccess was removed (#837): pools are the access model. List who may use plain /mcp in maintainers, and give each pool its tools and members. A guarded { tool, requireReadOnly: true } grant becomes a pool with readOnly: true."
-            : "") +
-        RETIRED_IDENTITY.filter(([key]) => paths.includes(`ConnectaConfig.identity.${key}`))
-            .map(([key, replacement]) => `\nidentity.${key} was removed (#837): ${replacement}`)
-            .join("") +
-        (paths.some((path) => path === "ConnectaConfig.identity" || path.startsWith("ConnectaConfig.identity."))
-            ? "\nThe identity section was removed (#837): maintainers and pool members decide access and management. Delete it."
-            : "") +
-        (paths.includes("ConnectaConfig.grant")
-            ? "\nThe top-level grant was removed (#837); list the people who may use plain /mcp in maintainers."
-            : "") +
-        (paths.some(isRetiredPoolGrant)
-            ? "\nPool grant was removed (#837); list who may open the pool in its members."
-            : "") +
-        (paths.some(isRetiredTrust)
-            ? '\ntrust was removed (#820); set readOnly, which every deployment now chooses explicitly. trust: "read-only" becomes readOnly: true, which now also refuses call_destructive_tool. trust: "trusted" becomes readOnly: false. A pool inherits the deployment readOnly unless it sets its own.'
             : ""));
 }
 /** Checks that span fields; each value is already individually valid. */
@@ -598,7 +547,7 @@ export function resolveConfig(config) {
  */
 export function readConfig(config) {
     const read = readPlain(config, "ConnectaConfig", CONFIG);
-    rejectUnknownOptions(expandRetiredIdentity(config, read.unknown));
+    rejectUnknownOptions(read.unknown);
     const input = read.value;
     const parsed = CONFIG.parse(input, "ConnectaConfig");
     assertCoherent(parsed);
@@ -648,5 +597,6 @@ export function executeLimits(config) {
         hostCallTimeoutMs: config.execute.hostCallTimeoutMs,
         watchdogMs: config.execute.watchdogMs,
         maxWrites: config.execute.maxWrites,
+        maxResultChars: config.execute.maxResultChars,
     };
 }

package/dist/connectors/api-connector.js

@@ -1,3 +1,4 @@
+import { wrapViewCredentials } from "../runtime/call.js";
 import { storedAuthObservation, withStoredAuth } from "../auth/stored-observation.js";
 import { Effect, Exit } from "effect";
 import { registerConnectorVocabulary } from "../operation-vocabulary.js";
@@ -13,7 +14,7 @@ import { describedEndpoint, describedOrigin, describedTools } from "../described
 import { READ_ONLY, CALL_ADMISSION, CREDENTIAL, USAGE_GUIDE } from "./option-shapes.js";
 import { assertStaticToolNames } from "../tool-name.js";
 import { registerInvocationAuth } from "../invocation-auth.js";
-import { redactCatalog, redactSentSecrets, sentSecretsFetch, trackCredentialReads } from "../sent-secrets.js";
+import { redactCatalog, redactSentSecrets, sentSecretsFetch } from "../sent-secrets.js";
 import { callClassification } from "../call-classification.js";
 import { classifyTool } from "../tool-safety.js";
 import { closeProviderCall, enterProviderBoundary, inLogicalCall, knownProviderFailure, nestedProviderRequests, providerBoundary, providerCallContext, providerFetch, providerRequests, tracksRequests, } from "../provider-call.js";
@@ -24,7 +25,7 @@ export function defined(value) {
 }
 /**
  * Three things a hand-written surface is refused for at construction rather
- * than in production (#340): no description (discovery has nothing to route on
+ * than in production: no description (discovery has nothing to route on
  * and a guess costs a call), no explicit `readOnlyHint` (connecta never infers
  * the safety class, so an unclassified tool is a deployment bug), and an
  * `inputSchema` the validator cannot compile (declaring one is optional;
@@ -173,7 +174,7 @@ export function apiConnector(id, opts, oauth) {
         callTool: (name, args, ctx, options) => runEdge(core(name, args, ctx, options)),
     };
     const core = (name, args, ctx) => Effect.gen(function* () {
-        trackCredentialReads(ctx);
+        wrapViewCredentials(ctx);
         enterProviderBoundary(ctx, connector);
         const tool = byName.get(name);
         // Refusals before the handler runs are known failures: nothing was sent.

package/dist/connectors/guarded-fetch.d.ts

@@ -1,5 +1,4 @@
 export { retryAfterMs } from "../http-policy.js";
-import { type ProviderRequest } from "../provider-call.js";
 import type { ConnectorContext } from "../types.js";
 /** The methods a hand-written provider surface actually uses. */
 type GuardedMethod = "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE";
@@ -182,11 +181,6 @@ type GuardedFetcher = (url: string, init: RequestInit, ctx: ConnectorContext) =>
 export declare function oauthBearer(provider: string): Pick<GuardedFetchOptions, "authenticate" | "fetch">;
 /** Send one guarded request and map its response with provider knowledge. */
 export type GuardedTransport = <T>(request: GuardedRequest, ctx: ConnectorContext, map: GuardedResponseMapper<T>) => Promise<T>;
-/**
- * Test-only legacy response lookup for renewal-provenance fixtures outside
- * the kit. Production renewal uses the kit ledger. Undefined for other objects.
- */
-export declare function answeredRequest(response: object): ProviderRequest | undefined;
 /**
  * Build the transport a connector sends every request through. `maxResponseBytes`
  * is required rather than defaulted: what counts as an absurd response is a fact

package/dist/connectors/guarded-fetch.js

@@ -3,7 +3,7 @@ export { retryAfterMs } from "../http-policy.js";
 import { callerSignal, duringViewCall, settleOnClose, viewSignal } from "../runtime/call.js";
 /**
  * The safety machinery every hand-written HTTP surface needs, extracted once
- * (#341): path confinement, encoded query and framed bodies, per-request
+ *: path confinement, encoded query and framed bodies, per-request
  * credential headers applied last, a refused redirect, a bounded read, and
  * network-failure normalization. It owns no vendor-specific meaning and never
  * invents an auth scheme, because the same 403 means an ungranted
@@ -280,15 +280,6 @@ async function jsonResult(read) {
         return { parseError: cause };
     }
 }
-// Each response a mapper reads, and the ledger entry of the request it answered.
-const answeredRequests = new WeakMap();
-/**
- * Test-only legacy response lookup for renewal-provenance fixtures outside
- * the kit. Production renewal uses the kit ledger. Undefined for other objects.
- */
-export function answeredRequest(response) {
-    return answeredRequests.get(response);
-}
 /**
  * Build the transport a connector sends every request through. `maxResponseBytes`
  * is required rather than defaulted: what counts as an absurd response is a fact
@@ -463,7 +454,6 @@ export function guardedFetch(options) {
                 throw oversized(provider, limit, `a declared ${declared} bytes`);
             }
             const answer = boundedResponse(provider, response, limit, signal);
-            answeredRequests.set(answer, dispatch);
             const abort = () => {
                 void response?.body?.cancel().catch(() => { });
             };

package/dist/connectors/remote-mcp.js

@@ -1,3 +1,5 @@
+import { wrapViewCredentials } from "../runtime/call.js";
+import { sha256Hex, utf8Length } from "../bytes.js";
 import { withStoredAuth } from "../auth/stored-observation.js";
 import { authorizationParamsFor } from "../auth/oauth-authorization-params.js";
 import { authView } from "../auth/native-call.js";
@@ -11,7 +13,7 @@ import { Deferred, Duration, Effect, Exit, Scope } from "effect";
 import { assertOAuthScope, authorizingContext, codeExchangeResponse, KvOAuthProvider, OAuthRequestNotSentError, refreshCoordinatorsByPartition, } from "../auth/downstream-oauth.js";
 import { trackOAuthStartReset } from "../auth/oauth-start-reset.js";
 import { byteReadResponse } from "../byte-read-response.js";
-import { redactCatalog, redactSentSecrets, requestSentSecrets, sentSecretsFor, shortSecretWarning, trackCredentialReads, } from "../sent-secrets.js";
+import { redactCatalog, redactSentSecrets, requestSentSecrets, sentSecretsFor, shortSecretWarning, } from "../sent-secrets.js";
 import { MAX_CATALOG_TOOLS, MAX_SERIALIZED_CATALOG_BYTES } from "../catalog-limits.js";
 import { catalogClientOptions, catalogItems, observeCompletedCatalogRefresh, closeCatalogCacheScope, observeCatalogChange, observeCatalogFetch, observeCatalogExpiry, } from "../catalog-cache.js";
 import { connectorScopeCleanupClaimed } from "../connector-scope.js";
@@ -115,32 +117,11 @@ const MAX_SKILL_BYTES = 16 * 1024 * 1024;
 // Leave room for the envelope while accepting every file up to the spec limit.
 const MAX_SKILL_READ_RPC_BYTES = 6 * MAX_SKILL_BYTES + 1024 * 1024;
 /** Count UTF-8 without allocating another full copy of a bounded response. */
-function skillTextBytes(value) {
-    let bytes = 0;
-    for (let i = 0; i < value.length; i++) {
-        const code = value.charCodeAt(i);
-        if (code < 0x80)
-            bytes++;
-        else if (code < 0x800)
-            bytes += 2;
-        else if (code >= 0xd800 &&
-            code <= 0xdbff &&
-            i + 1 < value.length &&
-            value.charCodeAt(i + 1) >= 0xdc00 &&
-            value.charCodeAt(i + 1) <= 0xdfff) {
-            bytes += 4;
-            i++;
-        }
-        else
-            bytes += 3;
-    }
-    return bytes;
-}
 function skillObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function skillJsonBytes(value) {
-    return skillTextBytes(JSON.stringify(value));
+    return utf8Length(JSON.stringify(value));
 }
 function validSkill(value) {
     if (!skillObject(value) ||
@@ -229,9 +210,7 @@ function skillReadSchema(uri) {
                     return { issues: [{ message: "Unexpected skill resource contents." }] };
                 }
                 const mimeType = typeof content.mimeType === "string" ? { mimeType: content.mimeType } : {};
-                if (typeof content.text === "string" &&
-                    !("blob" in content) &&
-                    skillTextBytes(content.text) <= MAX_SKILL_BYTES) {
+                if (typeof content.text === "string" && !("blob" in content) && utf8Length(content.text) <= MAX_SKILL_BYTES) {
                     return { value: [{ uri, ...mimeType, text: content.text }] };
                 }
                 if (typeof content.blob === "string" &&
@@ -668,18 +647,6 @@ function base64Utf8(value) {
     }
     return btoa(binary);
 }
-/**
- * Hex SHA-256 of a credential, used only to notice that a cached client
- * connected with a value the vault no longer holds. WebCrypto rather than a
- * `node:` hash: the whole core has to keep running unchanged on Workers.
- */
-async function digestOf(value) {
-    const bytes = new Uint8Array(await crypto.subtle.digest("SHA-256", encoder.encode(value)));
-    let hex = "";
-    for (const byte of bytes)
-        hex += byte.toString(16).padStart(2, "0");
-    return hex;
-}
 /**
  * Assemble the one header a credential-auth connector sends.
  *
@@ -1141,7 +1108,7 @@ export function remoteMcp(id, opts) {
     // handshake/discovery requests and OAuth rotations. Remove settled users.
     const activeContexts = new WeakMap();
     // Resource headers are non-secret context by contract. They never join the
-    // sent set, so arguments and results equal to them pass unchanged (#1108).
+    // sent set, so arguments and results equal to them pass unchanged.
     // An argument mirrored as `Mcp-Param-*` carrying a resource value is the
     // same context under a name the tracker may read as credential-shaped.
     const resourceValues = new Set(Object.values(extraHeaders ?? {}));
@@ -2177,7 +2144,7 @@ export function remoteMcp(id, opts) {
                 credentialFramed = credentialHeaderValue(credentialScheme, credentialValue);
                 // The principal joins the client's identity: another principal never
                 // reuses this client, even if its resolver returns the same token.
-                credentialDigest = (yield authCall(digestOf, [
+                credentialDigest = (yield authCall(sha256Hex, [
                     principal ? JSON.stringify([principal, credentialValue]) : credentialValue,
                 ]));
                 if ((state.client || state.connecting) &&
@@ -2302,7 +2269,7 @@ export function remoteMcp(id, opts) {
                         clientName: ctx.oauthClientName,
                     }
                     : undefined;
-                const negotiationDigest = yield* promised(authMethod(() => authCall(digestOf, [
+                const negotiationDigest = yield* promised(authMethod(() => authCall(sha256Hex, [
                     JSON.stringify([
                         opts.url,
                         opts.versionNegotiation ?? "auto",
@@ -2349,7 +2316,7 @@ export function remoteMcp(id, opts) {
                     provider
                         ? authMethod(() => authFlow(function* () {
                             const tokens = yield authInvoke(provider, "tokens", []);
-                            return yield authCall(digestOf, [JSON.stringify(tokens)]);
+                            return yield authCall(sha256Hex, [JSON.stringify(tokens)]);
                         }))
                         : undefined,
                 ])));
@@ -3186,7 +3153,7 @@ export function remoteMcp(id, opts) {
         }
     }));
     const withActiveSecrets = authMethod((ctx, run, redactResult = true, preserveInput = false) => authFlow(function* () {
-        trackCredentialReads(ctx);
+        wrapViewCredentials(ctx);
         const secrets = sentSecretsFor(ctx);
         if (opts.auth?.type === "headers") {
             for (const value of Object.values(opts.auth.headers))

package/dist/connectors/resource-uri.js

@@ -26,10 +26,6 @@ export function resourceUriMatchesTemplates(uri, templates, note = () => { }) {
     }
     return matched ? { matched } : { matched, ...(refusal ? { refusal } : {}) };
 }
-export function resourceUriMatchesTemplate(uri, template) {
-    const parsed = parse(template);
-    return typeof parsed === "object" && matches(uri, parsed);
-}
 function parse(template) {
     if (template.length > MAX_URI_LENGTH)
         return;

package/dist/d1.d.ts

@@ -38,93 +38,4 @@ export declare function d1Storage(db: D1DatabaseBinding): KVStorage;
  * write prunes a bounded batch of rows older than `retentionDays`.
  */
 export declare function d1ActivityStore(db: D1DatabaseBinding, options?: D1ActivityOptions): ActivityStore;
-/**
- * The part of a Workers KV binding `copyKvToD1` reads. Structural, like
- * `D1DatabaseBinding`; a Worker's `KVNamespace` satisfies it.
- */
-export interface KVNamespaceBinding {
-    list(options?: {
-        limit?: number;
-        cursor?: string | null;
-    }): Promise<{
-        keys: readonly {
-            name: string;
-            expiration?: number;
-        }[];
-        list_complete: boolean;
-        cursor?: string;
-    }>;
-    get(key: string, type: "text"): Promise<string | null>;
-}
-export interface KvToD1CopyOptions {
-    /** The source KV namespace id. Resume tokens are bound to this identity. */
-    source: string;
-    /** Resume against the same source and database within seven days. */
-    cursor?: string;
-    /** Explicit families whose conflicting D1 rows the operator judged stale. */
-    overwriteFamilies?: readonly string[];
-    /** Compare value hashes and absolute expiries without copying entries. */
-    verify?: boolean;
-    /** Override the cutover guard only after assessing stale KV state. */
-    allowStale?: boolean;
-    /** Keys read per call. Default 500; use a smaller budget for large rows. */
-    maxKeys?: number;
-}
-/** What a copy did with one family's keys. */
-export interface KvToD1Counts {
-    /** Written where D1 held no live entry. */
-    copied: number;
-    /** D1 already held the same value. */
-    unchanged: number;
-    /** D1 held a different value or expiry and kept it. */
-    conflicts: number;
-    /** D1 held a different value or expiry, replaced under `overwriteFamilies`. */
-    overwritten: number;
-    /** Expired or deleted in Workers KV before it could be read. */
-    expired: number;
-    /** A key/value/row D1 cannot hold, left in Workers KV. */
-    invalid: number;
-    /** Exact value hash and expiry match during a verification pass. */
-    verified: number;
-    /** Missing or different value/expiry during a verification pass. */
-    mismatches: number;
-}
-export interface KvToD1CopyResult {
-    /** True once the whole namespace has been read. */
-    done: boolean;
-    /**
-     * Pass back as `options.cursor` to continue; absent when `done`. A random
-     * token: the Workers KV cursor it stands for stays in D1, because that
-     * cursor can spell the last key listed.
-     */
-    cursor?: string;
-    /**
-     * Counts by key family (`src/storage/keys.ts`), plus `connector-owned` and
-     * `unclassified`. Never a key or a value.
-     */
-    families: Record<string, KvToD1Counts>;
-}
-/**
- * A copy that stopped. The message is fixed wording that names a family at
- * most, never a key or value, and the binding's own error is not attached:
- * KV and D1 errors can quote either. Entries before `cursor` are copied;
- * rerunning from it is safe while the maintenance window still holds.
- */
-export declare class KvToD1CopyError extends Error {
-    /** Resume point; absent means start over, which is also safe. */
-    readonly cursor: string | undefined;
-    readonly name = "KvToD1CopyError";
-    constructor(message: string, 
-    /** Resume point; absent means start over, which is also safe. */
-    cursor: string | undefined);
-}
-/** Mark cutover before reopening traffic. The marker stays in D1 permanently. */
-export declare function markKvToD1Live(db: D1DatabaseBinding, source: string): Promise<void>;
-/**
- * Copy live KV entries verbatim while all writers and traffic are stopped.
- * A live D1 row is kept unless its family is explicitly allowed to overwrite.
- * `verify` reads hashes and absolute expiries without changing copied entries.
- * Results contain counts only. Resume tokens are source-bound atomic claims.
- */
-export declare function copyKvToD1(kv: KVNamespaceBinding, db: D1DatabaseBinding, options: KvToD1CopyOptions): Promise<KvToD1CopyResult>;
 export {};