@zackbart/connecta 0.37.1 → 0.39.0

package/dist/discovery-health.js

@@ -0,0 +1,199 @@
+// Bounded per-connector discovery health, shared across requests (INV-7).
+//
+// One hung or failing connector would otherwise add its whole probe deadline
+// to every unscoped search, every time. A failed discovery leaves a record:
+// the connector-health family's `discovery` key, a typed code, when it was
+// seen, and when to try again (INV-6: never downstream text, tools or
+// credentials). Unscoped search skips a connector whose record is current and
+// reports it as unavailable in `catalogErrors` with `retryAfterMs`; it never
+// serves tools from the failed or interrupted walk (INV-8). Scoped search,
+// describe and calls still reach the connector.
+//
+// Records sit beside the catalog cache, in its store and owner partition:
+// principal, subject, caller identity and pool, origin, the admitted endpoint,
+// the connector's value-free described configuration and the package version
+// (INV-4, INV-5). Each record
+// also carries the connector's catalog invalidation generation as it was when
+// written. A credential change, OAuth connect or disconnect, or operator
+// invalidation rotates that generation, so every partition's record lapses at
+// once, in every isolate. A record is a bounded observation: it grants and
+// starts nothing (INV-10).
+//
+// After its retry time a record lingers, so exactly one request can claim the
+// next probe by compare-and-set as it dispatches it; the others keep skipping
+// until that probe settles or its lease lapses. A success, or an auth failure that proves the
+// connector answers, clears the record. A fast failure is not recorded:
+// asking again costs the next search nothing. Caller cancellation and a probe cut
+// short by the discovery budget record nothing.
+import { Effect } from "effect";
+import { healthAddress } from "./connector-health.js";
+export { bindDiscoveryEndpoint } from "./connector-health.js";
+import { classificationCode, classifyCallError } from "./errors.js";
+import { failureRecord, logFailure } from "./operator-record.js";
+import { causeError } from "./runtime/run.js";
+import { Storage } from "./runtime/services.js";
+import { storageCompareAndSet, storageGetMany, storageSet } from "./runtime/storage.js";
+import { connectorHealthKeys, CONNECTOR_HEALTH_LINGER_MS } from "./storage/keys.js";
+/** How long unscoped search skips a connector after a failed discovery. */
+const DISCOVERY_RETRY_MS = 60_000;
+/**
+ * A retryable failure slower than this is recorded; a faster one is cheap to
+ * ask again. A timeout, or a downstream that names its own wait, always is.
+ */
+const SLOW_FAILURE_MS = 1_000;
+function parseFact(raw) {
+    if (raw === null)
+        return undefined;
+    try {
+        const value = JSON.parse(raw);
+        const code = classificationCode(value.code);
+        if (value.v !== 1 ||
+            !code ||
+            !Number.isFinite(value.observedAt) ||
+            !Number.isFinite(value.retryAt) ||
+            !(value.generation === null || typeof value.generation === "string"))
+            return undefined;
+        return { v: 1, code, observedAt: value.observedAt, retryAt: value.retryAt, generation: value.generation };
+    }
+    catch {
+        return undefined;
+    }
+}
+function encodeFact(fact) {
+    return { raw: JSON.stringify(fact), expiresAtMs: Math.ceil(fact.retryAt + CONNECTOR_HEALTH_LINGER_MS) };
+}
+/**
+ * Each connector's verdict for this discovery, in `ids` order. With `skip`, a
+ * record of the current generation comes back as `skip`: current until its
+ * `retryAt`, claimable at dispatch once that has passed. Without `skip` every
+ * connector is probed and the slot only settles the record afterwards. A
+ * storage failure is a probe with no slot: health never fails discovery.
+ */
+export function readDiscoveryHealth(registry, ids, baseUrl, requestScope, options) {
+    return Effect.gen(function* () {
+        // Authored static catalogs never hang, so discovery keeps no health for them.
+        const addresses = yield* Effect.forEach(ids, (id) => registry.getConnector(id)?.staticTools
+            ? Effect.succeed(undefined)
+            : healthAddress(registry, id, baseUrl, requestScope), {
+            concurrency: "unbounded",
+        });
+        const verdicts = ids.map(() => ({}));
+        // One getMany per store: every record and its generation in one round trip.
+        const stores = new Map();
+        addresses.forEach((address, index) => {
+            if (!address)
+                return;
+            const indexes = stores.get(address.storage) ?? [];
+            indexes.push(index);
+            stores.set(address.storage, indexes);
+        });
+        for (const [storage, indexes] of stores) {
+            const keys = indexes.flatMap((index) => [
+                connectorHealthKeys.discovery(ids[index], addresses[index].digest),
+                addresses[index].generationKey,
+            ]);
+            const values = yield* storageGetMany(keys).pipe(Effect.provideService(Storage, storage), Effect.catchCause((cause) => Effect.sync(() => {
+                const first = addresses[indexes[0]];
+                logFailure(first.logger, "discovery health read failed", failureRecord({}, causeError(cause)));
+                return undefined;
+            })));
+            if (!values)
+                continue;
+            for (const [position, index] of indexes.entries()) {
+                const address = addresses[index];
+                const slot = {
+                    storage,
+                    key: keys[position * 2],
+                    logger: address.logger,
+                    generation: values[position * 2 + 1] ?? null,
+                    raw: values[position * 2] ?? null,
+                };
+                const fact = parseFact(slot.raw);
+                verdicts[index] =
+                    !options.skip || !fact || fact.generation !== slot.generation
+                        ? { slot }
+                        : { slot, skip: { code: fact.code, retryAt: fact.retryAt } };
+            }
+        }
+        return verdicts;
+    });
+}
+/**
+ * Claim the probe of a record whose retry time has passed, as the probe is
+ * dispatched: one compare-and-set against the record this request read, with
+ * a lease to the absolute time `leaseUntil`, past the claimant's whole
+ * discovery budget. Others keep skipping until the lease lapses or the probe
+ * settles. False when another request holds it, or the record changed.
+ */
+export function claimDiscoveryProbe(slot, leaseUntil) {
+    return Effect.suspend(() => {
+        const fact = parseFact(slot.raw);
+        if (!fact)
+            return Effect.succeed(slot.raw === null);
+        const claim = encodeFact({ ...fact, retryAt: leaseUntil });
+        return storageCompareAndSet(slot.key, slot.raw, claim.raw, { expiresAtMs: claim.expiresAtMs }).pipe(Effect.provideService(Storage, slot.storage), Effect.map((claimed) => {
+            if (claimed)
+                slot.raw = claim.raw;
+            return claimed;
+        }), Effect.catchCause(() => Effect.succeed(false)));
+    });
+}
+const REACHABLE_CODES = new Set([
+    "auth_required",
+    "downstream_oauth_required",
+    "provider_permission_denied",
+]);
+/**
+ * Settle one probed connector's record. `ok` and an auth failure clear a
+ * record this request saw; a recordable failure writes a fresh one. A
+ * cancelled or budget-cut probe passes `undefined` and leaves the record as
+ * it is, so a claim it held lapses on its own.
+ */
+export function settleDiscoveryHealth(slot, outcome) {
+    return Effect.suspend(() => {
+        let fact;
+        if (!outcome.ok) {
+            const classified = outcome.timedOut ? undefined : classifyCallError(outcome.failure, "catalog_lookup_failed");
+            const code = outcome.timedOut ? "timeout" : classificationCode(classified.code);
+            if (classified && REACHABLE_CODES.has(classified.code)) {
+                fact = undefined;
+            }
+            else if (code &&
+                (outcome.timedOut ||
+                    (classified.retryable && (outcome.elapsedMs >= SLOW_FAILURE_MS || classified.retryAfterMs !== undefined)))) {
+                const now = Date.now();
+                const window = classified?.retryAfterMs !== undefined
+                    ? Math.min(DISCOVERY_RETRY_MS, Math.max(1_000, classified.retryAfterMs))
+                    : DISCOVERY_RETRY_MS;
+                fact = { v: 1, code, observedAt: now, retryAt: now + window, generation: slot.generation };
+            }
+            else {
+                // A deterministic refusal is not a health fact, and a fast failure
+                // costs the next search nothing to ask again; leave the record.
+                return Effect.succeed({ slot });
+            }
+        }
+        if (!fact) {
+            if (slot.raw === null)
+                return Effect.succeed({ slot });
+            // Clear only the record this request saw: a newer failure stays.
+            return storageCompareAndSet(slot.key, slot.raw, null).pipe(Effect.provideService(Storage, slot.storage), Effect.map((cleared) => {
+                if (cleared)
+                    slot.raw = null;
+                return { slot };
+            }), Effect.catchCause((cause) => Effect.sync(() => {
+                logFailure(slot.logger, "discovery health write failed", failureRecord({}, causeError(cause)));
+                return { slot };
+            })));
+        }
+        const encoded = encodeFact(fact);
+        const skip = { code: fact.code, retryAt: fact.retryAt };
+        return storageSet(slot.key, encoded.raw, { expiresAtMs: encoded.expiresAtMs }).pipe(Effect.provideService(Storage, slot.storage), Effect.map(() => {
+            slot.raw = encoded.raw;
+            return { slot, skip };
+        }), Effect.catchCause((cause) => Effect.sync(() => {
+            logFailure(slot.logger, "discovery health write failed", failureRecord({}, causeError(cause)));
+            return { slot, skip };
+        })));
+    });
+}

