@zq-silk/yui 0.13.8 → 0.13.10

package/dist/run/providerRetry.js

@@ -1,226 +0,0 @@
-import { createHash } from "node:crypto";
-import { DEFAULT_PROVIDER_RETRY_DELAYS_SECONDS, DEFAULT_PROVIDER_RETRY_MAX_WINDOW_SECONDS, MAX_PROVIDER_RETRY_ATTEMPTS } from "../config/yuiConfig.js";
-import { requireIdentity, requireText, requireTimestamp } from "../domain/validation.js";
-export const PROVIDER_RETRY_DELAYS_MS = Object.freeze(DEFAULT_PROVIDER_RETRY_DELAYS_SECONDS.map((seconds) => seconds * 1_000));
-export const PROVIDER_RETRY_EPISODE_WINDOW_MS = DEFAULT_PROVIDER_RETRY_MAX_WINDOW_SECONDS * 1_000;
-export function nextProviderRetryDelayMs(retryIndex, delaysMs = PROVIDER_RETRY_DELAYS_MS) {
-    if (!Number.isSafeInteger(retryIndex)
-        || retryIndex < 1
-        || retryIndex > delaysMs.length) {
-        throw new Error(`Provider retry index is out of range: ${String(retryIndex)}.`);
-    }
-    return delaysMs[retryIndex - 1];
-}
-/**
- * True when the retry lineage has used its total wall-clock budget. The
- * budget is measured from the first classified failure, so repeated failures
- * never extend it.
- */
-export function providerRetryBudgetExhausted(value, now, maxWindowMs = PROVIDER_RETRY_EPISODE_WINDOW_MS) {
-    if (!Number.isSafeInteger(maxWindowMs) || maxWindowMs <= 0) {
-        throw new Error(`Provider retry max window must be a positive integer: ${String(maxWindowMs)}.`);
-    }
-    return Math.min(Date.parse(value.episodeDeadlineAt), Date.parse(value.firstFailureAt) + maxWindowMs) <= now.getTime();
-}
-export function validateAgentRunProviderRetry(value) {
-    if (value.schemaVersion !== 2) {
-        throw new Error("Agent run providerRetry must use schemaVersion 2.");
-    }
-    if (!["scheduled", "dispatching", "awaiting-progress", "blocked"].includes(value.state)) {
-        throw new Error("Agent run providerRetry state is invalid.");
-    }
-    requireIdentity(value.episodeId, "Agent run providerRetry episodeId");
-    requireIdentity(value.failureEventId, "Agent run providerRetry failureEventId");
-    if (value.policyVersion !== 1)
-        throw new Error("Provider retry policy version is invalid.");
-    if (!Number.isSafeInteger(value.consecutiveFailures) || value.consecutiveFailures < 1) {
-        throw new Error("Agent run providerRetry consecutiveFailures must be positive.");
-    }
-    if (!Number.isSafeInteger(value.dispatchedRetries)
-        || value.dispatchedRetries < 0
-        || value.dispatchedRetries > value.maxRetries) {
-        throw new Error("Agent run providerRetry dispatchedRetries is invalid.");
-    }
-    if (!Number.isSafeInteger(value.maxRetries)
-        || value.maxRetries < 1
-        || value.maxRetries > MAX_PROVIDER_RETRY_ATTEMPTS) {
-        throw new Error("Agent run providerRetry maxRetries is invalid.");
-    }
-    requireTimestamp(value.firstFailureAt, "Agent run providerRetry firstFailureAt");
-    requireTimestamp(value.lastFailureAt, "Agent run providerRetry lastFailureAt");
-    requireTimestamp(value.episodeDeadlineAt, "Agent run providerRetry episodeDeadlineAt");
-    if (Date.parse(value.lastFailureAt) < Date.parse(value.firstFailureAt)) {
-        throw new Error("Agent run providerRetry lastFailureAt precedes firstFailureAt.");
-    }
-    if (Date.parse(value.episodeDeadlineAt) <= Date.parse(value.firstFailureAt)) {
-        throw new Error("Agent run providerRetry deadline must follow firstFailureAt.");
-    }
-    if ((value.state === "scheduled") !== (value.nextAttemptAt !== undefined)) {
-        throw new Error("Only a scheduled providerRetry may carry nextAttemptAt.");
-    }
-    if (value.nextAttemptAt !== undefined) {
-        requireTimestamp(value.nextAttemptAt, "Agent run providerRetry nextAttemptAt");
-        if (Date.parse(value.nextAttemptAt) > Date.parse(value.episodeDeadlineAt)) {
-            throw new Error("Agent run providerRetry next attempt exceeds its episode deadline.");
-        }
-    }
-    if ((value.state === "dispatching" || value.state === "awaiting-progress")
-        !== (value.lastRetryReceiptId !== undefined)) {
-        throw new Error("An in-flight providerRetry requires one retry receipt identity.");
-    }
-    if (value.lastRetryReceiptId !== undefined) {
-        requireIdentity(value.lastRetryReceiptId, "Agent run providerRetry receipt id");
-    }
-    if (value.launchId !== undefined)
-        requireIdentity(value.launchId, "Agent run providerRetry launchId");
-    if (value.nativeSessionId !== undefined) {
-        requireIdentity(value.nativeSessionId, "Agent run providerRetry nativeSessionId");
-    }
-    if (value.failedNativeTurnId !== undefined) {
-        requireIdentity(value.failedNativeTurnId, "Agent run providerRetry failed native Turn id");
-    }
-    requireText(value.lastErrorSummary, "Agent run providerRetry lastErrorSummary");
-    return value;
-}
-/** Advance one failure episode without ever changing the native Session. */
-export function scheduleProviderRetry(previous, input, now, policy = {
-    delaysMs: PROVIDER_RETRY_DELAYS_MS,
-    maxWindowMs: PROVIDER_RETRY_EPISODE_WINDOW_MS
-}) {
-    validateRetrySchedulePolicy(policy);
-    const at = now.toISOString();
-    const firstFailureAt = previous?.firstFailureAt ?? at;
-    const episodeDeadlineAt = previous?.episodeDeadlineAt
-        ?? new Date(now.getTime() + policy.maxWindowMs).toISOString();
-    if (now.getTime() >= Date.parse(episodeDeadlineAt)) {
-        return Object.freeze({ outcome: "exhausted", reason: "window" });
-    }
-    const consecutiveFailures = (previous?.consecutiveFailures ?? 0) + 1;
-    const dispatchedRetries = previous?.dispatchedRetries ?? 0;
-    const schedule = input.scheduleNextAttempt ?? true;
-    if (schedule && dispatchedRetries >= policy.delaysMs.length) {
-        return Object.freeze({ outcome: "exhausted", reason: "attempts" });
-    }
-    const state = schedule ? "scheduled" : "blocked";
-    const retryAfterMs = input.retryAfterMs;
-    if (retryAfterMs !== undefined && (!Number.isSafeInteger(retryAfterMs) || retryAfterMs <= 0)) {
-        throw new Error("Provider retry Retry-After must be a positive safe integer.");
-    }
-    const delayMs = schedule
-        ? Math.max(nextProviderRetryDelayMs(dispatchedRetries + 1, policy.delaysMs), retryAfterMs ?? 0)
-        : undefined;
-    const nextAttemptAt = delayMs === undefined
-        ? undefined
-        : new Date(now.getTime() + delayMs).toISOString();
-    if (nextAttemptAt !== undefined && Date.parse(nextAttemptAt) > Date.parse(episodeDeadlineAt)) {
-        return Object.freeze({
-            outcome: "exhausted",
-            reason: retryAfterMs === undefined ? "window" : "retry-after-window"
-        });
-    }
-    const retry = validateAgentRunProviderRetry({
-        schemaVersion: 2,
-        episodeId: previous?.episodeId ?? createHash("sha256")
-            .update(`${firstFailureAt}\0${input.nativeSessionId ?? "unknown"}\0${input.launchId ?? "unknown"}`)
-            .digest("hex"),
-        failureEventId: requireIdentity(input.failureEventId, "Provider failure event id"),
-        policyVersion: 1,
-        state,
-        errorClass: input.errorClass,
-        consecutiveFailures,
-        dispatchedRetries,
-        maxRetries: policy.delaysMs.length,
-        firstFailureAt,
-        lastFailureAt: at,
-        episodeDeadlineAt,
-        ...(nextAttemptAt === undefined ? {} : { nextAttemptAt }),
-        ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
-        ...(input.nativeSessionId === undefined ? {} : { nativeSessionId: input.nativeSessionId }),
-        ...(input.failedNativeTurnId === undefined
-            ? {}
-            : { failedNativeTurnId: input.failedNativeTurnId }),
-        lastErrorSummary: input.lastErrorSummary
-    });
-    return Object.freeze({ outcome: schedule ? "scheduled" : "blocked", retry });
-}
-function validateRetrySchedulePolicy(policy) {
-    if (!Number.isSafeInteger(policy.maxWindowMs) || policy.maxWindowMs < 1) {
-        throw new Error("Provider retry max window must be a positive safe integer.");
-    }
-    if (policy.delaysMs.length < 1 || policy.delaysMs.length > MAX_PROVIDER_RETRY_ATTEMPTS
-        || policy.delaysMs.some((delay) => !Number.isSafeInteger(delay) || delay < 1)) {
-        throw new Error(`Provider retry delay schedule must contain 1-${MAX_PROVIDER_RETRY_ATTEMPTS} positive safe integers.`);
-    }
-}
-/** Mark that one short continuation request was dispatched and now awaits any correlated progress. */
-export function prepareProviderRetryDispatch(value, receiptId, now) {
-    if (value.state !== "scheduled" || value.nextAttemptAt === undefined)
-        return value;
-    if (now.getTime() > Date.parse(value.episodeDeadlineAt)) {
-        throw new Error("Provider retry episode expired before dispatch.");
-    }
-    const { nextAttemptAt: _nextAttemptAt, ...rest } = value;
-    return validateAgentRunProviderRetry({
-        ...rest,
-        state: "dispatching",
-        lastRetryReceiptId: requireIdentity(receiptId, "Provider retry receipt id")
-    });
-}
-export function markProviderRetryDispatched(value) {
-    if (value.state !== "dispatching")
-        return value;
-    return validateAgentRunProviderRetry({
-        ...value,
-        state: "awaiting-progress",
-        dispatchedRetries: value.dispatchedRetries + 1
-    });
-}
-export function providerRetryIsDue(value, now) {
-    return value.state === "scheduled"
-        && value.nextAttemptAt !== undefined
-        && Date.parse(value.nextAttemptAt) <= now.getTime();
-}
-/**
- * Next Controller wake for an active automatic retry episode. Scheduled
- * retries wake to dispatch; an in-flight retry wakes only at the episode
- * deadline so silence cannot strand the Run forever. Blocked states are
- * intentionally excluded because they require native/user evidence rather
- * than an automatic lifecycle transition.
- */
-export function providerRetryWakeAt(value) {
-    if (value.state === "scheduled")
-        return value.nextAttemptAt ?? null;
-    if (value.state === "dispatching" || value.state === "awaiting-progress") {
-        return value.episodeDeadlineAt;
-    }
-    return null;
-}
-/** Delay a control-plane recovery gap without changing either failure counter. */
-export function deferProviderRetry(value, now) {
-    const deadline = Date.parse(value.episodeDeadlineAt);
-    if (now.getTime() >= deadline)
-        return null;
-    const { lastRetryReceiptId: _receipt, nextAttemptAt: _next, ...rest } = value;
-    return validateAgentRunProviderRetry({
-        ...rest,
-        state: "scheduled",
-        nextAttemptAt: new Date(Math.min(now.getTime() + 15_000, deadline)).toISOString()
-    });
-}
-/** Short recovery instruction; it cannot repeat the Task Assignment body. */
-export function serializeProviderRetryEnvelope(input) {
-    validateAgentRunProviderRetry(input.retry);
-    const retryOrdinal = input.retry.state === "dispatching"
-        ? input.retry.dispatchedRetries + 1
-        : input.retry.dispatchedRetries;
-    return [
-        "Yui managed in-Session continuation retry.",
-        `task=${requireIdentity(input.taskId, "Provider retry task id")} run=${requireIdentity(input.runId, "Provider retry run id")} role=${requireIdentity(input.roleName, "Provider retry role")}`,
-        `episode=${input.retry.episodeId} retry=${retryOrdinal}/${input.retry.maxRetries} receipt=${input.retry.lastRetryReceiptId ?? "pending"}`,
-        `failureEvent=${input.retry.failureEventId}`,
-        ...(input.retry.failedNativeTurnId === undefined
-            ? []
-            : [`retryOfTurn=${input.retry.failedNativeTurnId}`]),
-        "Continue the existing native conversation from its latest accepted state. Do not repeat completed work; load exact Run deltas if needed."
-    ].join("\n");
-}

