@zackbart/connecta 0.34.0 → 0.35.0

package/dist/providers/_shared/google/workspace.js

@@ -2,7 +2,7 @@
  * Google Workspace access as the person calling, with no per-user consent:
  * a service account with domain-wide delegation mints a token *as* the user
  * the deployment maps the admitted caller to. The foundation each Workspace
- * product provider (`gmail()` first) builds on; never its own export.
+ * product provider builds on; never its own export.
  *
  * Whose account. `ConnectorContext` carries no identity, and a deployment's
  * own connector never learns its caller (`src/connector-caller.ts`). A
@@ -25,11 +25,9 @@
  * answers `undefined` for, fails `auth_required` before anything leaves the
  * host. Catalogs need no subject: tools are static.
  *
- * A product builds on three calls: `workspaceConnection(factory, options)` at
- * construction, `googleWorkspaceClient({...})` once, and the client's `json`,
- * `bytes`, or `text` per request — plus `googleReasonsOf(error)` where a
- * product must decide on a Google reason the shared mapping leaves generic.
- * Nothing else here is the products' to touch.
+ * This module owns shared options, connection parsing and subject resolution.
+ * `kit.ts` builds the delegated grant, Google error mapping and request adapter
+ * on these foundations; `service-account.ts` owns token exchange and caching.
  *
  * Setup, once per Workspace, shared by every product:
  *
@@ -51,17 +49,15 @@
  *    admitted identity to a Workspace address in `subject`. Give each pool
  *    agents use an `owner`, the address they act as there.
  */
-import { guardedFetch, retryAfterMs } from "../../../connectors/guarded-fetch.js";
 import { keys, optionsOf } from "../../../config-schema.js";
 import { callerOf } from "../../../connector-caller.js";
 import { CALL_ADMISSION } from "../../../connectors/option-shapes.js";
 import { ConnectorCallError } from "../../../errors.js";
 import { isWorkspaceAddress } from "../../../workspace-address.js";