package/dist/downstream-input.js

@@ -1,3 +1,4 @@
+import { toolError } from "./tool-error.js";
 import { RequestScope, requestOwner } from "./runtime/request-scope.js";
 import { Effect } from "effect";
 import { upwardStep } from "./upward.js";
@@ -129,8 +130,7 @@ function failure(code, message, write = false) {
             writeOutcome: "unknown",
         }
         : { code, message, retryable: false };
-    const structuredContent = { ok: false, error };
-    return { content: [{ type: "text", text: JSON.stringify(structuredContent) }], structuredContent, isError: true };
+    return toolError(error, { ok: false });
 }
 /** MCP-only continuation coordination. No downstream prompt enters operator records. */
 export class DownstreamElicitation {
@@ -210,6 +210,7 @@ export class DownstreamElicitation {
                     kind: "downstream",
                     principal,
                     endpoint,
+                    pool: self.options.registry.resultIdentity().pool,
                     connector: pending.connector,
                     address: String(args.address),
                     target: pending.address,
@@ -370,6 +371,7 @@ export class DownstreamElicitation {
                     state.kind !== "downstream" ||
                     state.principal !== principal ||
                     state.endpoint !== endpoint ||
+                    state.pool !== registry.resultIdentity().pool ||
                     state.connector !== wrapper.connector ||
                     typeof state.address !== "string" ||
                     typeof state.target !== "string" ||

package/dist/errors.d.ts

@@ -36,21 +36,51 @@ export type ConnectorCallErrorCode = "timeout" | "auth_required" | "downstream_o
 export type ClassificationCode = ConnectorCallErrorCode | ExecutorAdmissionErrorCode | "cancelled" | "unknown_address" | "unknown_tool" | "ambiguous_tool_alias" | "catalog_lookup_failed" | "result_too_large" | "destructive_tool_requires_approval" | "read_only_endpoint" | "auth_replay_refused" | "write_outcome_unknown" | "result_processing_failed" | "budget_exceeded" | "executor_failed" | "program_error";
 /** `value` when it is a code connecta assigns, else undefined. */
 export declare function classificationCode(value: unknown): ClassificationCode | undefined;
-/** One bounded, payload-free explanation of an input-schema mismatch. */
+/**
+ * One bounded fix for an argument. `expected` states the actual bound, allowed
+ * values or shape; `received` is the submitted JSON type, or a submitted number
+ * when its schema position is not writeOnly. Never a submitted string.
+ */
 export interface ArgumentValidationIssue {
     /** JSON Pointer into the submitted arguments; "/" means the root value. */
     path: string;
-    /** JSON Schema keyword that rejected the argument. */
-    code: string;
-    /** Expected shape only — never the submitted value. */
+    /** What the argument must be, e.g. `at least 5` or `one of "fast", "slow"`. */
     expected: string;
+    /** What arrived, e.g. `string`, `missing` or `4`. */
+    received?: string;
+    /**
+     * @deprecated Accepted from custom connectors for compatibility and no longer
+     * returned; `expected` carries the constraint.
+     */
+    code?: string;
 }
+/** A conditional requirement read from the published schema. */
+export interface ArgumentConditionalRequirement {
+    path: string;
+    condition: unknown;
+    required: string[];
+}
+/** Every bounded argument finding and one corrected example call. */
 export interface ArgumentValidationDetails {
     issues: ArgumentValidationIssue[];
-    /** More findings existed but were omitted from the bounded response. */
+    /** The tool's top-level argument names. */
+    acceptedKeys?: string[];
+    conditionalRequirements?: ArgumentConditionalRequirement[];
+    /**
+     * One complete corrected call. Placeholder values look like `<owner>/<repo>`;
+     * an example is omitted rather than guessed.
+     */
+    example?: unknown;
+    /** Why no example accompanies these findings. */
+    exampleUnavailable?: string;
+    /** More findings or detail existed but were omitted from the bounded response. */
     truncated?: true;
 }
-/** Agent-only facts from the published schema, never operator record fields. */
+/**
+ * @deprecated Pass these facts in `validation`, which connecta now returns as
+ * the single argument-recovery envelope. A `repair` passed to
+ * {@link ConnectorCallError} is folded into `validation`.
+ */
 export interface ArgumentRepairDetails {
     acceptedKeys?: string[];
     issues: Array<{
@@ -60,17 +90,17 @@ export interface ArgumentRepairDetails {
         enumValues?: unknown[];
         bounds?: Record<string, number>;
     }>;
-    conditionalRequirements?: Array<{
-        path: string;
-        condition: unknown;
-        required: string[];
-    }>;
-    /** Synthesized from the schema and checked by the same validator. */
+    conditionalRequirements?: ArgumentConditionalRequirement[];
     example?: unknown;
     exampleUnavailable?: string;
     truncated?: true;
 }
-export declare const MAX_ARGUMENT_VALIDATION_ISSUES = 3;
+/**
+ * Up to eight findings per refusal: enough for every argument of a maintained
+ * tool (the widest declare fewer than eight top-level arguments) while each
+ * finding stays a few hundred bytes inside the 4 KiB envelope below.
+ */
+export declare const MAX_ARGUMENT_VALIDATION_ISSUES = 8;
 /**
  * Clamp a string to a UTF-8 byte budget, appending `…` when it clipped.
  * Short strings — the common case, and the one that has to stay exact — are
@@ -87,6 +117,12 @@ export declare function echoedCallArgs(args: unknown, schema?: JsonSchema): {
     args?: unknown;
     argsRedacted?: true;
 };
+/** A JSON Schema bound keyword as an agent-readable constraint with its number. */
+export declare function boundText(keyword: string, bound: unknown): string | undefined;
+/** Up to twelve items, then a count. */
+export declare function listed(items: readonly string[]): string;
+/** One agent-readable clause per finding, for the error message. */
+export declare function issueSummary(issues: readonly ArgumentValidationIssue[]): string;
 /** Optional transport diagnostics; never a URL path or raw runtime message. */
 interface UnavailableDetails {
     /**
@@ -169,9 +205,11 @@ export declare class ConnectorCallError extends Error {
      * of the wire format is `classifyCallError`'s job, not this constructor's.
      */
     readonly retryAfterMs: number | undefined;
-    /** Bounded schema findings for `invalid_args`; never submitted values. */
+    /**
+     * Every bounded argument finding for `invalid_args`, with one corrected
+     * example call when it can be built without guessing.
+     */
     readonly validation: ArgumentValidationDetails | undefined;
-    readonly repair: ArgumentRepairDetails | undefined;
     /**
      * Sanitized transport diagnostics, for `unavailable` and for a write whose
      * outcome is unknown (a timeout's errno, an abort's class).
@@ -195,6 +233,7 @@ export declare class ConnectorCallError extends Error {
         retryAfterMs?: number;
         cause?: unknown;
         validation?: ArgumentValidationDetails;
+        /** @deprecated Pass these facts in `validation`; they are folded into it. */
         repair?: ArgumentRepairDetails;
         details?: UnavailableDetails;
         current?: Readonly<Record<string, number>>;
@@ -227,9 +266,8 @@ export interface CallErrorDetails extends Partial<AuthorizationHandoff> {
     retryable: boolean;
     /** Connector-known wait window; see {@link ConnectorCallError.retryAfterMs}. */
     retryAfterMs?: number;
-    /** Bounded input-schema findings; paths and expectations, never values. */
+    /** Every bounded argument finding and one corrected example call. */
     validation?: ArgumentValidationDetails;
-    repair?: ArgumentRepairDetails;
     /** On a `conflict`: where each thing the write touched stands now. */
     current?: Readonly<Record<string, number>>;
     /** Connector whose failed operation needs recovery. */

package/dist/errors.js

@@ -43,28 +43,16 @@ export function classificationCode(value) {
         ? value
         : undefined;
 }
-/** Drop oversized detail whole; clipping keys or examples changes their meaning. */
-function boundedRepair(details) {
-    if (!details)
-        return undefined;
-    try {
-        const text = JSON.stringify(details);
-        return new TextEncoder().encode(text).length <= 4096
-            ? JSON.parse(text)
-            : {
-                issues: [],
-                truncated: true,
-                exampleUnavailable: "Repair detail exceeds the response budget. Inspect the published inputSchema.",
-            };
-    }
-    catch {
-        return undefined;
-    }
-}
-export const MAX_ARGUMENT_VALIDATION_ISSUES = 3;
+/**
+ * Up to eight findings per refusal: enough for every argument of a maintained
+ * tool (the widest declare fewer than eight top-level arguments) while each
+ * finding stays a few hundred bytes inside the 4 KiB envelope below.
+ */
+export const MAX_ARGUMENT_VALIDATION_ISSUES = 8;
 const MAX_ARGUMENT_ISSUE_PATH_CHARS = 256;
-const MAX_ARGUMENT_ISSUE_CODE_CHARS = 64;
-const MAX_ARGUMENT_ISSUE_EXPECTED_CHARS = 128;
+const MAX_ARGUMENT_ISSUE_EXPECTED_CHARS = 256;
+const MAX_ARGUMENT_ISSUE_RECEIVED_CHARS = 64;
+const MAX_ARGUMENT_VALIDATION_BYTES = 4096;
 function boundedIssueText(value, maxChars) {
     if (value.length <= maxChars)
         return { value, truncated: false };
@@ -148,25 +136,91 @@ export function echoedCallArgs(args, schema) {
             ? { argsRedacted: true }
             : {};
 }
-function boundedValidation(details) {
-    if (!details)
+function plainJson(value) {
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
         return undefined;
-    let truncated = details.truncated === true || details.issues.length > MAX_ARGUMENT_VALIDATION_ISSUES;
-    const issues = details.issues.slice(0, MAX_ARGUMENT_VALIDATION_ISSUES).map((issue) => {
-        const path = boundedIssueText(issue.path, MAX_ARGUMENT_ISSUE_PATH_CHARS);
-        const code = boundedIssueText(issue.code, MAX_ARGUMENT_ISSUE_CODE_CHARS);
-        const expected = boundedIssueText(issue.expected, MAX_ARGUMENT_ISSUE_EXPECTED_CHARS);
-        truncated ||= path.truncated || code.truncated || expected.truncated;
+    }
+}
+const BOUND_WORDS = {
+    minimum: "at least",
+    maximum: "at most",
+    exclusiveMinimum: "greater than",
+    exclusiveMaximum: "less than",
+    multipleOf: "a multiple of",
+};
+/** A JSON Schema bound keyword as an agent-readable constraint with its number. */
+export function boundText(keyword, bound) {
+    const [, side, unit] = /^(min|max)(Length|Items|Properties)$/.exec(keyword) ?? [];
+    const words = side ? `at ${side === "min" ? "least" : "most"}` : BOUND_WORDS[keyword];
+    return typeof bound === "number" && words
+        ? `${words} ${bound}${unit ? ` ${unit === "Length" ? "characters" : unit.toLowerCase()}` : ""}`
+        : undefined;
+}
+/** Up to twelve items, then a count. */
+export function listed(items) {
+    return items.length > 12 ? `${items.slice(0, 12).join(", ")}, … (${items.length} in all)` : items.join(", ");
+}
+/** One agent-readable clause per finding, for the error message. */
+export function issueSummary(issues) {
+    return issues
+        .map((issue) => `${issue.path}: expected ${issue.expected}${issue.received ? `, received ${issue.received}` : ""}`)
+        .join("; ");
+}
+/**
+ * Bound argument findings into the one recovery envelope. A legacy `repair`
+ * contributes its received types and schema facts. The envelope is capped at
+ * 4 KiB: optional detail goes first, then the example, then trailing findings,
+ * so what remains is always whole.
+ */
+function boundedValidation(details, repair) {
+    if (!details && !repair)
+        return undefined;
+    const source = { ...repair, ...details };
+    const all = (details?.issues ?? []).filter((issue, index, list) => typeof issue?.path === "string" &&
+        typeof issue.expected === "string" &&
+        list.findIndex((other) => other.path === issue.path && other.expected === issue.expected) === index);
+    let truncated = source.truncated === true || all.length > MAX_ARGUMENT_VALIDATION_ISSUES;
+    const clip = (value, max) => {
+        const bounded = boundedIssueText(value, max);
+        truncated ||= bounded.truncated;
+        return bounded.value;
+    };
+    const issues = all.slice(0, MAX_ARGUMENT_VALIDATION_ISSUES).map(({ path, expected, received }) => {
+        received ??= repair?.issues?.find((legacy) => legacy?.path === path)?.receivedType;
         return {
-            path: path.value,
-            code: code.value,
-            expected: expected.value,
+            path: clip(path, MAX_ARGUMENT_ISSUE_PATH_CHARS),
+            expected: clip(expected, MAX_ARGUMENT_ISSUE_EXPECTED_CHARS),
+            ...(typeof received === "string" ? { received: clip(received, MAX_ARGUMENT_ISSUE_RECEIVED_CHARS) } : {}),
         };
     });
-    return {
-        issues,
-        ...(truncated ? { truncated: true } : {}),
-    };
+    const result = { issues };
+    if (Array.isArray(source.acceptedKeys) && source.acceptedKeys.length)
+        result.acceptedKeys = source.acceptedKeys.filter((key) => typeof key === "string");
+    if (Array.isArray(source.conditionalRequirements) && source.conditionalRequirements.length)
+        result.conditionalRequirements = plainJson(source.conditionalRequirements);
+    const example = Object.hasOwn(source, "example") ? plainJson(source.example) : undefined;
+    if (example !== undefined)
+        result.example = example;
+    else if (typeof source.exampleUnavailable === "string")
+        result.exampleUnavailable = clip(source.exampleUnavailable, MAX_ARGUMENT_ISSUE_EXPECTED_CHARS);
+    const fits = () => echoEncoder.encode(JSON.stringify(result)).length <= MAX_ARGUMENT_VALIDATION_BYTES - 20;
+    if (!fits()) {
+        truncated = true;
+        delete result.conditionalRequirements;
+        delete result.acceptedKeys;
+        if (result.example !== undefined && !fits()) {
+            delete result.example;
+            result.exampleUnavailable = "The example exceeds the response budget. Inspect the published inputSchema.";
+        }
+    }
+    while (!fits() && issues.length > 1)
+        issues.pop();
+    if (truncated)
+        result.truncated = true;
+    return result;
 }
 /** The network errnos `networkErrorCode` reports, and `timeout`. */
 export const NETWORK_ERROR_CODES = new Set([
@@ -344,9 +398,11 @@ export class ConnectorCallError extends Error {
      * of the wire format is `classifyCallError`'s job, not this constructor's.
      */
     retryAfterMs;
-    /** Bounded schema findings for `invalid_args`; never submitted values. */
+    /**
+     * Every bounded argument finding for `invalid_args`, with one corrected
+     * example call when it can be built without guessing.
+     */
     validation;
-    repair;
     /**
      * Sanitized transport diagnostics, for `unavailable` and for a write whose
      * outcome is unknown (a timeout's errno, an abort's class).
@@ -373,8 +429,7 @@ export class ConnectorCallError extends Error {
         this.retryAfterMs = normalizeRetryAfterMs(opts.retryAfterMs);
         this.details =
             code === "unavailable" || opts.writeOutcome === "unknown" ? sanitizedUnavailableDetails(opts.details) : undefined;
-        this.validation = code === "invalid_args" ? boundedValidation(opts.validation) : undefined;
-        this.repair = code === "invalid_args" ? boundedRepair(opts.repair) : undefined;
+        this.validation = code === "invalid_args" ? boundedValidation(opts.validation, opts.repair) : undefined;
         this.current = code === "conflict" ? boundedCurrent(opts.current) : undefined;
         this.writeOutcome = opts.writeOutcome === "unknown" ? "unknown" : undefined;
     }
@@ -482,7 +537,6 @@ export function classifyWithoutAdvice(err, fallbackCode = "connector_call_failed
             retryable: err.retryable,
             ...(err.retryAfterMs !== undefined ? { retryAfterMs: err.retryAfterMs } : {}),
             ...(err.validation ? { validation: err.validation } : {}),
-            ...(err.repair ? { repair: err.repair } : {}),
             ...(err.details ? { details: err.details } : {}),
             ...(err.current ? { current: err.current } : {}),
             ...(err.writeOutcome ? { writeOutcome: err.writeOutcome } : {}),