package/dist/run/providerRetryConfig.js

@@ -1,27 +0,0 @@
-import { resolveProviderRetryAdapters, resolveProviderRetryDelaysSeconds, resolveProviderRetryMaxWindowSeconds, resolveProviderRetryMode } from "../config/yuiConfig.js";
-/**
- * Resolves the retry flags from the durable Yui config. Homes without the
- * fields get the safe defaults: enforce mode, all supported adapters, receipt
- * replay on, 10-minute budget.
- */
-export function providerRetryConfig(config) {
-    const mode = resolveProviderRetryMode(config.providerRetryMode);
-    const adapters = resolveProviderRetryAdapters(config.providerRetryAdapters);
-    return {
-        mode: adapters.length === 0 ? "off" : mode,
-        adapters,
-        delaysMs: resolveProviderRetryDelaysSeconds(config.providerRetryDelaysSeconds)
-            .map((seconds) => seconds * 1_000),
-        maxWindowMs: resolveProviderRetryMaxWindowSeconds(config.providerRetryMaxWindowSeconds)
-            * 1_000
-    };
-}
-/** Whether the adapter has in-place retry enabled in the given mode. */
-export function providerRetryEnabledForAdapter(config, adapterId, mode) {
-    return config.mode === mode
-        && providerRetryAdapterEnabled(config, adapterId);
-}
-/** Default admission is capability-driven, not a hard-coded Provider list. */
-export function providerRetryAdapterEnabled(config, adapterId) {
-    return config.adapters === "all-capable" || config.adapters.includes(adapterId);
-}

