@zackbart/connecta 0.35.0 → 0.36.1

package/dist/program-writes.js

@@ -4,7 +4,6 @@ import { CONFIG_DEFAULTS } from "./config-defaults.js";
 import { Effect } from "effect";
 import { jsonResult } from "./meta-tools.js";
 import { classifyWriteOutcome } from "./write-outcome.js";
-export { classifyWriteOutcome } from "./write-outcome.js";
 /** Writes one program may send (`execute.maxWrites`), unless configured. */
 export const DEFAULT_MAX_WRITES = CONFIG_DEFAULTS.execute.maxWrites;
 /** What a dispatched write's outcome says about whether it landed. */

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

@@ -5,17 +5,14 @@
 // This module adds what every product needs: the Google error
 // table, the delegated machine grant, a value-safety resolver over the
 // product's own operations, a request adapter that keeps the legacy request
-// bytes and write wording, and the step-1 catalog bridge.
-import { Effect, Option, Schema } from "effect";
-import { callClassification } from "../../../call-classification.js";
+// bytes, and failure phases for product recovery.
+import { Effect, Option } from "effect";
 import { deriveContext } from "../../../derived-context.js";
 import { ConnectorCallError } from "../../../errors.js";
-import { attachFailureFacts } from "../../../operator-record.js";
 import { Refusal, StatusFailure, toConnectorCallError, } from "../../../http/errors.js";
 import { Classification, Dispatches, Signal } from "../../../http/services.js";
-import { read, write } from "../../../http/tools.js";
 import { callMemo, Operation } from "../../../runtime/call.js";
-import { providerFailureMessage, unsentAfterUnauthorized } from "../../../write-outcome.js";
+import { providerFailureMessage } from "../../../write-outcome.js";
 import { delegatedToken, forgetDelegatedToken } from "./service-account.js";
 import { subjectFor, workspaceConnection } from "./workspace.js";
 import { tagWorkspaceSubject } from "../../../workspace-subject.js";
@@ -349,40 +346,18 @@ function queryPairs(query) {
     }
     return pairs;
 }