-import { tagWorkspaceSubject } from "../../../workspace-subject.js";
-import { delegatedToken, forgetDelegatedToken, parseServiceAccount, } from "./service-account.js";
+import { parseServiceAccount } from "./service-account.js";
 /** The closed options every Workspace provider accepts; see `assertKnownOptions`. */
 export const GOOGLE_WORKSPACE_OPTIONS = optionsOf()({
-    ...keys("purpose", "subject", "title", "instructions", "maxResultBytes", "baseUrl"),
+    ...keys("purpose", "subject", "title", "instructions", "maxResultBytes", "baseUrl", "readOnly"),
     // A string is the key's JSON; only the object form has keys to check.
     serviceAccount: optionsOf()(keys("clientEmail", "privateKey", "clientId")),
     callAdmission: CALL_ADMISSION,
@@ -84,19 +80,11 @@ export function workspaceConnection(factory, options) {
     }
     return { purpose, account, subject };
 }
-/**
- * Tag a built Workspace connector with whose account it acts as, so the
- * operator matrix can say "humans act as themselves, agents as the pool
- * owner" for a mapping, or name a fixed subject (#837). Returns it unchanged.
- */
-export function workspaceConnector(connection, connector) {
-    return tagWorkspaceSubject(connector, connection.subject);
-}
 /**
  * The Workspace address this call acts as, resolved from config and the
  * admitted caller only. Throws before any network call when there is none.
  */
-async function subjectFor(provider, subject, ctx) {
+export async function subjectFor(provider, subject, ctx) {
     if (typeof subject === "string")
         return subject;
     const caller = callerOf(ctx);
@@ -135,410 +123,3 @@ async function subjectFor(provider, subject, ctx) {
     }
     return mapped.trim();
 }
-// --- API failures ------------------------------------------------------------------
-function asRecord(value) {
-    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function asArray(value) {
-    return Array.isArray(value) ? value : [];
-}
-/**
- * The machine-readable reasons in a Google API error body: the legacy
- * `errors[].reason`, the AIP-193 `details[].reason`, and the canonical
- * `status`. Classification reads these and nothing else; `message` is prose
- * for the reader.
- */
-function reasonsOf(error) {
-    const reasons = new Set();
-    for (const entry of [...asArray(error["errors"]), ...asArray(error["details"])]) {
-        const reason = asRecord(entry)["reason"];
-        if (typeof reason === "string")
-            reasons.add(reason);
-    }
-    if (typeof error["status"] === "string")
-        reasons.add(error["status"]);
-    return reasons;
-}
-/** The canonical and legacy spellings of a refused precondition. */
-const PRECONDITION_REASONS = ["FAILED_PRECONDITION", "failedPrecondition"];
-/** Concurrency aborts, which a revision-checked write also answers with. */
-const ABORTED_REASONS = ["ABORTED", "aborted"];
-/** A reason token as Google spells one; anything else is not passed on. */
-const REASON_TOKEN = /^[A-Za-z0-9_.]{1,64}$/;
-/** More than this many reasons on one error is noise, not information. */
-const MAX_REASONS = 8;
-/** Google's reasons for each failure this layer mapped, beside the error. */
-const googleReasons = new WeakMap();
-/**
- * Google's machine-readable reasons for a failure the shared client mapped:
- * `errors[].reason`, `details[].reason`, and the canonical `status`, in that
- * order, deduplicated, at most eight, and only tokens of `[A-Za-z0-9_.]` up to
- * 64 characters — never a message or any other part of the payload. An empty
- * array for anything else, including a failure that never reached Google.
- *
- * For a product that needs a decision the shared mapping does not make, such
- * as Drive telling `cannotDownloadAbusiveFile` from another refusal. Classify
- * on these, never on the error's message.
- */
-export function googleReasonsOf(error) {
-    return error instanceof ConnectorCallError ? (googleReasons.get(error) ?? []) : [];
-}
-const googleOutcomes = new WeakMap();
-function outcome(error, facts) {
-    if (error !== null && typeof error === "object")
-        googleOutcomes.set(error, Object.freeze({ ...facts }));
-    return error;
-}
-/**
- * How far the request behind a failure from `json`, `bytes`, or `text` got —
- * see {@link GoogleOutcome}. `undefined` for anything the client did not
- * throw. Read it beside the error, the way `googleReasonsOf` is read; the
- * error itself already carries the right retry verdict.
- */
-export function googleOutcomeOf(error) {
-    return error !== null && typeof error === "object" ? googleOutcomes.get(error) : undefined;
-}
-function apiFailure(context, status, headers, payload, options) {
-    const failure = classifyApiFailure(context, status, headers, payload, options);
-    const error = asRecord(asRecord(payload)["error"]);
-    const reasons = [...reasonsOf(error)].filter((reason) => REASON_TOKEN.test(reason)).slice(0, MAX_REASONS);
-    googleReasons.set(failure, Object.freeze(reasons));
-    return failure;
-}
-function classifyApiFailure(context, status, headers, payload, options) {
-    const { provider, api, scopes } = context;
-    const error = asRecord(asRecord(payload)["error"]);
-    const message = typeof error["message"] === "string" ? error["message"].trim().slice(0, 500) : "";
-    const detail = message ? `${provider}: ${message}` : `${provider} returned HTTP ${status}.`;
-    const reasons = reasonsOf(error);
-    const precondition = PRECONDITION_REASONS.some((reason) => reasons.has(reason));
-    // Order matters. Google's own specific reasons decide first, whatever the
-    // status and whatever the request asked for: a guarded write refused
-    // because the API is off, or because of a quota, must not read as "re-read
-    // and retry". Only a refused precondition or an abort with nothing more
-    // specific to say is left for the revision guard, then for the status.
-    if (status === 401) {
-        return new ConnectorCallError("auth_required", `${detail} Google rejected a freshly minted delegated token. The domain-wide delegation grant or the service account may have been revoked.`);
-    }
-    // The API is off in the service account's project.
-    if (reasons.has("accessNotConfigured") || reasons.has("SERVICE_DISABLED")) {
-        return new ConnectorCallError("connector_call_failed", `${detail} The ${api} is not enabled in the service account's Google Cloud project; an operator enables it there.`, { retryable: false });
-    }
-    if (status === 429 ||
-        reasons.has("rateLimitExceeded") ||
-        reasons.has("userRateLimitExceeded") ||
-        reasons.has("RATE_LIMIT_EXCEEDED")) {
-        const wait = retryAfterMs(headers);
-        return new ConnectorCallError("rate_limited", `${detail} Google meters this API per user and per project; wait before retrying.`, wait === undefined ? {} : { retryAfterMs: wait });
-    }
-    if (reasons.has("insufficientPermissions") || reasons.has("ACCESS_TOKEN_SCOPE_INSUFFICIENT")) {
-        return new ConnectorCallError("provider_permission_denied", `${detail} The delegated token lacks a scope this call needs. The Admin console's domain-wide delegation entry must list exactly: ${scopes.join(",")}.`);
-    }
-    // Where Google names the refusal precisely, so does the message.
-    if (reasons.has("exportSizeLimitExceeded")) {
-        return new ConnectorCallError("connector_call_failed", `${detail} The item is larger than Google will export in this format. Download the original file instead, or export a smaller part.`, { retryable: false });
-    }
-    if (reasons.has("domainPolicy")) {
-        return new ConnectorCallError("provider_permission_denied", `${detail} A Workspace domain policy forbids this action for this account; only a Workspace administrator can change that.`, { retryable: false });
-    }
-    if (reasons.has("insufficientFilePermissions") || reasons.has("forbidden")) {
-        return new ConnectorCallError("provider_permission_denied", `${detail} This account does not have the permission on this item that the action needs — it may be shared view-only, or not shared with this user. Its owner can grant more.`, { retryable: false });
-    }
-    // A write that named the revision it was made against hears "the item moved
-    // on" as a refused precondition or an abort. Fixed words, so no provider
-    // ever matches on Google's prose or on this file's.
-    if (options.revisionGuarded === true &&
-        (status === 400 || status === 409) &&
-        (precondition || ABORTED_REASONS.some((reason) => reasons.has(reason)))) {
-        return new ConnectorCallError("conflict", `${provider} refused the write because the item changed after the revision it named. Re-read it for the current revision, reapply the change, and retry.`);
-    }
-    if (status === 403) {
-        return new ConnectorCallError("provider_permission_denied", `${detail} Google refused the request; the account may lack access to this item, or a Workspace policy may block it. Google does not say which. Ask the item owner to grant access or a Workspace administrator to review the policy.`, { retryable: false });
-    }
-    if (status === 404) {
-        return context.notFound === "absent"
-            ? new ConnectorCallError("not_found", `${detail} Re-read the id from a list or search tool.`)
-            : new ConnectorCallError("connector_call_failed", `${detail} The id is unknown or not visible to this account; Google does not distinguish them.`, { retryable: false });
-    }
-    // Google uses the same reason for a product switched off for this user
-    // (Gmail's "Mail service not enabled") and for a stale write, so the
-    // classification asserts neither; Google's own message says which.
-    if (status === 400 && precondition) {
-        return new ConnectorCallError("connector_call_failed", `${detail} Google refused the request's precondition; its message says which.`, { retryable: false });
-    }
-    if (status === 400 || status === 422) {
-        return new ConnectorCallError("invalid_args", detail);
-    }
-    if (status >= 500) {
-        const wait = retryAfterMs(headers);
-        return new ConnectorCallError("unavailable", `${detail} Google is failing upstream.`, wait === undefined ? {} : { retryAfterMs: wait });
-    }
-    return new ConnectorCallError("connector_call_failed", detail, { retryable: false });
-}
-/** The token the API refused, carried out of the mapper for one replay. */
-class TokenRejected extends Error {
-    failure;
-    constructor(failure) {
-        super(failure.message);
-        this.failure = failure;
-    }
-}
-/** A Range request against an empty file: Google's verified "nothing here". */
-function isEmptyRange(response) {
-    return response.status === 416 && /^bytes \*\/0$/i.test(response.headers.get("content-range")?.trim() ?? "");
-}
-function charsetOf(contentType) {
-    return /charset="?([^";\s]+)"?/i.exec(contentType ?? "")?.[1] ?? "utf-8";
-}
-/** Build the delegated, confined, Google-error-mapped transport for one product. */
-export function googleWorkspaceClient(options) {
-    const { provider, scopes, connection } = options;
-    const failure = {
-        provider,
-        api: options.api,
-        scopes,
-        notFound: options.notFound,
-    };
-    // One resolution per call context: a tool that sends several requests acts
-    // as one account throughout, and the mapping runs once rather than per
-    // request. The context dies with its call, and so does the entry.
-    const subjects = new WeakMap();
-    const tokenRequest = async (ctx) => {
-        let subject = subjects.get(ctx);
-        if (!subject) {
-            subject = subjectFor(provider, connection.subject, ctx);
-            subjects.set(ctx, subject);
-        }
-        return { account: connection.account, subject: await subject, scopes };
-    };
-    // The transport is bound to one token, so the request that a 401 answers
-    // names exactly the token to forget. Building one validates the base URL
-    // and ceiling at construction, where a structural mistake belongs.
-    const transport = (token, facts = { dispatched: false }) => guardedFetch({
-        provider,
-        baseUrl: options.baseUrl,
-        maxResponseBytes: options.maxResponseBytes,
-        authenticate: () => ({ Authorization: `Bearer ${token}` }),
-        // The one place a request leaves and an answer arrives, recorded as
-        // they happen so a failure can say how far the request got.
-        fetch: async (url, init) => {
-            facts.dispatched = true;
-            const response = await fetch(url, init);
-            // Recorded before the transport validates anything: a ceiling or a
-            // redirect check can fail an answer, but not change what it said.
-            facts.status = response.status;
-            facts.headers = response.headers;
-            return response;
-        },
-    });
-    transport("");
-    /**
-     * What a failure means for a request that may have changed something. A
-     * write Google accepted, or one that left with no answer, may have landed:
-     * telling the agent to retry it invites a duplicate, so it is reported as
-     * an uncertain outcome that is not retried — the same verdict core reaches
-     * for a program write (`write_outcome_unknown`). A read is safe to
-     * repeat and keeps its retryable classification.
-     */
-    /**
-     * A 5xx answering a write that is not idempotent. Google can fail after a
-     * change commits, so "unavailable, retry" would invite a duplicate insert
-     * or a second draft: the outcome is unknown and the write is not retried,
-     * whatever reason the 5xx names. Its reasons stay readable beside it.
-     */
-    function serverErrorOnWrite(mapped, status, method, requestOptions) {
-        // Any 5xx, whatever reason it names: a quota reason on a 503 does not
-        // prove the write was turned away before it committed. Only a 429, or a
-        // 4xx naming a quota, is a rejection that applied nothing.
-        if (status < 500 || method === "GET" || requestOptions.idempotent === true) {
-            return undefined;
-        }
-        const unknown = new ConnectorCallError("connector_call_failed", `${provider} answered HTTP ${status} after receiving the request, so its outcome is unknown — it may have been applied. Re-read its target before repeating it.`, { retryable: false, cause: mapped });
-        const reasons = googleReasons.get(mapped);
-        if (reasons)
-            googleReasons.set(unknown, reasons);
-        return unknown;
-    }
-    // The errors built below keep no cause: a stream's or parser's error can
-    // quote the body it failed on, and the phase and status already say what
-    // happened (#695).
-    function settled(error, facts, method, ctx, requestOptions) {
-        const write = method !== "GET";
-        const status = facts.status;
-        if (facts.serverError) {
-            return outcome(error, { dispatched: true, phase: "server-error", ...(status === undefined ? {} : { status }) });
-        }
-        if (facts.refused) {
-            return outcome(error, { dispatched: true, phase: "refused", ...(status === undefined ? {} : { status }) });
-        }
-        // An error status keeps its meaning whatever went wrong reading its body
-        // — a body past the ceiling, a stream that broke off: the status alone
-        // still says what to do next.
-        if (status !== undefined && status >= 400 && !ctx.signal?.aborted) {
-            const mapped = apiFailure(failure, status, facts.headers ?? new Headers(), undefined, requestOptions);
-            const unknown = serverErrorOnWrite(mapped, status, method, requestOptions);
-            return unknown
-                ? outcome(unknown, { dispatched: true, status, phase: "server-error" })
-                : outcome(mapped, { dispatched: true, status, phase: "refused" });
-        }
-        if (!facts.dispatched)
-            return outcome(error, { dispatched: false, phase: "before-send" });
-        // The caller's own cancellation is core's to classify, not this layer's —
-        // but what Google had already said by then is still what it said.
-        if (ctx.signal?.aborted) {
-            const phase = status === undefined
-                ? "awaiting-response"
-                : status >= 500 && write && requestOptions.idempotent !== true
-                    ? "server-error"
-                    : status >= 400
-                        ? "refused"
-                        : status >= 300
-                            ? "redirected"
-                            : "reading-body";
-            return outcome(error, { dispatched: true, phase, ...(status === undefined ? {} : { status }) });
-        }
-        if (status === undefined) {
-            const mapped = write
-                ? new ConnectorCallError("connector_call_failed", `${provider} was sent the request but no answer came back, so it may or may not have been applied. Re-read its target before repeating it.`, { retryable: false })
-                : error;
-            return outcome(mapped, { dispatched: true, phase: "awaiting-response" });
-        }
-        // A redirect, which the transport refuses to follow. It shows neither
-        // that a write applied nor that it did not, so a write's outcome is
-        // unknown — never "probably applied". A read keeps the transport's own
-        // refusal.
-        if (status >= 300 && status < 400) {
-            const redirected = write
-                ? new ConnectorCallError("connector_call_failed", `${provider} answered HTTP ${status} with a redirect, which this connection does not follow, so whether the request was applied is unknown. Re-read its target before repeating it.`, { retryable: false })
-                : error;
-            return outcome(redirected, { dispatched: true, status, phase: "redirected" });
-        }
-        // Google accepted the request — a 2xx — and its reply broke off,
-        // overflowed, or would not parse.
-        const mapped = write
-            ? new ConnectorCallError("connector_call_failed", `${provider} accepted the request but its reply could not be read; the change probably applied. Re-read before repeating it.`, { retryable: false })
-            : error instanceof ConnectorCallError
-                ? error
-                : new ConnectorCallError("unavailable", `${provider}'s reply broke off while it was being read; reading again is safe.`);
-        return outcome(mapped, { dispatched: true, status, phase: "reading-body" });
-    }
-    async function call(request, ctx, accept, read, requestOptions = {}) {
-        // A 401 is answered by sending the same request again, so its body must
-        // survive being sent twice. A stream is consumed by the first send; it
-        // is a provider's wiring mistake, refused before anything leaves.
-        if (typeof ReadableStream !== "undefined" && request.rawBody instanceof ReadableStream) {
-            throw outcome(new TypeError(`${provider}: a Workspace request body must be replayable — pass a string, Uint8Array, ArrayBuffer, Blob, FormData, or URLSearchParams, never a ReadableStream.`), { dispatched: false, phase: "before-send" });
-        }
-        const headed = { ...request, headers: { Accept: accept, ...request.headers } };
-        for (let attempt = 0;; attempt += 1) {
-            const facts = { dispatched: false };
-            let delegated;
-            let token;
-            try {
-                // Subject first: no caller, or no mapped account, fails before any
-                // token is minted or request sent.
-                delegated = await tokenRequest(ctx);
-                token = await delegatedToken(delegated, ctx);
-            }
-            catch (error) {
-                throw outcome(error, { dispatched: false, phase: "before-send" });
-            }
-            try {
-                return await transport(token, facts)(headed, ctx, async (response) => {
-                    // Every 3xx — the ones the transport refuses and the 300, 304, 305,
-                    // and 306 it lets through — is a redirect before it is anything
-                    // else: no body or reason it carries makes it a refusal.
-                    if (response.status >= 300 && response.status < 400) {
-                        throw new ConnectorCallError("connector_call_failed", `${provider} answered HTTP ${response.status} with a redirect; this connection talks to exactly one origin and never forwards its credential to another.`, { retryable: false });
-                    }
-                    // A bounded read answers an empty file's 416 as an empty result.
-                    if (!response.ok && !(headed.prefixOnly === true && isEmptyRange(response))) {
-                        const parsed = await response.jsonResult();
-                        const payload = "value" in parsed ? parsed.value : undefined;
-                        const mapped = apiFailure(failure, response.status, response.headers, payload, requestOptions);
-                        const unknown = serverErrorOnWrite(mapped, response.status, headed.method, requestOptions);
-                        if (unknown) {
-                            facts.serverError = true;
-                            throw unknown;
-                        }
-                        facts.refused = true;
-                        throw response.status === 401 ? new TokenRejected(mapped) : mapped;
-                    }
-                    return await read(response);
-                });
-            }
-            catch (error) {
-                // Every 401 Google sent earns the refresh and the one replay, whether
-                // its body was read or failed the transport's checks first: what the
-                // status said about the token does not depend on the body.
-                // A caller that has left gets neither: the 401 it saw is reported as
-                // it was, and no new token is minted for a request nobody awaits.
-                const failed = error instanceof TokenRejected ? error.failure : error;
-                const unauthorized = !ctx.signal?.aborted && (error instanceof TokenRejected || facts.status === 401);
-                if (!unauthorized)
-                    throw settled(failed, facts, headed.method, ctx, requestOptions);
-                // Only the token this request carried; a newer one stays.
-                await forgetDelegatedToken(delegated, token);
-                if (attempt > 0 || ctx.signal?.aborted) {
-                    throw settled(failed, facts, headed.method, ctx, requestOptions);
-                }
-            }
-        }
-    }
-    return {
-        json: (request, ctx, requestOptions) => call(request, ctx, "application/json", async (response) => {
-            // Read first, parse second: a body that breaks off while it is being
-            // read is a transport failure (a GET may read again), and only text
-            // that arrived whole and still is not JSON is malformed.
-            const body = await response.text();
-            if (body.trim() === "")
-                return undefined;
-            try {
-                return JSON.parse(body);
-            }
-            catch {
-                throw new ConnectorCallError("connector_call_failed", `${provider} returned a successful response that is not JSON.`, { retryable: false });
-            }
-        }, requestOptions),
-        bytes: (request, ctx, accept = "*/*", requestOptions) => read(request, ctx, accept, requestOptions),
-        text: async (request, ctx, accept = "text/plain, */*", requestOptions) => {
-            const { bytes, ...rest } = await read(request, ctx, accept, requestOptions);
-            let text;
-            try {
-                // A cut prefix may end inside a code point; streaming decode drops
-                // the incomplete tail instead of inventing a replacement character.
-                text = new TextDecoder(charsetOf(rest.contentType)).decode(bytes, { stream: rest.truncated });
-            }
-            catch {
-                text = new TextDecoder().decode(bytes, { stream: rest.truncated });
-            }
-            return { text, ...rest };
-        },
-    };
-    /** The body as bytes: whole, or a bounded prefix when `maxBytes` is set. */
-    async function read(request, ctx, accept, requestOptions = {}) {
-        const { maxBytes } = requestOptions;
-        if (maxBytes !== undefined && (!Number.isInteger(maxBytes) || maxBytes < 0)) {
-            throw outcome(new TypeError(`${provider}: maxBytes must be a whole number of bytes, zero or more.`), {
-                dispatched: false,
-                phase: "before-send",
-            });
-        }
-        const bounded = maxBytes !== undefined;
-        return call(bounded ? { ...request, prefixOnly: true } : request, ctx, accept, async (response) => {
-            const facts = {
-                contentType: response.headers.get("content-type") ?? undefined,
-                status: response.status,
-                contentRange: response.headers.get("content-range") ?? undefined,
-            };
-            if (!bounded)
-                return { bytes: await response.bytes(), truncated: false, ...facts };
-            if (!response.ok) {
-                // Only the empty-file 416 reaches here; its body is not the file.
-                await response.prefix(0);
-                return { bytes: new Uint8Array(), truncated: false, ...facts };
-            }
-            return { ...(await response.prefix(maxBytes)), ...facts };
-        }, requestOptions);
-    }
-}

package/dist/providers/_shared/rest/compact-index.js

@@ -0,0 +1,86 @@
+// Physical decode ceiling, independent of request/schema/discovery budgets.
+const MAX_TEXT = 64 * 1024 * 1024;
+const parsers = new WeakMap();
+function limit(length) {
+    if (!Number.isSafeInteger(length) || length < 0 || length > MAX_TEXT)
+        throw new Error("Invalid compact index length.");
+}
+function rowText(packed, row) {
+    if (row === 0)
+        return "0";
+    const [ids, body] = row;
+    let length = body.length + 5; // [[params],body]
+    limit(length);
+    const parameters = [];
+    for (const id of ids) {
+        if (!Number.isSafeInteger(id) || id < 0 || typeof packed.parameters[id] !== "string")
+            throw new Error("Invalid compact index parameter reference.");
+        const text = packed.parameters[id];
+        length += text.length + (parameters.length ? 1 : 0);
+        limit(length);
+        parameters.push(text);
+    }
+    return `[[${parameters.join(",")}],${body}]`;
+}
+/** Recreate the exact old JSON string, for semantic identity/cursor binding. */
+export function expandIndexDetails(packed) {
+    limit(packed.length);
+    let length = packed.definitions.length + 13; // {"d":defs,"o":[]}
+    limit(length);
+    const rows = [];
+    for (const row of packed.operations) {
+        const text = rowText(packed, row);
+        length += text.length + (rows.length ? 1 : 0);
+        if (length > packed.length)
+            throw new Error("Compact index length exceeded.");
+        rows.push(text);
+    }
+    if (length !== packed.length)
+        throw new Error("Compact index length mismatch.");
+    return `{"d":${packed.definitions},"o":[${rows.join(",")}]}`;
+}
+/** Preserve OpenApiData's logical shape; decode no schema during construction. */
+export function compactOpenApi(metadata, packed) {
+    const { fields, requestSchemas, ...base } = metadata;
+    const data = base;
+    const get = () => expandIndexDetails(packed);
+    Object.defineProperty(data, "details", {
+        enumerable: true,
+        configurable: true,
+        get,
+        set(value) {
+            Object.defineProperty(data, "details", { value, writable: true, enumerable: true, configurable: true });
+        },
+    });
+    if (Object.hasOwn(metadata, "fields"))
+        Object.assign(data, { fields });
+    if (Object.hasOwn(metadata, "requestSchemas"))
+        Object.assign(data, { requestSchemas });
+    parsers.set(data, () => {
+        // Direct callers may replace the logical property before construction.
+        if (Object.getOwnPropertyDescriptor(data, "details")?.get !== get)
+            return JSON.parse(data.details);
+        limit(packed.length);
+        limit(packed.definitions.length);
+        const o = [];
+        for (let row = 0; row < packed.operations.length; row++) {
+            Object.defineProperty(o, row, {
+                enumerable: true,
+                configurable: true,
+                get() {
+                    // A separate parse for each occurrence preserves the old object
+                    // identity/mutation behaviour even when parameter text is shared.
+                    const value = JSON.parse(rowText(packed, packed.operations[row]));
+                    Object.defineProperty(o, row, { value, writable: true, enumerable: true, configurable: true });
+                    return value;
+                },
+            });
+        }
+        return { d: JSON.parse(packed.definitions), o };
+    });
+    return data;
+}
+/** Each OperationIndex owns its parsed values; kit indexes keep JSON.parse. */
+export function parseIndexDetails(data) {
+    return parsers.get(data)?.() ?? JSON.parse(data.details);
+}

package/dist/providers/_shared/rest/dispatch.js

@@ -1,9 +1,3 @@
-// Auth selects the implementation (decisions/0005): a `"dual"` provider sends
-// OAuth to the vendor's hosted MCP server and a key to Connecta's own REST
-// connector. The choice is made once, at construction, from `auth.type`; one
-// connector id is one implementation, and a failure on one is never replayed
-// against the other (INV-9).
-import { remoteMcp } from "../../../connectors/remote-mcp.js";
 /**
  * A provider `create` that dispatches on `options.auth.type`. Pair it with
  * `variants(["auth", "type"], …)` options, which refuse a missing or unknown
@@ -15,27 +9,13 @@ export function byAuth(cases) {
         const create = typeof type === "string" && Object.hasOwn(cases, type) ? cases[type] : undefined;
         if (!create) {
             throw new Error(`auth.type must be one of ${Object.keys(cases)
+                .filter((name) => cases[name] !== removedHostedMcp)
                 .map((name) => JSON.stringify(name))
                 .join(", ")}.`);
         }
         return create(id, options, provider);
     };
 }
-/**
- * The vendor's hosted MCP server, OAuth only: no bearer token, header, or
- * operator credential reaches a hosted endpoint. The provider's reviewed
- * classification classifies its catalog.
- */
-export function hostedOAuth(id, provider, options) {
-    return remoteMcp(id, {
-        url: options.url,
-        ...provider.connectorOptions,
-        title: options.title,
-        description: options.description,
-        auth: { type: "oauth" },
-        requireHttps: true,
-        classify: provider.classify,
-        ...(options.callAdmission ? { callAdmission: options.callAdmission } : {}),
-        usageGuide: options.usageGuide,
-    });
+export function removedHostedMcp() {
+    throw new Error("remoteMcp() with ConnectaConfig.classification for hosted MCP connections; use a distinct id beside the API connector.");
 }