package/dist/runtime/providerErrorCodes.js

@@ -1,278 +0,0 @@
-/**
- * Provider-neutral structured error taxonomy.
- *
- * Each Agent Driver parses its own Provider's raw failure text into one of
- * these codes at the driver boundary. The retry classifier then maps codes to
- * Yui error classes by lookup — no Provider-specific regex lives in the
- * classifier. Text matching remains only as a fallback for drivers that
- * cannot yet produce a structured code.
- */
-/**
- * Maps each structured code to its Yui error class. This is the single
- * authoritative lookup that replaces regex matching in the classifier.
- */
-export const PROVIDER_ERROR_CODE_CLASS = Object.freeze({
-    // Stream/transport → transport-uncertain (delivery may have happened)
-    "stream-internal-error": "transport-uncertain",
-    "stream-protocol-error": "transport-uncertain",
-    "stream-error": "transport-uncertain",
-    "connection-reset": "transport-uncertain",
-    "connection-lost": "transport-uncertain",
-    timeout: "transport-uncertain",
-    // HTTP 5xx / capacity → transient-provider
-    "http-5xx": "transient-provider",
-    overloaded: "transient-provider",
-    "server-error": "transient-provider",
-    // HTTP 429 → transient-provider (retryable with backoff)
-    "http-429": "transient-provider",
-    // HTTP 4xx → invalid-request (non-retryable)
-    "http-4xx": "invalid-request",
-    // Policy
-    "policy-denied": "policy-denied",
-    // Session
-    "session-not-found": "session-dead",
-    "session-expired": "session-dead",
-    "session-ended": "session-dead",
-    "process-exited": "session-dead",
-    // Request
-    "invalid-request": "invalid-request",
-    unknown: "unclassified"
-});
-/** Whether a structured code is retryable in place. */
-export function isRetryableErrorCode(code) {
-    const cls = PROVIDER_ERROR_CODE_CLASS[code];
-    return cls === "transient-provider" || cls === "transport-uncertain";
-}
-// ── Claude Code driver ──────────────────────────────────────────────────
-/**
- * Parses a Claude Code StopFailure `error` string into a structured code.
- *
- * Claude sends structured API error codes (server_error, overloaded_error,
- * rate_limit_error, etc.) as the `error` field, and raw transport text
- * ("stream error: stream ID …; INTERNAL_ERROR") in error_details or the
- * CLI's own output. This function handles both.
- */
-export function parseClaudeError(error, details) {
-    const text = [error, details]
-        .filter((v) => typeof v === "string" && v.length > 0)
-        .join("\n");
-    // ── Structured Claude API error codes ──────────────────────────────
-    // Claude's StopFailure hook sends these as the `error` field.
-    if (/^server_error$/iu.test(text)) {
-        return { code: "server-error", raw: error };
-    }
-    if (/^overloaded_error$/iu.test(text)) {
-        return { code: "overloaded", raw: error };
-    }
-    if (/^rate_limit_error$/iu.test(text)) {
-        return { code: "http-429", raw: error };
-    }
-    if (/^invalid_request_error$/iu.test(text)) {
-        return { code: "invalid-request", raw: error };
-    }
-    if (/^(authentication_error|permission_error)$/iu.test(text)) {
-        return { code: "policy-denied", raw: error };
-    }
-    if (/^not_found_error$/iu.test(text)) {
-        return { code: "session-not-found", raw: error };
-    }
-    if (/^api_error$/iu.test(text)) {
-        return { code: "server-error", raw: error };
-    }
-    // Claude CLI structured error codes (e.g. "[claude-code:unrecognized_model]")
-    if (/\[claude-code:(unrecognized_model|invalid_model|model_not_found)\]/iu.test(text)) {
-        return { code: "invalid-request", raw: error };
-    }
-    // HTTP/2 RST_STREAM (the Task-27 failure mode)
-    if (/stream error:.*INTERNAL_ERROR/iu.test(text)) {
-        return { code: "stream-internal-error", raw: error };
-    }
-    if (/stream error:.*PROTOCOL_ERROR/iu.test(text)) {
-        return { code: "stream-protocol-error", raw: error };
-    }
-    if (/stream error/iu.test(text)) {
-        return { code: "stream-error", raw: error };
-    }
-    // "Server error mid-response" and similar
-    if (/server[\s_-]?error/iu.test(text)) {
-        return { code: "server-error", raw: error };
-    }
-    // HTTP status codes
-    if (/\b429\b/u.test(text))
-        return { code: "http-429", raw: error };
-    if (/\b40[0-9]\b/u.test(text))
-        return { code: "http-4xx", raw: error };
-    if (/\b50[024]\b/u.test(text))
-        return { code: "http-5xx", raw: error };
-    // Connection
-    if (/connection[\s_-]?reset/iu.test(text))
-        return { code: "connection-reset", raw: error };
-    if (/connection[\s_-]?lost/iu.test(text))
-        return { code: "connection-lost", raw: error };
-    if (/econnreset/iu.test(text))
-        return { code: "connection-reset", raw: error };
-    if (/socket hang up/iu.test(text))
-        return { code: "connection-reset", raw: error };
-    // Timeout
-    if (/timed?[ -]?out/iu.test(text))
-        return { code: "timeout", raw: error };
-    if (/etimedout/iu.test(text))
-        return { code: "timeout", raw: error };
-    // Capacity
-    if (/overloaded/iu.test(text))
-        return { code: "overloaded", raw: error };
-    if (/rate[\s_-]?limit/iu.test(text))
-        return { code: "http-429", raw: error };
-    // Policy
-    if (/cyber[_-]?policy/iu.test(text))
-        return { code: "policy-denied", raw: error };
-    if (/policy[\s_-]?violation/iu.test(text))
-        return { code: "policy-denied", raw: error };
-    if (/usage[\s_-]?policy/iu.test(text))
-        return { code: "policy-denied", raw: error };
-    if (/content[\s_-]?policy/iu.test(text))
-        return { code: "policy-denied", raw: error };
-    if (/safety[\s_-]?policy/iu.test(text))
-        return { code: "policy-denied", raw: error };
-    // Session lifecycle
-    if (/session[\s_-]?not[\s_-]?found/iu.test(text))
-        return { code: "session-not-found", raw: error };
-    if (/no[\s_-]?such[\s_-]?(session|thread)/iu.test(text))
-        return { code: "session-not-found", raw: error };
-    if (/thread[\s_-]?not[\s_-]?found/iu.test(text))
-        return { code: "session-not-found", raw: error };
-    if (/session[\s_-]?(has[\s_-]?)?expired/iu.test(text))
-        return { code: "session-expired", raw: error };
-    if (/session[\s_-]?(has[\s_-]?)?ended/iu.test(text))
-        return { code: "session-ended", raw: error };
-    if (/process[\s_-]?exited/iu.test(text))
-        return { code: "process-exited", raw: error };
-    // Request validity
-    if (/invalid[\s_-]?request/iu.test(text))
-        return { code: "invalid-request", raw: error };
-    if (/validation[\s_-]?error/iu.test(text))
-        return { code: "invalid-request", raw: error };
-    if (/bad[\s_-]?request/iu.test(text))
-        return { code: "http-4xx", raw: error };
-    if (/unknown[\s_-]?(flag|tool|argument)/iu.test(text))
-        return { code: "invalid-request", raw: error };
-    return { code: "unknown", raw: error };
-}
-// ── Codex driver ────────────────────────────────────────────────────────
-/**
- * Parses a Codex CLI failure into a structured code.
- *
- * Codex surfaces errors through process exit, transcript messages, and
- * stream-level failures. Its error formats overlap with Claude's (HTTP/2
- * stream errors, API status codes) but also include Codex-specific patterns.
- */
-export function parseCodexError(error, details) {
-    const text = [error, details]
-        .filter((v) => typeof v === "string" && v.length > 0)
-        .join("\n");
-    // ── Structured API error codes ────────────────────────────────────
-    if (/^server_error$/iu.test(text)) {
-        return { code: "server-error", raw: error };
-    }
-    if (/^overloaded_error$/iu.test(text)) {
-        return { code: "overloaded", raw: error };
-    }
-    if (/^rate_limit_error$/iu.test(text)) {
-        return { code: "http-429", raw: error };
-    }
-    if (/^invalid_request_error$/iu.test(text)) {
-        return { code: "invalid-request", raw: error };
-    }
-    if (/^(authentication_error|permission_error)$/iu.test(text)) {
-        return { code: "policy-denied", raw: error };
-    }
-    // Codex CLI structured error codes
-    if (/\[codex:(unrecognized_model|invalid_model|model_not_found)\]/iu.test(text)) {
-        return { code: "invalid-request", raw: error };
-    }
-    // Model not supported / invalid model (non-retryable)
-    if (/model.*not supported|invalid.*model|model.*not found/iu.test(text)) {
-        return { code: "invalid-request", raw: error };
-    }
-    // Stream disconnected (retryable transport)
-    if (/stream disconnected/iu.test(text)) {
-        return { code: "stream-error", raw: error };
-    }
-    // ── Stream / transport ────────────────────────────────────────────
-    if (/stream error:.*INTERNAL_ERROR/iu.test(text)) {
-        return { code: "stream-internal-error", raw: error };
-    }
-    if (/stream error:.*PROTOCOL_ERROR/iu.test(text)) {
-        return { code: "stream-protocol-error", raw: error };
-    }
-    if (/stream error/iu.test(text)) {
-        return { code: "stream-error", raw: error };
-    }
-    // ── HTTP status codes ─────────────────────────────────────────────
-    if (/\b429\b/u.test(text))
-        return { code: "http-429", raw: error };
-    if (/\b40[0-9]\b/u.test(text))
-        return { code: "http-4xx", raw: error };
-    if (/\b50[024]\b/u.test(text))
-        return { code: "http-5xx", raw: error };
-    // ── Server / capacity ─────────────────────────────────────────────
-    if (/server[\s_-]?error/iu.test(text)) {
-        return { code: "server-error", raw: error };
-    }
-    if (/overloaded/iu.test(text))
-        return { code: "overloaded", raw: error };
-    if (/rate[\s_-]?limit/iu.test(text))
-        return { code: "http-429", raw: error };
-    if (/bad gateway/iu.test(text))
-        return { code: "http-5xx", raw: error };
-    if (/gateway timeout/iu.test(text))
-        return { code: "timeout", raw: error };
-    if (/service unavailable/iu.test(text))
-        return { code: "http-5xx", raw: error };
-    if (/temporarily unavailable/iu.test(text))
-        return { code: "http-5xx", raw: error };
-    // ── Connection ────────────────────────────────────────────────────
-    if (/connection[\s_-]?reset/iu.test(text))
-        return { code: "connection-reset", raw: error };
-    if (/connection[\s_-]?lost/iu.test(text))
-        return { code: "connection-lost", raw: error };
-    if (/econnreset/iu.test(text))
-        return { code: "connection-reset", raw: error };
-    if (/socket hang up/iu.test(text))
-        return { code: "connection-reset", raw: error };
-    // ── Timeout ───────────────────────────────────────────────────────
-    if (/timed?[ -]?out/iu.test(text))
-        return { code: "timeout", raw: error };
-    if (/etimedout/iu.test(text))
-        return { code: "timeout", raw: error };
-    // ── Policy ────────────────────────────────────────────────────────
-    if (/cyber[_-]?policy/iu.test(text))
-        return { code: "policy-denied", raw: error };
-    if (/policy[\s_-]?violation/iu.test(text))
-        return { code: "policy-denied", raw: error };
-    if (/usage[\s_-]?policy/iu.test(text))
-        return { code: "policy-denied", raw: error };
-    if (/content[\s_-]?policy/iu.test(text))
-        return { code: "policy-denied", raw: error };
-    // ── Session ───────────────────────────────────────────────────────
-    if (/session[\s_-]?not[\s_-]?found/iu.test(text))
-        return { code: "session-not-found", raw: error };
-    if (/no[\s_-]?such[\s_-]?(session|thread)/iu.test(text))
-        return { code: "session-not-found", raw: error };
-    if (/session[\s_-]?(has[\s_-]?)?expired/iu.test(text))
-        return { code: "session-expired", raw: error };
-    if (/session[\s_-]?(has[\s_-]?)?ended/iu.test(text))
-        return { code: "session-ended", raw: error };
-    if (/process[\s_-]?exited/iu.test(text))
-        return { code: "process-exited", raw: error };
-    // ── Request validity ──────────────────────────────────────────────
-    if (/invalid[\s_-]?request/iu.test(text))
-        return { code: "invalid-request", raw: error };
-    if (/validation[\s_-]?error/iu.test(text))
-        return { code: "invalid-request", raw: error };
-    if (/bad[\s_-]?request/iu.test(text))
-        return { code: "http-4xx", raw: error };
-    if (/unknown[\s_-]?(flag|tool|argument)/iu.test(text))
-        return { code: "invalid-request", raw: error };
-    return { code: "unknown", raw: error };
-}