-/**
- * Words the legacy client gave a served write whose answer proves nothing:
- * no answer, a 5xx, a redirect, or a 2xx whose reply could not be read. Only
- * the message and retry flag are its; the core still decides the outcome,
- * which for each of these is unknown.
- */
-function unknownWrite(message, status) {
-    return new Refusal({
-        error: attachFailureFacts(new ConnectorCallError("connector_call_failed", message, { retryable: false }), status === undefined ? {} : { httpStatus: status }),
-    });
-}
-export function googleClient(connection, provider, configuration = {}) {
-    if (configuration.standard || configuration.index)
-        requireGoogleIndex(configuration.index);
+export function googleClient(connection, index) {
+    requireGoogleIndex(index);
     const send = (request, accept, options, binary = false) => Effect.gen(function* () {
-        if (configuration.index) {
-            yield* Effect.try({
-                try: () => {
-                    if (!request.template)
-                        throw new ConnectorCallError("invalid_args", "This indexed Google named request needs its declared operation template.");
-                    googleNamedOperation(configuration.index, request.method, request.path, request.template);
-                },
-                catch: (error) => new Refusal({ error: error }),
-            });
-        }
-        const active = yield* Effect.serviceOption(Operation);
-        const callWrite = (yield* Classification) === "write";
+        yield* Effect.try({
+            try: () => {
+                if (!request.template)
+                    throw new ConnectorCallError("invalid_args", "This indexed Google named request needs its declared operation template.");
+                googleNamedOperation(index, request.method, request.path, request.template);
+            },
+            catch: (error) => new Refusal({ error: error }),
+        });
         const dispatches = yield* Dispatches;
-        const signal = yield* Signal;
-        // Match the legacy wording rule even for direct calls: their GET
-        // lookups have no served verdict. Physical write accounting stays the
-        // core's Classification; only these Google-specific words use this.
-        const served = Option.isSome(active) && active.value ? callClassification(active.value) : undefined;
-        const write = (served ?? (request.method === "GET" ? "read" : "write")) === "write";
         const operation = yield* connection.safety.resolve(request.method, request.path);
         return yield* connection
             .sendPath({
@@ -406,73 +381,27 @@ export function googleClient(connection, provider, configuration = {}) {
             ...(options?.effect ? { effect: options.effect } : {}),
             ...(options?.step ? { step: options.step } : {}),
         })
-            .pipe(Effect.catch((failure) => Effect.fail(settled(failure, dispatches.find((entry) => entry.failure === failure), write, callWrite, signal))));
+            .pipe(Effect.catch((failure) => Effect.fail(settled(failure, dispatches.find((entry) => entry.failure === failure)))));
     });
-    function settled(failure, own, write, callWrite, signal) {
-        // A lookup inside a write call has not sent the write. Keep the lookup's
-        // own verdict; only a call-owned request gets uncertain-write wording.
-        write = write && own?.request?.auxiliary !== true;
+    function settled(failure, own) {
         const status = own?.status;
         const dispatched = own?.request?.dispatched === true;
-        const at = (phase, code = status) => ({ dispatched, phase, ...(code === undefined ? {} : { status: code }) });
         if (!dispatched)
             return noted(failure, { dispatched: false, phase: "before-send" });
-        if (configuration.standard) {
-            // Preserve phase evidence for partial-create recovery; settlement and
-            // reconciliation wording belong to the kit in standard mode.
-            const phase = failure._tag === "TransportFailure"
-                ? "awaiting-response"
-                : failure._tag === "UnreadableBody" || failure._tag === "ResponseTooLarge"
-                    ? "reading-body"
-                    : failure._tag === "RedirectRefused" || (status !== undefined && status >= 300 && status < 400)
-                        ? "redirected"
-                        : status === 401
-                            ? "unauthorized"
-                            : status !== undefined && status >= 500
-                                ? "server-error"
-                                : "refused";
-            return noted(failure, at(phase));
-        }
-        switch (failure._tag) {
-            case "StatusFailure": {
-                const code = failure.status;
-                if (code >= 300 && code < 400)
-                    return noted(write
-                        ? unknownWrite(`${provider} answered HTTP ${code} with a redirect, which this connection does not follow, so whether the request was applied is unknown. Re-read its target before repeating it.`, status)
-                        : failure, at("redirected", code));
-                if (write && code >= 500)
-                    return noted(unknownWrite(`${provider} answered HTTP ${code} after receiving the request, so its outcome is unknown — it may have been applied. Re-read its target before repeating it.`, status), at("server-error", code));
-                if (callWrite && own?.request?.auxiliary !== true && code === 401) {
-                    // Never sent again (INV-9); the next call mints a fresh token.
-                    const refusal = toConnectorCallError(failure, connection.errors, {
-                        classification: "write",
-                        dispatches: [own],
-                        withholds: connection.safety.withholdsErrors,
-                        signal,
-                    });
-                    return noted(new Refusal({ error: unsentAfterUnauthorized(provider, refusal) }), at("unauthorized", 401));
-                }
-                return noted(failure, at("refused", code));
-            }
-            case "RedirectRefused":
-                return noted(write
-                    ? unknownWrite(`${provider} answered HTTP ${failure.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.`, status)
-                    : failure, at("redirected", failure.status));
-            case "TransportFailure":
-                return noted(write
-                    ? unknownWrite(`${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.`, status)
-                    : failure, at("awaiting-response", undefined));
-            case "ResponseTooLarge":
-            case "UnreadableBody":
-                // An error status keeps its meaning whatever went wrong reading it.
-                if (status !== undefined && status >= 400)
-                    return noted(failure, at(write && status >= 500 ? "server-error" : "refused"));
-                return noted(write
-                    ? unknownWrite(`${provider} accepted the request but its reply could not be read; the change probably applied. Re-read before repeating it.`, status)
-                    : failure, at("reading-body"));
-            default:
-                return noted(failure, at("refused"));
-        }
+        // Preserve phase evidence for partial-create recovery; settlement and
+        // reconciliation wording belong to the kit.
+        const phase = failure._tag === "TransportFailure"
+            ? "awaiting-response"
+            : failure._tag === "UnreadableBody" || failure._tag === "ResponseTooLarge"
+                ? "reading-body"
+                : failure._tag === "RedirectRefused" || (status !== undefined && status >= 300 && status < 400)
+                    ? "redirected"
+                    : status === 401
+                        ? "unauthorized"
+                        : status !== undefined && status >= 500
+                            ? "server-error"
+                            : "refused";
+        return noted(failure, { dispatched, phase, ...(status === undefined ? {} : { status }) });
     }
     return {
         json: (request, options) => Effect.map(send(request, "application/json", options), (answer) => answer.data),
@@ -496,42 +425,3 @@ export function googleFailureMessage(connection, failure, message) {
         return yield* Effect.fail(outcome ? noted(reworded, outcome) : reworded);
     });
 }
-/** Arguments arrive validated against the exact legacy `inputSchema` by `api()` before any handler runs. */
-const ARGUMENTS = Schema.Record(Schema.String, Schema.Unknown);
-/**
- * The step-1 catalog bridge. The tool is a kit `read` or `write` (its
- * lease, write capacity, transport, failure mapping and result safety are
- * the kit's), but its catalog keeps the legacy declaration's bytes:
- * annotations, input and output schemas. `api()` validates every call, from
- * every entry path, against that exact input schema before the handler runs
- * (`callTool` in `src/connectors/api-connector.ts`, fail-closed), so the
- * decoder accepts whatever reaches it and keeps the caller's key order. Step
- * 2 replaces these schemas with Effect declarations (0011).
- */
-export function googleTool(connection, declaration) {
-    const { annotations } = declaration;
-    const spec = {
-        name: declaration.name,
-        description: declaration.description,
-        input: ARGUMENTS,
-        output: Schema.Unknown,
-        ...(declaration.writeSteps ? { writeSteps: declaration.writeSteps } : {}),
-        run: (args) => Effect.gen(function* () {
-            const operation = yield* Effect.serviceOption(Operation);
-            const ctx = Option.isSome(operation) ? operation.value : undefined;
-            if (!ctx)
-                return yield* Effect.die(new Error(`${declaration.name} needs the call's connector context.`));
-            return yield* declaration.run(args, ctx);
-        }).pipe(
-        // A product's own refusals are thrown ConnectorCallErrors, as on the legacy client.
-        Effect.catchDefect((defect) => defect instanceof ConnectorCallError ? Effect.fail(new Refusal({ error: defect })) : Effect.die(defect))),
-    };
-    const built = annotations.readOnlyHint === true && annotations.destructiveHint !== true
-        ? read(connection, spec)
-        : write(connection, { ...spec, destructive: annotations.destructiveHint === true });
-    return Object.assign(built, {
-        annotations: declaration.annotations,
-        inputSchema: declaration.inputSchema,
-        outputSchema: declaration.outputSchema,
-    });
-}

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

@@ -1,17 +1,9 @@
-// Step-1 REST bridge: pinned contracts and legacy hatch bytes on the provider kit.
-// The index remains the hatch validator; every network answer comes from Connection.
+// Shared REST call shapes, pinned-schema conversion and indexed vendor declarations.
 import { Effect, Schema } from "effect";
-import { IDEMPOTENCY_KEY_MAX_LENGTH } from "../../../call-recovery.js";
-import { ConnectorCallError, keyResendAdvice } from "../../../errors.js";
-import { providerFailureMessage } from "../../../write-outcome.js";
-import { Refusal, toConnectorCallError } from "../../../http/errors.js";
+import { ConnectorCallError } from "../../../errors.js";
+import { Refusal } from "../../../http/errors.js";
 import { Integer, isMinChars, isMaxChars } from "../../../http/json-schema.js";
-import { Classification, Dispatches, IdempotencyKey, Recovery, Signal, } from "../../../http/services.js";
-import { read, write } from "../../../http/tools.js";
 import { vendor as declareVendor, get, head, post, put, patch, del, } from "../../../http/vendor.js";
-const MAX_SELECT = 50;
-const READ = { readOnlyHint: true };
-const DESTRUCTIVE = { readOnlyHint: false, destructiveHint: true };
 function isRecord(value) {
     return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -36,7 +28,7 @@ export function typedParams(params) {
         return [name, value];
     }));
 }
-/** Only the JSON forms the pinned index and legacy hatch catalogs publish. No vendor encoders run here. */
+/** Convert the JSON forms published by pinned indexes. No vendor encoders run here. */
 export function schema(node) {
     const n = node;
     let out;
@@ -152,395 +144,3 @@ export function indexedVendor(name, index, named = []) {
         indexed: { operations: index.ops.map((op) => `${op.method} ${op.path}`).sort(), api: () => (built ??= build()) },
     };
 }
-function project(value, paths) {
-    const root = new Map();
-    for (const path of paths) {
-        let node = root;
-        const parts = path.split(".");
-        for (const [index, part] of parts.entries()) {
-            const existing = node.get(part);
-            // A shorter path already keeps this whole subtree.
-            if (existing === true)
-                break;
-            if (index === parts.length - 1) {
-                node.set(part, true);
-                break;
-            }
-            const next = existing ?? new Map();
-            node.set(part, next);
-            node = next;
-        }
-    }
-    const pick = (current, tree) => {
-        if (Array.isArray(current))
-            return current.map((item) => pick(item, tree));
-        if (!isRecord(current))
-            return current;
-        const out = {};
-        for (const [key, child] of tree) {
-            if (!Object.hasOwn(current, key))
-                continue;
-            out[key] = child === true ? current[key] : pick(current[key], child);
-        }
-        return out;
-    };
-    return pick(value, root);
-}
-function selected(args, result) {
-    const select = args["select"];
-    if (!Array.isArray(select) || select.length === 0)
-        return result;
-    return { ...result, data: project(result.data, select) };
-}
-function pathSchema(example = "/v1/customers/cus_123") {
-    return {
-        type: "string",
-        minLength: 2,
-        maxLength: 2048,
-        description: `Concrete path from search with ids filled in, e.g. ${example}. No query string.`,
-    };
-}
-const QUERY = {
-    type: "object",
-    description: "Query parameters as JSON, named as details lists them.",
-};
-const SELECT = {
-    type: "array",
-    maxItems: MAX_SELECT,
-    items: { type: "string", minLength: 1, maxLength: 200 },
-    description: "Dot paths to keep from data, e.g. data.id; a path through a list applies to each item.",
-};
-const PAGE = {
-    type: "object",
-    description: "Present on lists: pass next as the param query parameter (a body field when in is body) for the next page. hasMore without next: no cursor exists.",
-    properties: {
-        hasMore: { type: "boolean" },
-        next: { type: "string" },
-        param: { type: "string" },
-        in: { type: "string", enum: ["query", "body"] },
-        path: { type: "string", description: "GET this path for the next page, when it differs from this call's." },
-    },
-    required: ["hasMore"],
-};
-function envelope(extra = {}) {
-    return {
-        type: "object",
-        properties: {
-            status: { type: "integer", description: "HTTP status." },
-            data: {
-                description: "Response body: JSON, text, NDJSON rows, { contentType, bytes, base64 }, or HEAD's headers.",
-            },
-            page: PAGE,
-            ...extra,
-        },
-        required: ["status", "data"],
-    };
-}
-function closed(properties, required) {
-    return { type: "object", properties, required, additionalProperties: false };
-}
-/** Restore declaration key order only after proving the kit generated the identical schema. */
-export function catalogOrder(actual, legacy) {
-    if (Array.isArray(legacy)) {
-        if (!Array.isArray(actual) || actual.length !== legacy.length)
-            throw new Error("Kit catalog array differs from the legacy declaration.");
-        return legacy.map((value, index) => catalogOrder(actual[index], value));
-    }
-    if (isRecord(legacy)) {
-        if (!isRecord(actual) ||
-            Object.keys(actual).length !== Object.keys(legacy).length ||
-            Object.keys(legacy).some((key) => !Object.hasOwn(actual, key)))
-            throw new Error("Kit catalog keys differ from the legacy declaration.");
-        return Object.fromEntries(Object.entries(legacy).map(([key, value]) => [key, catalogOrder(actual[key], value)]));
-    }
-    if (actual !== legacy)
-        throw new Error("Kit catalog value differs from the legacy declaration.");
-    return actual;
-}
-/** Four legacy tools, with kit leases, capacity, mapping and dispatch. */
-export function restKitTools(vendor) {
-    const writeSteps = vendor.writeSteps === undefined ? undefined : Object.freeze({ ...vendor.writeSteps });
-    const { index, title } = vendor;
-    const tool = (kind) => `${vendor.vendor}_api_${kind}`;
-    const PATH = pathSchema(vendor.pathExample);
-    const headerNames = Object.keys(vendor.headers ?? {});
-    const HEADERS = headerNames.length
-        ? {
-            headers: {
-                type: "object",
-                description: "Optional request headers this vendor's operations read; nothing else is accepted.",
-                properties: Object.fromEntries(Object.entries(vendor.headers).map(([name, description]) => [
-                    name,
-                    { type: "string", minLength: 1, maxLength: 200, description },
-                ])),
-                additionalProperties: false,
-            },
-        }
-        : {};
-    const headersOf = (args) => isRecord(args["headers"]) ? { headers: args["headers"] } : {};
-    const readPosts = vendor.readPosts ?? [];
-    for (const [method, path] of readPosts) {
-        // A reviewed exception the index no longer carries is a stale review.
-        if (!index.operation(method, path)) {
-            throw new Error(`${title} reviewed read-only ${method} ${path} is not in the pinned API index.`);
-        }
-    }
-    const reads = (op) => op.method === "GET" ||
-        op.method === "HEAD" ||
-        readPosts.some(([method, path]) => method === op.method && path === op.path);
-    const writeMethods = index.methods.filter((method) => method !== "GET" && method !== "HEAD");
-    // The methods an idempotency key is sent with: never DELETE (see the handler).
-    const keyed = vendor.idempotencyHeader ? writeMethods.filter((method) => method !== "DELETE") : [];
-    const keyedText = keyed.join(" or ");
-    const head = index.methods.includes("HEAD");
-    const readMethods = [...new Set(["GET", ...(head ? ["HEAD"] : []), ...readPosts.map(([method]) => method)])];
-    const routeOf = (op) => (reads(op) ? tool("read") : tool("write"));
-    const guard = (call) => {
-        const server = vendor.checkServer?.(call.op.server);
-        if (server)
-            invalid(server);
-        const refusal = vendor.valueSafety.refusal(call.method, call.op.path) ?? vendor.refuse?.(call);
-        if (refusal)
-            invalid(refusal);
-    };
-    const declarations = [
-        {
-            name: tool("search"),
-            description: `Find ${title} API operations by keyword or path in the pinned API index. Returns method, path, and summary; reads no account data.`,
-            annotations: READ,
-            inputSchema: closed({
-                query: {
-                    type: "string",
-                    minLength: 1,
-                    maxLength: 200,
-                    description: "Keywords or a path, e.g. refund charge.",
-                },
-                method: { type: "string", enum: [...index.methods], description: "Only operations with this method." },
-                limit: { type: "integer", minimum: 1, maximum: 50, description: "Most operations to return; default 10." },
-            }, ["query"]),
-            outputSchema: {
-                type: "object",
-                properties: {
-                    operations: {
-                        type: "array",
-                        items: {
-                            type: "object",
-                            properties: {
-                                method: { type: "string" },
-                                path: { type: "string" },
-                                summary: { type: "string" },
-                                tool: { type: "string", description: "The tool that calls it." },
-                            },
-                            required: ["method", "path", "tool"],
-                        },
-                    },
-                    revision: { type: "string", description: "Pinned index revision." },
-                },
-                required: ["operations", "revision"],
-            },
-        },
-        {
-            name: tool("details"),
-            description: `Read one ${title} API operation's request contract: path, query, and body parameters with types, enums, and required names. Reads no account data.`,
-            annotations: READ,
-            inputSchema: closed({
-                method: { type: "string", enum: [...index.methods], description: "The operation's HTTP method." },
-                path: { ...PATH, description: "The path template from search, or a concrete path." },
-                param: { type: "string", minLength: 1, maxLength: 200, description: "Return only this parameter." },
-            }, ["method", "path"]),
-            outputSchema: {
-                type: "object",
-                properties: {
-                    method: { type: "string" },
-                    path: { type: "string" },
-                    tool: { type: "string", description: "The tool that calls it." },
-                    parameters: { type: "array", description: "Path and query parameters." },
-                    body: {
-                        type: "object",
-                        description: "Body content type and schema; truncated: true marks unexpanded levels.",
-                    },
-                    revision: { type: "string" },
-                },
-                required: ["method", "path", "tool", "parameters", "revision"],
-            },
-        },
-        {
-            name: tool("read"),
-            description: `Call a ${title} API GET${head ? " or HEAD" : ""} operation${readPosts.length ? ", or a reviewed read-only POST" : ""}. ` +
-                "Arguments are checked against the pinned index before anything is sent.",
-            annotations: READ,
-            inputSchema: closed({
-                path: PATH,
-                ...(readMethods.length > 1
-                    ? {
-                        method: {
-                            type: "string",
-                            enum: readMethods,
-                            description: "GET by default; another method only for an operation search routes here.",
-                        },
-                    }
-                    : {}),
-                ...(readPosts.length
-                    ? {
-                        body: {
-                            type: vendor.textBodies ? ["object", "string"] : "object",
-                            description: `Body for a reviewed read-only POST${vendor.textBodies ? "; a string for a text-framed operation" : ""}.`,
-                        },
-                    }
-                    : {}),
-                query: QUERY,
-                ...HEADERS,
-                select: SELECT,
-            }, ["path"]),
-            outputSchema: envelope(),
-        },
-        {
-            name: tool("write"),
-            description: `Call a ${title} API write (${writeMethods.join(", ")}); method and path are stated for approval. ` +
-                `Checked against the pinned index first.${keyed.length ? ` Pass idempotencyKey to retry a ${keyedText} safely${keyed.length < writeMethods.length ? "; a DELETE sends no key" : ""}.` : ""}`,
-            annotations: DESTRUCTIVE,
-            inputSchema: closed({
-                method: { type: "string", enum: writeMethods, description: "The operation's HTTP method." },
-                path: PATH,
-                query: QUERY,
-                body: {
-                    type: vendor.textBodies ? ["object", "array", "string"] : ["object", "array"],
-                    description: `Request body as JSON${vendor.bodyHint ? `; ${vendor.bodyHint}` : ""}.`,
-                },
-                ...HEADERS,
-                ...(vendor.idempotencyHeader
-                    ? {
-                        idempotencyKey: {
-                            type: "string",
-                            minLength: 1,
-                            maxLength: IDEMPOTENCY_KEY_MAX_LENGTH,
-                            description: `Reuse to retry this exact ${keyedText}; one is generated and returned when omitted.`,
-                        },
-                    }
-                    : {}),
-                select: SELECT,
-            }, ["method", "path"]),
-            outputSchema: envelope(vendor.idempotencyHeader
-                ? {
-                    idempotencyKey: {
-                        type: "string",
-                        description: "The key sent; reuse it, with the same arguments, while the vendor retains it.",
-                    },
-                }
-                : {}),
-        },
-    ];
-    const resolve = (args, method) => {
-        const path = vendor.path ? vendor.path(String(args["path"])) : String(args["path"]);
-        const { op, params } = index.resolve(method, path);
-        const call = {
-            method: op.method,
-            path,
-            op,
-            params,
-            query: isRecord(args["query"]) ? args["query"] : {},
-            body: args["body"],
-            ...headersOf(args),
-        };
-        return vendor.scope ? vendor.scope(call) : call;
-    };
-    const search = (args) => ({
-        operations: index
-            .search(String(args["query"]), {
-            ...(typeof args["method"] === "string" ? { method: args["method"] } : {}),
-            limit: typeof args["limit"] === "number" ? args["limit"] : 10,
-        })
-            .map((op) => ({
-            method: op.method,
-            path: op.path,
-            operationId: op.operationId,
-            summary: op.summary,
-            tag: op.tag,
-            tool: routeOf(op),
-        })),
-        revision: index.revision,
-    });
-    const details = (args) => {
-        const method = String(args["method"]), path = String(args["path"]);
-        const op = index.operation(method, path) ?? index.resolve(method, path).op;
-        return {
-            ...index.contract(op, typeof args["param"] === "string" ? args["param"] : undefined),
-            tool: routeOf(op),
-            revision: index.revision,
-        };
-    };
-    const execute = (args, writing) => checked(() => {
-        const call = resolve(args, (typeof args["method"] === "string" ? args["method"] : "GET"));
-        if (writing && (call.method === "GET" || call.method === "HEAD"))
-            invalid(`${call.method} operations are reads; call them with ${tool("read")}.`);
-        if (!writing && !reads(call.op))
-            invalid(`${call.method} ${call.op.path} is not a reviewed read; call it with ${tool("write")}.`);
-        if (!writing && (call.method === "GET" || call.method === "HEAD") && call.body !== undefined)
-            invalid(`A ${call.method} operation takes query, not body.`);
-        guard(call);
-        const framing = index.bodyType(call.op);
-        if (writing && framing && /^multipart\/|octet-stream/.test(framing))
-            invalid(`${call.method} ${call.op.path} takes a ${framing} upload, which ${tool("write")} does not send.` +
-                (vendor.upload ? ` ${vendor.upload}` : ""));
-        index.check(call.op, call.query, call.body);
-        return call;
-    }).pipe(Effect.flatMap((call) => Effect.gen(function* () {
-        const header = writing && call.method !== "DELETE" ? vendor.idempotencyHeader : undefined;
-        const given = typeof args["idempotencyKey"] === "string" ? args["idempotencyKey"] : undefined;
-        if (writing && given !== undefined)
-            yield* checked(() => {
-                const key = given.replace(/^[\t\n\r ]+|[\t\n\r ]+$/g, "");
-                if (!key)
-                    invalid("idempotencyKey is blank; pass a key with at least one non-whitespace character, or omit it.");
-                if (!/^[\t\x20-\x7e\x80-\xff]*$/.test(key))
-                    invalid("idempotencyKey contains a character an HTTP header cannot carry (a control character, or one past Latin-1); pass a printable key, or omit it.");
-            });
-        const key = header ? (given ?? crypto.randomUUID()) : undefined;
-        if (key)
-            yield* (yield* Recovery).record({ idempotencyKey: key });
-        const classification = yield* Classification, dispatches = yield* Dispatches, signal = yield* Signal;
-        return yield* vendor.send(call).pipe(Effect.provideService(IdempotencyKey, key && header ? { header, key } : undefined), Effect.map((result) => ({ ...selected(args, result), ...(key ? { idempotencyKey: key } : {}) })), Effect.catch((failure) => {
-            if (!key || given)
-                return Effect.fail(failure);
-            const error = toConnectorCallError(failure, vendor.connection.errors, {
-                classification,
-                dispatches,
-                withholds: vendor.connection.safety.withholdsErrors,
-                signal,
-            });
-            const diagnostic = providerFailureMessage(error, `${error.message} ${header}: ${key}.`);
-            const dispatched = dispatches.some((d) => d.request?.dispatched && d.request.key === key);
-            return Effect.fail(new Refusal({
-                error: dispatched
-                    ? keyResendAdvice(diagnostic, key, " Reusing it with the exact original arguments retries this write without repeating it only while the vendor retains the key; after that, look the object up before retrying.")
-                    : diagnostic,
-            }));
-        }));
-    })));
-    return declarations.map((declaration, i) => {
-        const spec = {
-            ...(writeSteps === undefined ? {} : { writeSteps }),
-            name: declaration.name,
-            description: declaration.description,
-            input: schema(declaration.inputSchema),
-            output: schema(declaration.outputSchema),
-            run: (args) => i === 0
-                ? checked(() => search(args))
-                : i === 1
-                    ? checked(() => details(args))
-                    : execute(args, i === 3),
-        };
-        const built = i === 3
-            ? write(vendor.connection, { ...spec, destructive: true })
-            : read(vendor.connection, {
-                ...spec,
-                review: readPosts.map(([, path, reason]) => `${path}: ${reason}`).join("\n") ||
-                    "Only GET and HEAD operations are admitted.",
-            });
-        Object.assign(built, {
-            inputSchema: catalogOrder(built.inputSchema, declaration.inputSchema),
-            outputSchema: catalogOrder(built.outputSchema, declaration.outputSchema),
-        });
-        return built;
-    });
-}

package/dist/providers/_shared/sensitive-fields.js

@@ -1,22 +1,6 @@
 // A provider's sensitive fields leave every result unless deployment code
 // returns them; no tool argument can. Shared by the providers whose raw rows
 // and hatches would otherwise reach what their projections drop.
-/** What `raw: true` and the hatches return, under the deployment's `sensitiveFields` choice. */
-export function unprojectedResults(sensitiveFields, names) {
-    if (sensitiveFields === "return")
-        return (body) => body;
-    const dropped = new Set(names);
-    const strip = (value) => {
-        if (Array.isArray(value))
-            return value.map(strip);
-        if (!value || typeof value !== "object")
-            return value;
-        return Object.fromEntries(Object.entries(value)
-            .filter(([name]) => !dropped.has(name))
-            .map(([name, entry]) => [name, strip(entry)]));
-    };
-    return (body) => strip(body);
-}
 /** Refuse anything but the two choices, at construction (INV-11). */
 export function sensitiveFieldsOption(provider, value) {
     if (value === undefined)