@zackbart/connecta 0.34.1 → 0.36.0

package/dist/operator-ui/model.d.ts

@@ -1,6 +1,6 @@
 import type { ConnectaConfigDescription } from "../describe-config.js";
+import type { CatalogAccessObservation, ResourceTemplateRefusalCode } from "../types.js";
 import type { OperatorConnectorOverlay, OperatorTool } from "./contract.js";
-import type { CatalogAccessObservation, CatalogDriftReport, ResourceTemplateRefusalCode } from "../types.js";
 /** Tool verdicts, independent of whether the selected pool is read-only. */
 export type UiToolSafety = "runs_in_programs" | "needs_approval";
 export interface UiTool extends Pick<OperatorTool, "name" | "address" | "description"> {
@@ -91,7 +91,6 @@ export interface UiConnector {
      * drifted — which is why the UI renders that as its own state rather than as
      * a clean one.
      */
-    catalogDrift?: CatalogDriftReport;
     /** Last agent-facing catalog read in this runtime; never persisted. */
     catalogAccess?: CatalogAccessObservation;
     resourceTemplateRefusals?: ResourceTemplateRefusalCode[];
@@ -114,7 +113,7 @@ export interface UiData {
      */
     pools?: string[];
 }
-export interface FilteredUiConnector {
+interface FilteredUiConnector {
     connector: UiConnector;
     tools: UiTool[];
 }

package/dist/program-writes.js

@@ -17,28 +17,38 @@ export function writeStateOf(outcome) {
             error: outcome.error,
             ...(outcome.answered !== undefined ? { answered: outcome.answered } : {}),
         });
-    return state === "unknown" && !outcome.ok && outcome.error.uncertainCall
+    if (state !== "unknown" || outcome.ok)
+        return state;
+    const { error } = outcome;
+    const handoff = (error.code === "auth_required" || error.code === "downstream_oauth_required") &&
+        error.nextAction &&
+        "tool" in error.nextAction &&
+        error.nextAction.tool === "authorize_connector"
         ? {
-            state,
-            uncertainCall: outcome.error.uncertainCall,
-            ...(outcome.error.details?.stage !== undefined
-                ? {
-                    deadline: {
-                        ...(outcome.error.details.operation !== undefined
-                            ? { operation: outcome.error.details.operation }
-                            : {}),
-                        stage: outcome.error.details.stage,
-                        ...(outcome.error.details.elapsedMs !== undefined
-                            ? { elapsedMs: outcome.error.details.elapsedMs }
-                            : {}),
-                        ...(outcome.error.details.deadlineMs !== undefined
-                            ? { deadlineMs: outcome.error.details.deadlineMs }
-                            : {}),
-                    },
-                }
-                : {}),
+            code: error.code,
+            ...(error.connector !== undefined ? { connector: error.connector } : {}),
+            ...(error.recovery !== undefined ? { recovery: error.recovery } : {}),
+            nextAction: error.nextAction,
+            ...(error.retry !== undefined ? { retry: error.retry } : {}),
         }
-        : state;
+        : undefined;
+    if (!error.uncertainCall && !handoff)
+        return state;
+    return {
+        state,
+        ...(error.uncertainCall ? { uncertainCall: error.uncertainCall } : {}),
+        ...(error.uncertainCall && error.details?.stage !== undefined
+            ? {
+                deadline: {
+                    ...(error.details.operation !== undefined ? { operation: error.details.operation } : {}),
+                    stage: error.details.stage,
+                    ...(error.details.elapsedMs !== undefined ? { elapsedMs: error.details.elapsedMs } : {}),
+                    ...(error.details.deadlineMs !== undefined ? { deadlineMs: error.details.deadlineMs } : {}),
+                },
+            }
+            : {}),
+        ...(handoff ? { handoff } : {}),
+    };
 }
 /**
  * The writes one program sends. The play closes this when the
@@ -55,6 +65,7 @@ export class ProgramWrites {
     uncertainCalls = [];
     uncertainCallsTruncated = false;
     deadlines = [];
+    handoff;
     /** Whether the program has settled: a write gated now is not sent. */
     get isClosed() {
         return this.closed;
@@ -80,12 +91,15 @@ export class ProgramWrites {
             recorded = true;
             const state = typeof completion === "string" ? completion : completion.state;
             if (typeof completion !== "string") {
-                if (this.uncertainCalls.length < 10)
-                    this.uncertainCalls.push(completion.uncertainCall);
-                else
-                    this.uncertainCallsTruncated = true;
+                if (completion.uncertainCall) {
+                    if (this.uncertainCalls.length < 10)
+                        this.uncertainCalls.push(completion.uncertainCall);
+                    else
+                        this.uncertainCallsTruncated = true;
+                }
                 if (completion.deadline && this.deadlines.length < 10)
                     this.deadlines.push(completion.deadline);
+                this.handoff ??= completion.handoff;
             }
             this.states.push(state);
             this.inFlight.delete(settled);
@@ -108,10 +122,17 @@ export class ProgramWrites {
             unknown: this.states.filter((state) => state === "unknown").length,
         };
         if (writes.unknown > 0) {
+            // Caught or not, an authorization verdict a write met after it left is
+            // the result, as a direct call reports it: its code and handoff, never
+            // retryable, with the write's outcome unknown.
+            const handoff = this.handoff;
             return errorEnvelope({
-                code: "write_outcome_unknown",
-                message: "A write this program sent has no known outcome, so that is the result rather than what the program returned. It will not be sent again. Check its target before doing anything that depends on it. Argument echoes may be partial or absent; use the original arguments if reconciliation requires another call.",
+                code: handoff?.code ?? "write_outcome_unknown",
+                message: handoff
+                    ? "A write this program sent failed authorization after it left, so whether it took effect is unknown, and that is the result rather than what the program returned. It will not be sent again. Check its target before doing anything that depends on it, and give nextAction to the operator to recover the connector. Argument echoes may be partial or absent; use the original arguments if reconciliation requires another call."
+                    : "A write this program sent has no known outcome, so that is the result rather than what the program returned. It will not be sent again. Check its target before doing anything that depends on it. Argument echoes may be partial or absent; use the original arguments if reconciliation requires another call.",
                 retryable: false,
+                ...(handoff ? { ...handoff, reconciliationRequired: true, writeOutcome: "unknown" } : {}),
                 ...(this.deadlines.length > 0 ? { details: this.deadlines[0] } : {}),
                 ...(this.deadlines.length > 1 ? { timeouts: this.deadlines } : {}),
                 ...(this.uncertainCalls.length === 1

package/dist/provider-call-facts.d.ts

@@ -0,0 +1,115 @@
+import { ConnectorCallError } from "./errors.js";
+import type { Connector } from "./types.js";
+export interface ProviderRequest {
+    readonly dispatched: boolean;
+    readonly status?: number;
+    auxiliary: boolean;
+    /** A kit auxiliary declared as a read lacked physical GET/HEAD proof at dispatch. */
+    readonly blocksAuxiliaryProof?: true;
+    provider: string;
+    /** The HTTP method it was sent with, when its channel knows it. */
+    readonly method?: string;
+    /** Positive operation/tool evidence; an HTTP method alone proves no read. */
+    classification?: "read" | "write" | undefined;
+    /** Remote MCP's source class said write, recorded at physical dispatch. */
+    readonly sourceWrite?: true;
+    /** The genuine, legal idempotency key the vendor honors that it carried; nothing else. */
+    key?: string;
+    /**
+     * Its answer was a 401 that the transport's reviewed `authBeforeExecution`
+     * evidence covers: the vendor rejected the credential before it acted on
+     * the request. Only that makes a 401 a refusal (`servedRefusal`).
+     */
+    authBeforeExecution?: true;
+    /**
+     * Its answer was a 401, and a renewal then replaced the credential it sent
+     * with a different one ({@link renewedAfterUnauthorized}). The 401 no
+     * longer needs the operator's recovery. The single `settleWrite` decider
+     * still reports unknown, without the handoff (Q8).
+     */
+    readonly renewed?: true;
+}
+export type CallTool = Connector["callTool"];
+interface Boundary {
+    /** The api() or remoteMcp() object whose own code enters the logical call. */
+    boundary: object;
+    own: CallTool;
+}
+export declare function originalCallIdentity(connector: object): object;
+export declare function boundaryFor(connector: object): Boundary | undefined;
+export declare function delegatorFor(connector: object): CallTool | undefined;
+/** A physical send owns its fields permanently; its own answer is recorded once. */
+export declare function recordRequestField(request: ProviderRequest, field: keyof ProviderRequest, value: unknown): void;
+export declare function recordProviderResponse(request: ProviderRequest, status: number): void;
+/**
+ * Declare that every request the connector's handlers send goes through a
+ * channel the call ledger records: a guarded transport, `ctx.fetch`, or
+ * `ctx.oauth.fetch`. Only then does an empty ledger prove that a failed
+ * write never left. Maintained providers declare it; an arbitrary `api()`
+ * handler can reach the network some other way, so its ledger proves nothing.
+ */
+export declare function tracksEveryRequest<T extends object>(connector: T): T;
+export declare function tracksRequests(connector: object): boolean;
+/**
+ * Declare a maintained connector whose `callTool` hands each call to at most
+ * one api() or remoteMcp() boundary and sends nothing else that could apply
+ * it (GitHub). Only then may that boundary's verdict stand for the call. The
+ * object and its function are recorded now, at construction: a later
+ * assignment to the property, or a copy of the object, declares nothing.
+ */
+export declare function delegatesEachCall<T extends Connector>(connector: T): T;
+/**
+ * Record a just-built api() or remoteMcp() object as a boundary, with its
+ * published `callTool`. Its own code then names the same object, from its
+ * closure, in {@link enterProviderBoundary}.
+ */
+export declare function providerBoundary(connector: Connector): void;
+/**
+ * `alias` serves `base` itself (`defineProvider`'s inheriting stamp), so it
+ * takes `base`'s recorded identities. Only construction code calls this.
+ */
+export declare function aliasCallIdentity(alias: object, base: object): void;
+/**
+ * Whether a served HTTP status says the request was refused, not applied: a
+ * 4xx other than 408. A 408 is a timeout, whose request may have been acted
+ * on; a 2xx or 5xx never proves a write unapplied. A 401 passes here, and
+ * `servedRefusal` still asks for the vendor's reviewed evidence.
+ */
+export declare function refusedStatus(status: number | undefined): boolean;
+/**
+ * Refusal provenance, recorded where the answer is observed: the request was
+ * served a refusing status (`refusedStatus`) and the mapper failed on it. An
+ * error code alone is never this evidence.
+ */
+export declare function vendorRefusal<T>(error: T, request: ProviderRequest): T;
+/** An authorization verdict, the kind that keeps the `authorize_connector` handoff. */
+export declare function authorizationFailure(error: unknown): error is ConnectorCallError;
+/**
+ * The authorization verdict `request`'s own 401 answer was mapped to, as
+ * {@link vendorRefusal} recorded it. Undefined when nothing mapped that
+ * answer, such as a body past the ceiling.
+ */
+export declare function unauthorizedAnswer(request: ProviderRequest): ConnectorCallError | undefined;
+/**
+ * A renewal answered `request`'s own 401 (a refresh, a login, a fresh token
+ * minted) with `fresh`, a credential other than `sent`, the one the request
+ * carried: that 401 no longer needs the operator's recovery (Q8). It names
+ * the one request it answered and never marks another. A renewal that hands
+ * back the credential the request already sent (an earlier recovery reused)
+ * renewed nothing.
+ */
+export declare function renewedAfterUnauthorized(request: ProviderRequest | undefined, sent: string, fresh: string): void;
+export declare function refusalRequest(error: unknown): ProviderRequest | undefined;
+export declare function knownProviderFailure<T>(error: T): T;
+export declare function isKnownProviderFailure(error: unknown): boolean;
+/** Withdraw a verdict that does not hold for the call that reports it. */
+export declare function forgetProviderFailure(error: object): void;
+/** Preserve internal verdicts and resend advice through redaction and provider recovery wording. */
+export declare function carryProviderFailure<T>(from: unknown, to: T): T;
+/** Mark a verdict that already accounts for a write's 401 in its own words. */
+export declare function explainedUnauthorizedVerdict<T>(error: T): T;
+export declare function explainsUnauthorized(error: unknown): boolean;
+/** Mark a verdict the Q8 decision made, final for every step after it. */
+export declare function settledWrite<T>(error: T): T;
+export declare function isSettledWrite(error: unknown): boolean;
+export {};

package/dist/provider-call-facts.js

@@ -0,0 +1,182 @@
+// Pure physical-request facts, failure provenance and construction identities.
+// No operation/call services or transport graph: provider definitions and
+// operator sinks can preserve provenance without acquiring Effect.
+import { carryResendAdvice, ConnectorCallError } from "./errors.js";
+import { followRedactedCopies } from "./redaction-identity.js";
+// A redacted copy of a failure is the same failure: its verdict follows it.
+const refusals = followRedactedCopies(new WeakMap());
+const knownFailures = followRedactedCopies(new WeakSet());
+// Verdicts that already account for a write's 401 in words of their own: a
+// renewal's (`unsentAfterUnauthorized`) or Q8's own. Q8 adds no sentence to them.
+const explainedUnauthorized = followRedactedCopies(new WeakSet());
+// Verdicts the one Q8 decision (`settleWrite`) made. They are final: nothing
+// after it may add retry, resend, key-reuse or wait advice to them.
+const settledWrites = followRedactedCopies(new WeakSet());
+// The authorization verdict a request's own 401 was mapped to, kept for the
+// call's verdict whatever failure surfaces after it (Q8).
+const unauthorizedAnswers = new WeakMap();
+const trackedConnectors = new WeakSet();
+const boundaries = new WeakMap();
+const delegators = new WeakMap();
+const aliases = new WeakMap();
+export function originalCallIdentity(connector) {
+    return aliases.get(connector) ?? connector;
+}
+export function boundaryFor(connector) {
+    return boundaries.get(connector);
+}
+export function delegatorFor(connector) {
+    return delegators.get(connector);
+}
+/** A physical send owns its fields permanently; its own answer is recorded once. */
+export function recordRequestField(request, field, value) {
+    Object.defineProperty(request, field, { value, enumerable: true, writable: false, configurable: false });
+}
+export function recordProviderResponse(request, status) {
+    if (request.status !== undefined)
+        throw new Error("Provider request already answered.");
+    recordRequestField(request, "status", status);
+}
+/**
+ * Declare that every request the connector's handlers send goes through a
+ * channel the call ledger records: a guarded transport, `ctx.fetch`, or
+ * `ctx.oauth.fetch`. Only then does an empty ledger prove that a failed
+ * write never left. Maintained providers declare it; an arbitrary `api()`
+ * handler can reach the network some other way, so its ledger proves nothing.
+ */
+export function tracksEveryRequest(connector) {
+    trackedConnectors.add(connector);
+    return connector;
+}
+export function tracksRequests(connector) {
+    return trackedConnectors.has(connector);
+}
+/**
+ * Declare a maintained connector whose `callTool` hands each call to at most
+ * one api() or remoteMcp() boundary and sends nothing else that could apply
+ * it (GitHub). Only then may that boundary's verdict stand for the call. The
+ * object and its function are recorded now, at construction: a later
+ * assignment to the property, or a copy of the object, declares nothing.
+ */
+export function delegatesEachCall(connector) {
+    delegators.set(connector, connector.callTool);
+    return connector;
+}
+/**
+ * Record a just-built api() or remoteMcp() object as a boundary, with its
+ * published `callTool`. Its own code then names the same object, from its
+ * closure, in {@link enterProviderBoundary}.
+ */
+export function providerBoundary(connector) {
+    boundaries.set(connector, { boundary: connector, own: connector.callTool });
+}
+/**
+ * `alias` serves `base` itself (`defineProvider`'s inheriting stamp), so it
+ * takes `base`'s recorded identities. Only construction code calls this.
+ */
+export function aliasCallIdentity(alias, base) {
+    aliases.set(alias, originalCallIdentity(base));
+    const boundary = boundaries.get(base);
+    const delegator = delegators.get(base);
+    if (boundary)
+        boundaries.set(alias, boundary);
+    if (delegator)
+        delegators.set(alias, delegator);
+}
+/**
+ * Whether a served HTTP status says the request was refused, not applied: a
+ * 4xx other than 408. A 408 is a timeout, whose request may have been acted
+ * on; a 2xx or 5xx never proves a write unapplied. A 401 passes here, and
+ * `servedRefusal` still asks for the vendor's reviewed evidence.
+ */
+export function refusedStatus(status) {
+    return status !== undefined && status >= 400 && status < 500 && status !== 408;
+}
+/**
+ * Refusal provenance, recorded where the answer is observed: the request was
+ * served a refusing status (`refusedStatus`) and the mapper failed on it. An
+ * error code alone is never this evidence.
+ */
+export function vendorRefusal(error, request) {
+    if (error !== null && typeof error === "object" && refusedStatus(request.status)) {
+        refusals.set(error, request);
+        if (request.status === 401 && authorizationFailure(error) && !unauthorizedAnswers.has(request))
+            unauthorizedAnswers.set(request, error);
+    }
+    return error;
+}
+/** An authorization verdict, the kind that keeps the `authorize_connector` handoff. */
+export function authorizationFailure(error) {
+    return (error instanceof ConnectorCallError &&
+        (error.code === "auth_required" || error.code === "downstream_oauth_required"));
+}
+/**
+ * The authorization verdict `request`'s own 401 answer was mapped to, as
+ * {@link vendorRefusal} recorded it. Undefined when nothing mapped that
+ * answer, such as a body past the ceiling.
+ */
+export function unauthorizedAnswer(request) {
+    return unauthorizedAnswers.get(request);
+}
+/**
+ * A renewal answered `request`'s own 401 (a refresh, a login, a fresh token
+ * minted) with `fresh`, a credential other than `sent`, the one the request
+ * carried: that 401 no longer needs the operator's recovery (Q8). It names
+ * the one request it answered and never marks another. A renewal that hands
+ * back the credential the request already sent (an earlier recovery reused)
+ * renewed nothing.
+ */
+export function renewedAfterUnauthorized(request, sent, fresh) {
+    if (request?.status === 401 && fresh !== sent && !request.renewed)
+        recordRequestField(request, "renewed", true);
+}
+export function refusalRequest(error) {
+    return error !== null && typeof error === "object" ? refusals.get(error) : undefined;
+}
+export function knownProviderFailure(error) {
+    if (error !== null && typeof error === "object")
+        knownFailures.add(error);
+    return error;
+}
+export function isKnownProviderFailure(error) {
+    return error !== null && typeof error === "object" && knownFailures.has(error);
+}
+/** Withdraw a verdict that does not hold for the call that reports it. */
+export function forgetProviderFailure(error) {
+    knownFailures.delete(error);
+    refusals.delete(error);
+}
+/** Preserve internal verdicts and resend advice through redaction and provider recovery wording. */
+export function carryProviderFailure(from, to) {
+    if (to !== null && typeof to === "object") {
+        const refusal = refusalRequest(from);
+        if (refusal)
+            refusals.set(to, refusal);
+        if (isKnownProviderFailure(from))
+            knownFailures.add(to);
+        if (explainsUnauthorized(from))
+            explainedUnauthorized.add(to);
+        if (isSettledWrite(from))
+            settledWrites.add(to);
+        carryResendAdvice(from, to);
+    }
+    return to;
+}
+/** Mark a verdict that already accounts for a write's 401 in its own words. */
+export function explainedUnauthorizedVerdict(error) {
+    if (error !== null && typeof error === "object")
+        explainedUnauthorized.add(error);
+    return error;
+}
+export function explainsUnauthorized(error) {
+    return error !== null && typeof error === "object" && explainedUnauthorized.has(error);
+}
+/** Mark a verdict the Q8 decision made, final for every step after it. */
+export function settledWrite(error) {
+    if (error !== null && typeof error === "object")
+        settledWrites.add(error);
+    return error;
+}
+export function isSettledWrite(error) {
+    return error !== null && typeof error === "object" && settledWrites.has(error);
+}

package/dist/provider-call.d.ts

@@ -0,0 +1,112 @@
+import { type ProviderRequest, type CallTool } from "./provider-call-facts.js";
+import type { ConnectorContext } from "./types.js";
+export interface ProviderCall {
+    requests: ProviderRequest[];
+    classification?: "read" | "write" | undefined;
+    /** The handler settled: its outcome may be reported, so nothing more leaves. */
+    closed: boolean;
+    /** The calls of api() boundaries entered beneath this one's handler. */
+    nested: ProviderCall[];
+    /** The call whose handler entered this one; undefined for the outermost. */
+    parent?: ProviderCall;
+}
+export interface LogicalCall {
+    target: object;
+    entered: CallTool;
+    boundaries: object[];
+    /** Every resource request dispatched under it, once per dispatch, from any ledger. */
+    sent: ProviderRequest[];
+    /** Auxiliary GET/HEAD dispatches without method overrides, apart from resource writes and auth POSTs. */
+    auxiliaryReads: ProviderRequest[];
+    /** A kit auxiliary declared as a read dispatched without physical read proof. */
+    nonReadAuxiliaryDispatched: boolean;
+}
+export declare function providerCallContext(ctx: ConnectorContext, classification?: "read" | "write"): ConnectorContext;
+/** Whether `ctx`'s call was entered by another api() boundary's handler. */
+export declare function nestedProviderCall(ctx: ConnectorContext): boolean;
+export declare function providerRequests(ctx: ConnectorContext): readonly ProviderRequest[] | undefined;
+/**
+ * Every request the ledgers of api() boundaries nested beneath `ctx`'s call
+ * recorded, at any depth: an inner call's 401 still decides the outer's
+ * write (Q8), whatever the outer handler made of the inner's failure.
+ */
+export declare function nestedProviderRequests(ctx: ConnectorContext): ProviderRequest[];
+/**
+ * End the call's ledger before its outcome is decided. A request still in
+ * flight already counts as dispatched; one that has not left yet (a sibling
+ * still reading its credential, say) is refused by {@link dispatchProviderRequest}
+ * and never leaves after the failure is reported.
+ */
+export declare function closeProviderCall(ctx: ConnectorContext): void;
+/**
+ * Refuse every request after its request scope ends, before credential reads
+ * and again immediately before dispatch. Resource requests also require an
+ * open call. Auxiliary requests (token mints, lookups) may outlive that call,
+ * but never their request.
+ */
+export declare function assertProviderCallOpen(ctx: ConnectorContext, provider: string, auxiliary: boolean): void;
+/** Record that a request leaves now; synchronous with the send that follows it. */
+export declare function dispatchProviderRequest(ctx: ConnectorContext | undefined, request: ProviderRequest, headers?: HeadersInit, method?: string | undefined): void;
+export declare function recordingFetch<T extends object>(send: T): T;
+export declare function isRecordingFetch(send: object | undefined): boolean;
+export declare function handoffProviderRequest(init: RequestInit, request: ProviderRequest): void;
+export declare function takeProviderHandoff(init: RequestInit): ProviderRequest | undefined;
+export declare function bindProviderResponse(response: object, request: ProviderRequest, owner: ProviderRequest | undefined): void;
+export declare function responseProviderRequest(response: object, owner: ProviderRequest): ProviderRequest | undefined;
+export declare function providerRequest(ctx: ConnectorContext, auxiliary: boolean, provider: string, sent?: {
+    method?: string;
+    key?: string;
+    classification?: "read" | "write";
+}): ProviderRequest;
+/**
+ * The invocation opens one logical call on the context it hands a connector,
+ * naming the exact object and `callTool` function it is about to invoke.
+ */
+export declare function openLogicalCall(ctx: ConnectorContext, target: object, entered: CallTool): LogicalCall;
+/**
+ * An api() or remoteMcp() boundary was entered under `ctx`'s logical call.
+ * `boundary` is the object it was built as, from its own closure, never `this`.
+ */
+export declare function enterProviderBoundary(ctx: ConnectorContext, boundary: object): void;
+/**
+ * Whether a failure's known mark holds for its whole logical call (INV-9).
+ * A boundary marks a write known only when every request it dispatched is
+ * proven unapplied, so the mark stands when that boundary owned the call
+ * ({@link ownsLogicalCall}) and at most one boundary was entered. A wrapper
+ * that composed several calls, or could send around them, never inherits an
+ * inner verdict.
+ */
+export declare function knownCallFailure(call: LogicalCall | undefined, error: unknown): boolean;
+/**
+ * Positive proof that a complete tracked call dispatched only auxiliaries,
+ * including a recorded resource read (positive GET/HEAD evidence). An
+ * authentication POST alone is not evidence of that call's resource work:
+ * token mints can be shared with callers whose ledgers did not send them.
+ * An empty resource ledger is not this proof: even a declared api() entry
+ * can report a timeout and recovery facts without recording any dispatch.
+ * Keep those calls conservative rather than inferring an auxiliary failure
+ * from the absence of a resource request. Wrappers and untracked boundaries
+ * cannot borrow an inner call's observations.
+ */
+export declare function onlyAuxiliaryRequests(call: LogicalCall | undefined): boolean;
+/**
+ * Whether reusing `key` with the exact original arguments cannot repeat any
+ * write of `ctx`'s logical call, the one basis for key-reuse advice (INV-9).
+ * It holds only when the call entered exactly one boundary, which owned it
+ * and tracks every request, and sent exactly one write, carrying `key`. A
+ * request counts as a read only with positive classification and a recorded
+ * GET or HEAD ({@link readRequest}). An inner request's key never speaks for a composite,
+ * a wrapper, a second write, or an earlier unrelated request.
+ */
+export declare function keyProtectsCall(call: LogicalCall | undefined, key: string | undefined): boolean;
+/** Positive read evidence, with GET/HEAD as #902's additional conservative bound. */
+export declare function readRequest(request: Pick<ProviderRequest, "classification" | "method">, headers?: HeadersInit): boolean;
+export declare function providerFetch(ctx: ConnectorContext, provider: string, auxiliary: boolean, send: typeof fetch): typeof fetch;
+/** Whether an invocation opened the logical call `ctx` belongs to; it then settles Q8 itself. */
+export declare function inLogicalCall(ctx: object): boolean;
+/**
+ * Every resource request dispatched under `ctx`'s logical call, from any
+ * ledger, nested ones included; undefined outside one.
+ */
+export declare function logicalCallRequests(ctx: object | undefined): readonly ProviderRequest[] | undefined;
+export { recordProviderResponse, tracksEveryRequest, tracksRequests, delegatesEachCall, providerBoundary, refusedStatus, vendorRefusal, authorizationFailure, unauthorizedAnswer, renewedAfterUnauthorized, refusalRequest, knownProviderFailure, isKnownProviderFailure, forgetProviderFailure, explainedUnauthorizedVerdict, explainsUnauthorized, settledWrite, isSettledWrite, type ProviderRequest, } from "./provider-call-facts.js";