package/dist/runtime/providerRecoveryDecision.js

@@ -1,55 +0,0 @@
-import { currentProviderActivation, currentProviderConversation, validateProviderRuntimeBinding } from "./providerRuntimeIdentity.js";
-/**
- * Exact tri-state recovery policy. Unknown is a terminal decision for the
- * automatic recovery attempt, not permission to create another Conversation.
- */
-export function decideProviderRecovery(input) {
-    const binding = validateProviderRuntimeBinding(input.binding);
-    const conversation = currentProviderConversation(binding);
-    if (input.probe.conversationId !== conversation.conversationId) {
-        throw new Error("Provider recovery probe targets a different Conversation.");
-    }
-    if (input.probe.state === "unknown") {
-        return {
-            action: "attention",
-            conversationId: conversation.conversationId,
-            reason: "Provider Conversation existence is unknown; replacement is fenced."
-        };
-    }
-    if (input.probe.state === "exists") {
-        if (input.probe.activeTurnId !== undefined) {
-            return {
-                action: "observe-active-turn",
-                conversationId: conversation.conversationId,
-                turnId: input.probe.activeTurnId
-            };
-        }
-        if (input.unsettledInputDelivery || providerTurnIsUnsettled(binding)) {
-            return {
-                action: "attention",
-                conversationId: conversation.conversationId,
-                reason: "Provider Conversation exists but prior input delivery is still unsettled."
-            };
-        }
-        return { action: "resume", conversationId: conversation.conversationId };
-    }
-    if (input.unsettledInputDelivery || providerTurnIsUnsettled(binding)) {
-        return {
-            action: "attention",
-            conversationId: conversation.conversationId,
-            reason: "Provider Conversation is missing but input delivery remains unsettled."
-        };
-    }
-    if (currentProviderActivation(binding) !== null || binding.authority.owner !== "none") {
-        return {
-            action: "attention",
-            conversationId: conversation.conversationId,
-            reason: "Provider Conversation is missing but its Activation writer has not ended."
-        };
-    }
-    return { action: "restart-run", conversationId: conversation.conversationId };
-}
-function providerTurnIsUnsettled(binding) {
-    return binding.turn !== null
-        && ["submitting", "accepted", "running", "delivery-unknown"].includes(binding.turn.status);
-}