@xandreed/plugin-models 0.13.0 → 0.15.0

package/dist/transport/http-proxy.entity.functions.js

@@ -0,0 +1,112 @@
+import { Match, Option, Redacted, Result, SemVer } from "effect";
+import { ProxyConfig, ProxyInvalid } from "./http-proxy.entity.js";
+const present = (value) => Option.filter(Option.fromNullishOr(value), (text) => text.trim().length > 0), firstSet = (values) => Option.fromNullishOr(values.flatMap(([name, value]) => Option.toArray(Option.map(present(value), (text) => [name, text.trim()])))[0]);
+export const redactCredentials = (text) => text.replace(/([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi, "$1<redacted>@"), displayProxy = (url) => {
+  const raw = Redacted.value(url);
+  if (!URL.canParse(raw))
+    return redactCredentials(raw);
+  const parsed = new URL(raw), userinfo = parsed.username.length > 0 || parsed.password.length > 0 ? "<redacted>@" : "";
+  return `${parsed.protocol}//${userinfo}${parsed.host}`;
+}, proxyUrl = (raw, source) => {
+  const text = raw.trim();
+  if (text.length === 0)
+    return Result.succeed(Option.none());
+  const candidate = /^[a-z][a-z0-9+.-]*:\/\//i.test(text) ? text : `http://${text}`;
+  if (!URL.canParse(candidate))
+    return Result.fail(new ProxyInvalid({ source, message: `${source} is not a proxy URL: ${redactCredentials(candidate)}` }));
+  const url = new URL(candidate);
+  if (url.protocol !== "http:" && url.protocol !== "https:")
+    return Result.fail(new ProxyInvalid({
+      source,
+      message: `${source} is a ${url.protocol}// proxy; only http:// and https:// proxies are supported (SOCKS is not)`
+    }));
+  if (url.hostname.length === 0)
+    return Result.fail(new ProxyInvalid({ source, message: `${source} names no proxy host: ${redactCredentials(candidate)}` }));
+  return Result.succeed(Option.some(Redacted.make(url.href)));
+}, parseIpv4 = (text) => {
+  if (!/^\d{1,3}(\.\d{1,3}){3}$/.test(text))
+    return Option.none();
+  const bytes = text.split(".").map(Number);
+  return bytes.every((byte) => byte <= 255) ? Option.some(bytes) : Option.none();
+};
+const ipv6Groups = (text) => {
+  const tail = /(\d{1,3}(?:\.\d{1,3}){3})$/.exec(text);
+  if (tail === null)
+    return Option.some(text);
+  const dotted = tail[1] ?? "";
+  return Option.map(parseIpv4(dotted), (bytes) => {
+    const [a = 0, b = 0, c = 0, d = 0] = bytes;
+    return `${text.slice(0, text.length - dotted.length)}${(a << 8 | b).toString(16)}:${(c << 8 | d).toString(16)}`;
+  });
+};
+export const parseIpv6 = (text) => Option.flatMap(ipv6Groups((text.replace(/^\[|\]$/g, "").split("%")[0] ?? "").toLowerCase()), (address) => {
+  const halves = address.split("::");
+  if (halves.length > 2 || !address.includes(":"))
+    return Option.none();
+  const groupsOf = (half) => half === void 0 || half.length === 0 ? [] : half.split(":"), head = groupsOf(halves[0]), tail = groupsOf(halves[1]), missing = 8 - head.length - tail.length;
+  if (halves.length === 1 ? missing !== 0 : missing < 1)
+    return Option.none();
+  const groups = [...head, ...Array.from({ length: halves.length === 1 ? 0 : missing }, () => "0"), ...tail];
+  return groups.every((group) => /^[0-9a-f]{1,4}$/.test(group)) ? Option.some(groups.flatMap((group) => {
+    const value = Number.parseInt(group, 16);
+    return [value >> 8, value & 255];
+  })) : Option.none();
+});
+const addressOf = (host) => Option.orElse(parseIpv4(host), () => parseIpv6(host)), inRange = (network, prefix, address) => network.length === address.length && network.every((byte, index) => {
+  const bits = Math.min(8, Math.max(0, prefix - index * 8)), mask = bits === 0 ? 0 : 255 << 8 - bits & 255;
+  return (byte & mask) === ((address[index] ?? 0) & mask);
+});
+export const isLoopback = (hostname) => {
+  const host = hostname.toLowerCase().replace(/^\[|\]$/g, "").replace(/\.$/, "");
+  if (host === "localhost" || host.endsWith(".localhost"))
+    return !0;
+  return Option.match(addressOf(host), {
+    onNone: () => !1,
+    onSome: (bytes) => bytes.length === 4 ? bytes[0] === 127 : inRange([...Array.from({ length: 15 }, () => 0), 1], 128, bytes) || inRange([...Array.from({ length: 10 }, () => 0), 255, 255, 127, 0, 0, 0], 104, bytes)
+  });
+};
+const parseRule = (entry) => {
+  const text = entry.toLowerCase();
+  if (text === "*")
+    return Option.some({ _tag: "Everything" });
+  if (text.includes("/")) {
+    const [address = "", bits = ""] = text.split("/", 2);
+    return Option.flatMap(addressOf(address.replace(/^\[|\]$/g, "")), (bytes) => {
+      const prefix = Number(bits);
+      return /^\d+$/.test(bits) && prefix <= bytes.length * 8 ? Option.some({ _tag: "Address", bytes, prefix, port: Option.none() }) : Option.none();
+    });
+  }
+  const bracketed = /^\[([^\]]+)\](?::(\d+))?$/.exec(text), withPort = bracketed === null && (text.match(/:/g) ?? []).length === 1 ? /^(.+):(\d+)$/.exec(text) : null, host = bracketed?.[1] ?? withPort?.[1] ?? text, port = Option.map(Option.fromNullishOr(bracketed?.[2] ?? withPort?.[2]), Number);
+  return Option.some(Option.match(addressOf(host), {
+    onSome: (bytes) => ({ _tag: "Address", bytes, prefix: bytes.length * 8, port }),
+    onNone: () => ({ _tag: "Domain", name: host.replace(/^\*?\./, "").replace(/\.$/, ""), port })
+  }));
+};
+export const parseNoProxy = (value) => value.split(/[\s,]+/).filter((entry) => entry.length > 0).flatMap((entry) => Option.toArray(parseRule(entry)));
+const DEFAULT_PORTS = { "http:": 80, "ws:": 80, "https:": 443, "wss:": 443 };
+export const bypassesProxy = (rules, target) => {
+  const host = target.hostname.toLowerCase().replace(/^\[|\]$/g, "").replace(/\.$/, ""), port = target.port.length > 0 ? Number(target.port) : DEFAULT_PORTS[target.protocol] ?? 0, address = addressOf(host), portMatches = (wanted) => Option.match(wanted, { onNone: () => !0, onSome: (value) => value === port });
+  return rules.some(Match.type().pipe(Match.tag("Everything", () => !0), Match.tag("Domain", (rule) => portMatches(rule.port) && (host === rule.name || host.endsWith(`.${rule.name}`))), Match.tag("Address", (rule) => portMatches(rule.port) && Option.exists(address, (bytes) => inRange(rule.bytes, rule.prefix, bytes))), Match.exhaustive));
+};
+const exemptsEverything = (rules) => rules.some((rule) => rule._tag === "Everything");
+export const resolveProxy = (options, env) => Result.gen(function* () {
+  const explicit = yield* proxyUrl(options.proxy === void 0 ? "" : Redacted.isRedacted(options.proxy) ? Redacted.value(options.proxy) : options.proxy, "the proxy option"), noProxy = parseNoProxy([
+    ...Option.toArray(Option.map(firstSet([["no_proxy", env.no_proxy], ["NO_PROXY", env.NO_PROXY]]), ([, value]) => value)),
+    options.noProxy ?? ""
+  ].join(",")), off = exemptsEverything(noProxy), fromEnv = (names) => Option.match(off ? Option.none() : firstSet(names), {
+    onNone: () => Result.succeed(Option.none()),
+    onSome: ([name, value]) => proxyUrl(value, name)
+  }), http = Option.isSome(explicit) ? explicit : yield* fromEnv([["http_proxy", env.http_proxy], ["HTTP_PROXY", env.HTTP_PROXY]]), https = Option.isSome(explicit) ? explicit : Option.orElse(yield* fromEnv([["https_proxy", env.https_proxy], ["HTTPS_PROXY", env.HTTPS_PROXY]]), () => http);
+  return new ProxyConfig({ https, http, noProxy });
+}), usesProxy = (config) => Option.isSome(config.https) || Option.isSome(config.http), turnsProxyOff = (config) => exemptsEverything(config.noProxy), proxyFor = (target, config) => {
+  if (isLoopback(target.hostname) || bypassesProxy(config.noProxy, target))
+    return Option.none();
+  if (target.protocol === "https:" || target.protocol === "wss:")
+    return config.https;
+  if (target.protocol === "http:" || target.protocol === "ws:")
+    return config.http;
+  return Option.none();
+}, atLeastVersion = (version, minimum) => Result.match(Result.all([SemVer.parse(version.replace(/^v/, "")), SemVer.parse(minimum)]), {
+  onFailure: () => !1,
+  onSuccess: ([current, wanted]) => SemVer.isGreaterThanOrEqualTo(current, wanted)
+});

package/dist/transport/http-proxy.entity.js

@@ -0,0 +1,42 @@
+import { Schema } from "effect";
+export const ProxyUrlOption = Schema.Union([
+  Schema.String,
+  Schema.Redacted(Schema.String).annotate({ message: "proxy is a URL string or a Redacted one" })
+]).annotate({ message: "proxy is a URL string or a Redacted one" }), HttpProxyOptions = Schema.Struct({
+  proxy: Schema.optionalKey(ProxyUrlOption),
+  noProxy: Schema.optionalKey(Schema.String)
+}), ProxyEnvironment = Schema.Struct({
+  https_proxy: Schema.optionalKey(Schema.String),
+  HTTPS_PROXY: Schema.optionalKey(Schema.String),
+  http_proxy: Schema.optionalKey(Schema.String),
+  HTTP_PROXY: Schema.optionalKey(Schema.String),
+  no_proxy: Schema.optionalKey(Schema.String),
+  NO_PROXY: Schema.optionalKey(Schema.String)
+}), PROXY_VARIABLES = ["https_proxy", "HTTPS_PROXY", "http_proxy", "HTTP_PROXY", "no_proxy", "NO_PROXY"], NoProxyRule = Schema.Union([
+  Schema.TaggedStruct("Everything", {}),
+  Schema.TaggedStruct("Domain", { name: Schema.String, port: Schema.Option(Schema.Int) }),
+  Schema.TaggedStruct("Address", {
+    bytes: Schema.Array(Schema.Int),
+    prefix: Schema.Int,
+    port: Schema.Option(Schema.Int)
+  })
+]);
+
+export class ProxyConfig extends Schema.Class("ProxyConfig")({
+  https: Schema.Option(Schema.Redacted(Schema.String)),
+  http: Schema.Option(Schema.Redacted(Schema.String)),
+  noProxy: Schema.Array(NoProxyRule)
+}) {
+}
+
+export class ProxyInvalid extends Schema.TaggedError()("ProxyInvalid", {
+  source: Schema.String,
+  message: Schema.String
+}) {
+}
+
+export class ProxyUnsupported extends Schema.TaggedError()("ProxyUnsupported", {
+  message: Schema.String
+}) {
+}
+export const BUN_WEBSOCKET_PROXY_VERSION = "1.3.6", NODE_WEBSOCKET_PROXY_VERSION = "24.5.0";

package/dist/transport/model-request.conformance.d.ts

@@ -0,0 +1,13 @@
+import { Effect } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
+import type { ConformanceCheck } from "@xandreed/core/conformance";
+import type { ResilientHttpError, ResilientHttpResponse } from "./resilient-http-client.adapter.js";
+import type { ProviderFailureProtocol } from "../llm/provider-failure.entity.js";
+/** A fresh logical request over a supplied raw transport; request retries belong to the subject. @public */
+export interface ModelRequestSubject {
+    readonly request: (client: HttpClient.HttpClient, request: HttpClientRequest.HttpClientRequest, options: {
+        readonly protocol: ProviderFailureProtocol;
+    }) => Effect.Effect<Pick<ResilientHttpResponse, "text" | "status">, ResilientHttpError>;
+}
+/** Bounded request-policy contract, independent of provider credentials or a real network. @public */
+export declare const modelRequestConformance: (subject?: ModelRequestSubject) => ReadonlyArray<ConformanceCheck>;

package/dist/transport/model-request.conformance.js

@@ -0,0 +1,36 @@
+import { Effect, Exit, Option, Ref } from "effect";
+import { HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/http";
+import { modelFailureOf } from "@xandreed/core";
+import { check, ConformanceFailure } from "@xandreed/core/conformance";
+import { modelRetryDefaults } from "../llm/model-retry-policy.entity.js";
+import { CurrentModelRetryPolicy } from "../ports/model-retry-policy.port.js";
+import { resilientRequest } from "./resilient-http-client.adapter.js";
+const policy = { ...modelRetryDefaults, totalTimeoutMs: 2000, requestTimeoutMs: 100, bodyIdleTimeoutMs: 100, backoff: { initialMs: 0, maxMs: 0, jitter: 0 } }, request = HttpClientRequest.post("https://conformance.invalid/messages").pipe(HttpClientRequest.bodyJsonUnsafe({ fixture: !0 })), expect = (id, holds, message) => holds ? Effect.void : Effect.fail(new ConformanceFailure({ check: id, message })), response = (request, status, type) => HttpClientResponse.fromWeb(request, Response.json({ error: { type, message: "conformance fixture" } }, { status }));
+export const modelRequestConformance = (subject = { request: resilientRequest }) => [
+  check("uses one counter for transport failures and rejected statuses", "mixed-attempts", () => Effect.gen(function* () {
+    const sends = yield* Ref.make(0), client = HttpClient.make((request) => Effect.flatMap(Ref.getAndUpdate(sends, (n) => n + 1), (ordinal) => ordinal === 0 ? Effect.fail(new HttpClientError.HttpClientError({ reason: new HttpClientError.TransportError({ request, description: "fixture" }) })) : Effect.succeed(ordinal < 3 ? response(request, ordinal === 1 ? 429 : 529, ordinal === 1 ? "rate_limit_error" : "overloaded_error") : HttpClientResponse.fromWeb(request, new Response("ok"))))), result = yield* subject.request(client, request, { protocol: "anthropic" }).pipe(Effect.flatMap((reply) => reply.text), Effect.provideService(CurrentModelRetryPolicy, policy));
+    yield* expect("mixed-attempts", result === "ok" && (yield* Ref.get(sends)) === 4, "mixed failures did not reach one fourth-attempt success");
+  })),
+  check("classifies a structured permanent error before retrying its status", "permanent-status", () => Effect.gen(function* () {
+    const sends = yield* Ref.make(0), client = HttpClient.make((request) => Ref.update(sends, (n) => n + 1).pipe(Effect.as(response(request, 429, "invalid_request_error")))), result = yield* Effect.exit(subject.request(client, request, { protocol: "compat" }).pipe(Effect.provideService(CurrentModelRetryPolicy, policy)));
+    yield* expect("permanent-status", Exit.isFailure(result) && (yield* Ref.get(sends)) === 1 && Option.contains(modelFailureOf(result.cause.reasons.find((reason) => reason._tag === "Fail")?.error), "InvalidRequest"), "a permanent request error was retried or lost its semantic kind");
+  })),
+  check("reads a call's policy at execution and obeys its total attempt limit", "dynamic-policy", () => Effect.gen(function* () {
+    const run = (maxAttempts) => Effect.gen(function* () {
+      const sends = yield* Ref.make(0), client = HttpClient.make((request) => Ref.update(sends, (n) => n + 1).pipe(Effect.as(response(request, 503, "overloaded_error"))));
+      yield* Effect.exit(subject.request(client, request, { protocol: "anthropic" }).pipe(Effect.provideService(CurrentModelRetryPolicy, { ...policy, maxAttempts })));
+      return yield* Ref.get(sends);
+    }), one = yield* run(1), three = yield* run(3);
+    yield* expect("dynamic-policy", one === 1 && three === 3, "a call ignored its policy or repeated beyond its total attempt cap");
+  })),
+  check("never sends a settled request again after its pending headers time out", "settled-headers", () => Effect.gen(function* () {
+    const sends = yield* Ref.make(0), client = HttpClient.make(() => Ref.update(sends, (n) => n + 1).pipe(Effect.andThen(Effect.never))), result = yield* subject.request(client, request, { protocol: "anthropic" }).pipe(Effect.provideService(CurrentModelRetryPolicy, { ...policy, requestTimeoutMs: 50, totalTimeoutMs: 300 }), Effect.exit, Effect.timeoutOption("2 seconds")), timedOut = Option.exists(result, (exit) => Exit.isFailure(exit) && Option.contains(modelFailureOf(exit.cause.reasons.find((reason) => reason._tag === "Fail")?.error), "Timeout"));
+    yield* expect("settled-headers", timedOut && (yield* Ref.get(sends)) === 1, "a settled request was cut before its deadline and sent again, or never timed out");
+  })),
+  check("reads a successful body that loses its connection as a transient failure", "lost-body", () => Effect.gen(function* () {
+    const client = HttpClient.make((request) => Effect.sync(() => HttpClientResponse.fromWeb(request, new Response(new ReadableStream({ start(controller) {
+      controller.error(Error("conformance connection reset"));
+    } }))))), result = yield* subject.request(client, request, { protocol: "anthropic" }).pipe(Effect.flatMap((reply) => reply.text), Effect.exit, Effect.provideService(CurrentModelRetryPolicy, policy));
+    yield* expect("lost-body", Exit.isFailure(result) && Option.contains(modelFailureOf(result.cause.reasons.find((reason) => reason._tag === "Fail")?.error), "Transient"), "a lost connection after handoff became a permanent or unclassified failure");
+  }))
+];

package/dist/transport/models-transport.adapter.d.ts

@@ -0,0 +1,49 @@
+import { Config, Context, Effect, Layer, Option, Redacted } from "effect";
+import type { Scope } from "effect";
+import { ModelsTransport } from "../ports/models-transport.port.js";
+import type { ModelsFetch, WebSocketProxy } from "../ports/models-transport.port.js";
+import { ProxyUnsupported } from "./http-proxy.entity.js";
+import type { HttpProxyOptions, ProxyInvalid } from "./http-proxy.entity.js";
+/** The runtime the plugin runs on, told apart without a Bun-only import (the subscription's WebSocket checks its route against it too). */
+export type Runtime = {
+    readonly _tag: "Bun";
+    readonly version: string;
+} | {
+    readonly _tag: "Node";
+    readonly version: string;
+} | {
+    readonly _tag: "Other";
+};
+export declare const currentRuntime: () => Runtime;
+export declare const modelsTransportContextFor: (options: {
+    readonly proxy?: string | Redacted.Redacted<string>;
+    readonly noProxy?: string;
+}) => Effect.Effect<Context.Context<never>, ProxyInvalid | ProxyUnsupported | Config.ConfigError, Scope.Scope>;
+/** The scoped transport: a proxy's, or the managed direct one on Node and Bun; none on another runtime without a proxy. */
+export declare const modelsTransportFor: (options: {
+    readonly proxy?: string | Redacted.Redacted<string>;
+    readonly noProxy?: string;
+}) => Effect.Effect<Option.Option<{
+    readonly fetch: ModelsFetch;
+    readonly webSocketAgent?: (target: URL) => Effect.Effect<Option.Option<WebSocketProxy>, ProxyUnsupported>;
+}>, ProxyInvalid | ProxyUnsupported | Config.ConfigError, Scope.Scope>;
+/**
+ * `ModelsTransportLive(options)` — the models plugin's network path from a
+ * proxy setting: `options.proxy` (or `https_proxy` / `HTTPS_PROXY` and
+ * `http_proxy` / `HTTP_PROXY` from the environment) for every call, except
+ * loopback hosts and the `noProxy` / `NO_PROXY` hosts, which go direct (see
+ * `resolveProxy`). Node always uses a scoped direct undici Agent with its
+ * header/body timeouts disabled; Bun uses its native fetch with fetch's own
+ * timeout turned off. A proxy URL that cannot
+ * be used fails with `ProxyInvalid`; a runtime that is neither Node nor Bun
+ * fails with `ProxyUnsupported` when a proxy applies. Its connection pools
+ * close with the layer's scope. Hosts use it for the OAuth login helpers too:
+ * `exchangeAnthropicCode(code, verifier, { fetch: transport.fetch })`.
+ */
+export declare const ModelsTransportLive: (options?: HttpProxyOptions) => Layer.Layer<ModelsTransport, ProxyInvalid | ProxyUnsupported | Config.ConfigError>;
+/**
+ * A transport's fetch as `FetchHttpClient.Fetch` takes it (the type of the
+ * global `fetch`): a `Request` input is sent as its URL, method, headers,
+ * body and signal; Bun's `fetch.preconnect` does nothing.
+ */
+export declare const transportFetch: (transport: Context.Service.Shape<typeof ModelsTransport>) => typeof globalThis.fetch;

package/dist/transport/models-transport.adapter.js

@@ -0,0 +1,99 @@
+import { Agent as HttpAgent } from "node:http";
+import { Agent as HttpsAgent } from "node:https";
+import { Config, Context, Effect, Layer, Match, Option, Redacted } from "effect";
+import { errorCodeOf } from "@xandreed/core";
+import { CurrentManagedModelsTransport, ModelsTransport } from "../ports/models-transport.port.js";
+import { BUN_WEBSOCKET_PROXY_VERSION, NODE_WEBSOCKET_PROXY_VERSION, PROXY_VARIABLES, ProxyUnsupported } from "./http-proxy.entity.js";
+import { atLeastVersion, displayProxy, proxyFor, redactCredentials, resolveProxy, usesProxy } from "./http-proxy.entity.functions.js";
+import { undiciFetch } from "./undici-fetch.adapter.js";
+export const currentRuntime = () => {
+  const versions = typeof process > "u" ? {} : process.versions, bun = versions.bun, node = versions.node;
+  return bun !== void 0 ? { _tag: "Bun", version: bun } : node !== void 0 ? { _tag: "Node", version: node } : { _tag: "Other" };
+};
+const readEnvironment = Effect.forEach(PROXY_VARIABLES, (name) => Config.option(Config.String(name)).pipe(Effect.map((value) => Option.toArray(Option.map(value, (text) => [name, text])))), { concurrency: 1 }).pipe(Effect.map((entries) => Object.fromEntries(entries.flat()))), targetOf = (input) => typeof input === "string" ? URL.canParse(input) ? Option.some(new URL(input)) : Option.none() : Option.some(input), isSecure = (target) => target.protocol === "https:" || target.protocol === "wss:", describeFailure = (cause) => {
+  const own = cause instanceof Error ? cause.message : String(cause), inner = cause instanceof Error && cause.cause !== void 0 ? cause.cause instanceof Error ? cause.cause.message : String(cause.cause) : "";
+  return redactCredentials(inner.length > 0 && inner !== own ? `${own}: ${inner}` : own);
+}, throughProxy = (target, proxy, request) => request.then((response) => response, (cause) => Promise.reject(cause instanceof Error && (cause.name === "AbortError" || cause.name === "TimeoutError") ? cause : TypeError(`the request to ${target.protocol}//${target.host} through the proxy ${displayProxy(proxy)} failed: ${describeFailure(cause)}`, { cause }))), directTransport = ModelsTransport.of({ fetch: (input, init) => globalThis.fetch(input, init) }), untimed = (init) => ({ ...init, timeout: !1 }), bunDirectTransport = ModelsTransport.of({ fetch: (input, init) => globalThis.fetch(input, untimed(init)) }), webSocketRefused = (target, why) => new ProxyUnsupported({
+  message: `${why}, so the WebSocket to ${target.host} is refused instead of connecting directly past the proxy`
+}), refuseProxyAuthentication = (response) => response.status === 407 ? (response.body === null ? Promise.resolve() : response.body.cancel().then(() => {
+  return;
+}, () => {
+  return;
+})).then(() => Promise.reject(Error("the proxy refused its credentials (407 Proxy Authentication Required)"))) : Promise.resolve(response), bunTransport = (config, version) => ModelsTransport.of({
+  fetch: (input, init) => Option.match(Option.flatMap(targetOf(input), (target) => Option.map(proxyFor(target, config), (proxy) => [target, proxy])), {
+    onNone: () => globalThis.fetch(input, untimed(init)),
+    onSome: ([target, proxy]) => throughProxy(target, proxy, globalThis.fetch(input, { ...untimed(init), proxy: Redacted.value(proxy) }).then(refuseProxyAuthentication))
+  }),
+  webSocketAgent: (target) => Option.match(proxyFor(target, config), {
+    onNone: () => Effect.succeedNone,
+    onSome: (url) => atLeastVersion(version, BUN_WEBSOCKET_PROXY_VERSION) ? Effect.succeedSome({ _tag: "Proxy", url }) : Effect.fail(webSocketRefused(target, `Bun ${version} cannot send a WebSocket through a proxy (Bun ${BUN_WEBSOCKET_PROXY_VERSION} and later can)`))
+  })
+}), isConnector = (value) => typeof value === "function", tunnelOnce = (connect, proxy) => (options, callback) => connect(options, (...result) => {
+  const [error] = result;
+  return error !== null && Option.contains(errorCodeOf(error), "UND_ERR_SOCKET") ? callback(Error(`the proxy ${displayProxy(proxy)} closed the connection while opening a tunnel to ${options.hostname}:${options.port.length > 0 ? options.port : options.protocol === "https:" ? "443" : "80"} (${error.message})`, { cause: error }), null) : callback(...result);
+}), loadUndici = Effect.tryPromise({
+  try: () => import("undici"),
+  catch: (cause) => new ProxyUnsupported({ message: `undici, which sends the models plugin's calls on Node, could not be loaded: ${describeFailure(cause)}` })
+}), destroyDispatcher = (dispatcher) => Effect.tryPromise({ try: () => dispatcher.destroy(), catch: (cause) => cause }).pipe(Effect.catch((cause) => Effect.logDebug("models transport: a connection pool did not close", cause))), nodeDirect = (undici) => Effect.gen(function* () {
+  const dispatcher = new undici.Agent({ headersTimeout: 0, bodyTimeout: 0 }), sockets = { https: new HttpsAgent, http: new HttpAgent };
+  yield* Effect.addFinalizer(() => Effect.all([
+    destroyDispatcher(dispatcher),
+    Effect.sync(() => [sockets.https, sockets.http].forEach((agent) => agent.destroy()))
+  ], { concurrency: 1, discard: !0 }));
+  return {
+    fetch: undiciFetch(undici.fetch, dispatcher),
+    webSocket: (target) => ({ _tag: "Agent", agent: isSecure(target) ? sockets.https : sockets.http })
+  };
+}), nodeDirectTransport = Effect.gen(function* () {
+  const direct = yield* nodeDirect(yield* loadUndici);
+  return ModelsTransport.of({ fetch: direct.fetch, webSocketAgent: (target) => Effect.succeedSome(direct.webSocket(target)) });
+}), nodeTransport = (config, version) => Effect.gen(function* () {
+  const undici = yield* loadUndici, direct = yield* nodeDirect(undici), proxyAgent = (proxy) => new undici.ProxyAgent({
+    uri: Redacted.value(proxy),
+    clientFactory: (origin, options) => new undici.Pool(origin, { ...options, headersTimeout: 0, bodyTimeout: 0 }),
+    factory: (origin, options) => {
+      const connect = Reflect.get(options, "connect");
+      return new undici.Pool(origin, { ...options, ...isConnector(connect) ? { connect: tunnelOnce(connect, proxy) } : {}, headersTimeout: 0, bodyTimeout: 0 });
+    }
+  }), sameUrl = Option.isSome(config.https) && Option.isSome(config.http) && Redacted.value(config.https.value) === Redacted.value(config.http.value), route = (proxy) => {
+    const dispatcher = proxyAgent(proxy);
+    return { proxy, dispatcher, fetch: undiciFetch(undici.fetch, dispatcher) };
+  }, httpsRoute = Option.map(config.https, route), httpRoute = sameUrl ? httpsRoute : Option.map(config.http, route), socketAgents = {
+    https: Option.map(config.https, (proxy) => new HttpsAgent({ proxyEnv: { HTTPS_PROXY: Redacted.value(proxy) } })),
+    http: Option.map(config.http, (proxy) => new HttpAgent({ proxyEnv: { HTTP_PROXY: Redacted.value(proxy) } }))
+  }, dispatchers = [...Option.toArray(Option.map(httpsRoute, (route) => route.dispatcher)), ...sameUrl ? [] : Option.toArray(Option.map(httpRoute, (route) => route.dispatcher))];
+  yield* Effect.addFinalizer(() => Effect.all([
+    Effect.forEach(dispatchers, destroyDispatcher, { concurrency: 1, discard: !0 }),
+    Effect.sync(() => [...Option.toArray(socketAgents.https), ...Option.toArray(socketAgents.http)].forEach((agent) => agent.destroy()))
+  ], { concurrency: 1, discard: !0 }));
+  const routeFor = (target) => Option.flatMap(proxyFor(target, config), () => isSecure(target) ? httpsRoute : httpRoute), fetch = (input, init) => Option.match(Option.flatMap(targetOf(input), (target) => Option.map(routeFor(target), (route) => [target, route])), {
+    onNone: () => direct.fetch(input, init),
+    onSome: ([target, route]) => throughProxy(target, route.proxy, route.fetch(input, init))
+  });
+  return ModelsTransport.of({
+    fetch,
+    webSocketAgent: (target) => Option.match(Option.flatMap(proxyFor(target, config), () => isSecure(target) ? socketAgents.https : socketAgents.http), {
+      onNone: () => Effect.succeedSome(direct.webSocket(target)),
+      onSome: (agent) => atLeastVersion(version, NODE_WEBSOCKET_PROXY_VERSION) ? Effect.succeedSome({ _tag: "Agent", agent }) : Effect.fail(webSocketRefused(target, `Node ${version} ignores the proxyEnv option of https.Agent (Node ${NODE_WEBSOCKET_PROXY_VERSION} and later honour it)`))
+    })
+  });
+}), managedDirect = (transport) => Context.make(ModelsTransport, transport).pipe(Context.add(CurrentManagedModelsTransport, Option.some(transport)));
+export const modelsTransportContextFor = Effect.fnUntraced(function* (options) {
+  const config = yield* Effect.fromResult(resolveProxy(options, yield* readEnvironment)), runtime = currentRuntime();
+  if (!usesProxy(config))
+    return yield* Match.value(runtime).pipe(Match.tag("Node", () => Effect.map(nodeDirectTransport, managedDirect)), Match.tag("Bun", () => Effect.succeed(managedDirect(bunDirectTransport))), Match.orElse(() => Effect.succeed(Context.empty())));
+  const transport = yield* Match.value(runtime).pipe(Match.tag("Bun", ({ version }) => Effect.succeed(bunTransport(config, version))), Match.tag("Node", ({ version }) => nodeTransport(config, version)), Match.tag("Other", () => Effect.fail(new ProxyUnsupported({
+    message: "a proxy is configured, but this runtime is neither Node nor Bun: the models plugin cannot send its calls through a proxy here"
+  }))), Match.exhaustive);
+  return Context.make(ModelsTransport, transport).pipe(Context.add(CurrentManagedModelsTransport, Option.none()));
+}), modelsTransportFor = Effect.fnUntraced(function* (options) {
+  return Context.getOption(yield* modelsTransportContextFor(options), ModelsTransport);
+}), ModelsTransportLive = (options = {}) => Layer.effectContext(Effect.map(modelsTransportContextFor(options), (context) => Context.add(context, ModelsTransport, Option.getOrElse(Context.getOption(context, ModelsTransport), () => directTransport)))), transportFetch = (transport) => Object.assign((input, init) => input instanceof Request ? input.arrayBuffer().then((body) => transport.fetch(input.url, {
+  method: input.method,
+  headers: input.headers,
+  body: body.byteLength === 0 ? null : body,
+  signal: input.signal,
+  ...init
+})) : transport.fetch(input, init), { preconnect: () => {
+  return;
+} });

package/dist/transport/resilient-http-client.adapter.d.ts

@@ -0,0 +1,73 @@
+import { Effect, Ref, Schema, Stream } from "effect";
+import { AiError } from "effect/ai";
+import { HttpClient, HttpClientError, HttpClientResponse, UrlParams } from "effect/http";
+import type { HttpClientRequest } from "effect/http";
+import type { ModelCallMethod, ModelSelection, TurnError } from "@xandreed/core";
+import { ModelRequestState, ModelRetryPolicy } from "../llm/model-retry-policy.entity.js";
+import type { ProviderFailureProtocol } from "../llm/provider-failure.entity.js";
+import type { ModelAttempt, ModelCompletionCall } from "../llm/model-completion.adapter.js";
+export type ResilientHttpError = HttpClientError.HttpClientError | AiError.AiError | TurnError;
+type BodyReaders = "json" | "text" | "arrayBuffer" | "urlParamsBody" | "formData" | "stream";
+/** Exact body-reader error channels before the existing SDK-boundary adaptation. */
+export type ResilientHttpResponse = Omit<HttpClientResponse.HttpClientResponse, BodyReaders> & {
+    readonly json: Effect.Effect<Schema.Json, ResilientHttpError>;
+    readonly text: Effect.Effect<string, ResilientHttpError>;
+    readonly arrayBuffer: Effect.Effect<ArrayBuffer, ResilientHttpError>;
+    readonly urlParamsBody: Effect.Effect<UrlParams.UrlParams, ResilientHttpError>;
+    readonly formData: Effect.Effect<FormData, ResilientHttpError>;
+    readonly stream: Stream.Stream<Uint8Array, ResilientHttpError>;
+    readonly modelAttempt: {
+        readonly call: ModelRequestCall;
+        readonly ordinal: number;
+        readonly completion: ModelAttempt;
+    };
+};
+/** One call's ephemeral identity and observable physical-attempt state; no stored ledger. */
+export interface ModelRequestCall {
+    readonly policy: ModelRetryPolicy;
+    readonly completion: ModelCompletionCall;
+    readonly startedAt: number;
+    readonly deadline: number;
+    readonly reserveFallback: boolean;
+    readonly state: Ref.Ref<ModelRequestState>;
+}
+export declare const makeModelRequestCall: (options: {
+    readonly reserveFallback: boolean;
+}) => Effect.Effect<ModelRequestCall, AiError.AiError, never>;
+export declare const modelRequestSnapshot: (call: ModelRequestCall) => Effect.Effect<ModelRequestState>;
+export declare const enterModelFallback: (call: ModelRequestCall, error: unknown) => Effect.Effect<boolean, never, never>;
+/**
+ * A handed-off response with its body observed as it passes. A response
+ * this client handed off stays guarded: its readers keep their exact typed
+ * failures (timeouts, lost connections) and its model attempt. Any other
+ * response is rebuilt over a Web body.
+ */
+export declare const observedResponse: (response: HttpClientResponse.HttpClientResponse, observe: (bytes: Uint8Array) => Effect.Effect<void>) => Effect.Effect<HttpClientResponse.HttpClientResponse | ResilientHttpResponse>;
+/**
+ * How one request is sent: its error vocabulary, whether its response is
+ * settled (headers arrive only once the whole response is generated; absent:
+ * every call method but a stream's is settled) and the caller's admission
+ * before each physical send.
+ */
+export interface ResilientRequestOptions {
+    readonly protocol: ProviderFailureProtocol;
+    readonly settled?: boolean;
+    readonly beforeSend?: Effect.Effect<void, AiError.AiError>;
+}
+/**
+ * One retry owner before response handoff; successful response readers
+ * retain exact typed failures. A streamed request waits for its headers at
+ * most `requestTimeoutMs`; a settled one's headers come with the whole
+ * generation, so they wait for the call's deadline and a timeout there is
+ * final instead of a second generation.
+ */
+export declare const resilientRequest: <R>(client: HttpClient.HttpClient.With<HttpClientError.HttpClientError, R>, request: HttpClientRequest.HttpClientRequest, options: ResilientRequestOptions) => Effect.Effect<ResilientHttpResponse, ResilientHttpError, R>;
+export declare const resilientHttpClient: <R>(client: HttpClient.HttpClient.With<HttpClientError.HttpClientError, R>, options: {
+    readonly protocol: ProviderFailureProtocol;
+    readonly adaptResponse: (response: ResilientHttpResponse) => HttpClientResponse.HttpClientResponse;
+}) => HttpClient.HttpClient.With<ResilientHttpError, R>;
+/** One provider invocation owns cleanup of a handed-off body that failed before raw decoding. */
+export declare const withModelRequestCall: <A, E, R>(method: ModelCallMethod, selection: ModelSelection, operation: Effect.Effect<A, E, R>) => Effect.Effect<A, E | AiError.AiError | TurnError, R>;
+/** Fixed SDK streams bridge an original recorder TurnError as a defect; no data/error relabeling. */
+export declare const withModelRequestStream: <A, E, R>(method: ModelCallMethod, selection: ModelSelection, stream: Stream.Stream<A, E, R>) => Stream.Stream<A, E | AiError.AiError | TurnError, R>;
+export {};

package/dist/transport/resilient-http-client.adapter.js

@@ -0,0 +1,177 @@
+import { Clock, Duration, Effect, Exit, Inspectable, Match, Option, Random, Ref, Schema, Stream } from "effect";
+import { AiError } from "effect/ai";
+import { HttpClient, HttpClientError, HttpClientResponse, UrlParams } from "effect/http";
+import { isTurnError, modelFailureMessageOf, modelFailureOf, stampAiErrorFailure } from "@xandreed/core";
+import { ModelRequestState, ModelRetryPolicy } from "../llm/model-retry-policy.entity.js";
+import { enterFallbackState, retryableModelFailure, retryDelayMillis, retryHintMillis, startAttemptState } from "../llm/model-retry-policy.entity.functions.js";
+import { CurrentModelRequestCall, CurrentModelRetryPolicy } from "../ports/model-retry-policy.port.js";
+import { ProviderErrorBody } from "../llm/provider-failure.entity.js";
+import { classifyAiError } from "../llm/provider-failure.entity.functions.js";
+import { classifyLlmError } from "../llm/retry.js";
+import { attachModelAttempt, beginModelAttempt, completeModelAttempt, completePendingAttempts, makeCompletionCall, observeModelBody, retainModelAttempt } from "../llm/model-completion.adapter.js";
+import { CurrentModelCallMetadataOwner, CurrentModelCallMethod, CurrentModelCallSelection } from "../ports/model-call-completion.port.js";
+const timeoutFailure = () => stampAiErrorFailure(AiError.make({ module: "Models", method: "request", reason: new AiError.UnknownError({ description: modelFailureMessageOf("Timeout") }) }), "Timeout");
+export const makeModelRequestCall = Effect.fnUntraced(function* (options) {
+  const policy = yield* Schema.decodeUnknownEffect(ModelRetryPolicy)(yield* CurrentModelRetryPolicy, { onExcessProperty: "error" }).pipe(Effect.mapError(() => stampAiErrorFailure(AiError.make({ module: "Models", method: "requestPolicy", reason: new AiError.InvalidRequestError({ description: modelFailureMessageOf("InvalidRequest") }) }), "InvalidRequest"))), startedAt = yield* Clock.currentTimeMillis, state = yield* Ref.make({ _tag: "Ready", rung: "Primary", attempts: 0 });
+  return { policy, completion: yield* makeCompletionCall(), startedAt, deadline: startedAt + policy.totalTimeoutMs, reserveFallback: options.reserveFallback, state };
+}), modelRequestSnapshot = (call) => Ref.get(call.state), enterModelFallback = Effect.fnUntraced(function* (call, error) {
+  const now = yield* Clock.currentTimeMillis;
+  if (now >= call.deadline || classifyLlmError(error, now) !== "transient")
+    return !1;
+  return yield* Ref.modify(call.state, (state) => Option.match(enterFallbackState(state, call.policy, call.reserveFallback), {
+    onNone: () => [!1, state],
+    onSome: (next) => [!0, next]
+  }));
+});
+const timed = (effect, boundMs) => effect.pipe(Effect.timeoutOrElse({ duration: Duration.millis(boundMs), orElse: () => Effect.fail(timeoutFailure()) })), pendingRead = (effect, call, boundMs) => Effect.flatMap(Clock.currentTimeMillis, (now) => now >= call.deadline ? Effect.fail(timeoutFailure()) : timed(effect, Math.min(boundMs, call.deadline - now))), rejectedBody = (response, call) => Stream.transformPull(response.stream, (pull) => Effect.succeed(pendingRead(pull, call, call.policy.bodyIdleTimeoutMs))), requestDetails = (request) => {
+  const url = URL.canParse(request.url) ? new URL(request.url) : new URL("https://provider.invalid/");
+  return { method: request.method, url: `${url.protocol}//${url.host}${url.pathname}`, urlParams: [], headers: {} };
+}, bodyReadFailure = (response) => AiError.make({ module: "Models", method: "request", reason: new AiError.NetworkError({ reason: "TransportError", request: requestDetails(response.request), description: modelFailureMessageOf("Transient") }) }), committedBody = (response, call) => Stream.transformPull(response.stream, (pull) => Effect.succeed(timed(pull, call.policy.bodyIdleTimeoutMs))).pipe(Stream.mapError((error) => HttpClientError.isHttpClientError(error) && error.reason._tag === "DecodeError" ? bodyReadFailure(response) : error)), concatenate = (pieces) => {
+  const bytes = new Uint8Array(pieces.reduce((size, piece) => size + piece.byteLength, 0));
+  pieces.reduce((offset, piece) => {
+    bytes.set(piece, offset);
+    return offset + piece.byteLength;
+  }, 0);
+  return bytes;
+};
+
+class GuardedResponse {
+  stream;
+  buffered;
+  modelAttempt;
+  [HttpClientResponse.TypeId] = HttpClientResponse.TypeId;
+  ["~effect/http/HttpIncomingMessage"] = "~effect/http/HttpIncomingMessage";
+  #original;
+  constructor(original, stream, buffered, modelAttempt) {
+    this.stream = stream;
+    this.buffered = buffered;
+    this.modelAttempt = modelAttempt;
+    this.#original = original;
+  }
+  get request() {
+    return this.#original.request;
+  }
+  get url() {
+    return this.#original.url;
+  }
+  get status() {
+    return this.#original.status;
+  }
+  get headers() {
+    return this.#original.headers;
+  }
+  get cookies() {
+    return this.#original.cookies;
+  }
+  get remoteAddress() {
+    return this.#original.remoteAddress;
+  }
+  get upgrade() {
+    return this.#original.upgrade;
+  }
+  get pipe() {
+    return this.#original.pipe;
+  }
+  get arrayBuffer() {
+    return Effect.map(this.buffered, (bytes) => bytes.buffer);
+  }
+  get text() {
+    return Effect.map(this.buffered, (bytes) => new TextDecoder().decode(bytes));
+  }
+  get json() {
+    return this.text.pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Json))), Effect.mapError((cause) => AiError.isAiError(cause) || HttpClientError.isHttpClientError(cause) || isTurnError(cause) ? cause : this.decodeFailure(cause)));
+  }
+  get urlParamsBody() {
+    return Effect.map(this.text, (text) => UrlParams.fromInput(new URLSearchParams(text)));
+  }
+  get formData() {
+    return this.buffered.pipe(Effect.flatMap((bytes) => Effect.tryPromise({ try: () => new Response(bytes, { headers: this.headers }).formData(), catch: (cause) => this.decodeFailure(cause) })));
+  }
+  decodeFailure(cause) {
+    return new HttpClientError.HttpClientError({ reason: new HttpClientError.DecodeError({ request: this.request, response: this.#original, cause, description: modelFailureMessageOf("InvalidResponse") }) });
+  }
+  toJSON() {
+    return this.#original.toJSON();
+  }
+  toString() {
+    return this.#original.toString();
+  }
+  [Inspectable.NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+}
+const guardedResponse = Effect.fnUntraced(function* (response, stream, modelAttempt) {
+  const buffered = yield* Effect.cached(Stream.runCollect(stream).pipe(Effect.map(concatenate)));
+  return attachModelAttempt(modelAttempt.completion, new GuardedResponse(response, stream, buffered, modelAttempt));
+}), wrapResponse = (response, call, ordinal, completion) => guardedResponse(response, committedBody(response, call), { call, ordinal, completion });
+export const observedResponse = (response, observe) => response instanceof GuardedResponse ? guardedResponse(response, response.stream.pipe(Stream.tap(observe)), response.modelAttempt) : Effect.map(Stream.toReadableStreamEffect(response.stream.pipe(Stream.tap(observe))), (body) => retainModelAttempt(response, HttpClientResponse.fromWeb(response.request, new Response(body, { status: response.status, headers: new Headers(Object.entries(response.headers)) }))));
+const httpDetails = (response, body) => ({ request: requestDetails(response.request), response: { status: response.status, headers: Object.fromEntries(Object.entries(response.headers).filter(([key]) => ["request-id", "x-request-id", "retry-after", "retry-after-ms"].includes(key))) }, body }), responseFailure = (response, text, protocol) => {
+  const http = httpDetails(response, text), classified = classifyAiError(AiError.make({ module: "Models", method: "request", reason: new AiError.UnknownError({ http }) }), protocol), kind = Option.getOrElse(modelFailureOf(classified), () => "Unknown"), diagnostic = Option.flatMap(Schema.decodeUnknownOption(Schema.fromJsonString(ProviderErrorBody))(text), (body) => Option.fromNullishOr([
+    typeof body.error === "string" ? body.error : body.error?.message,
+    body.message
+  ].find((value) => typeof value === "string" && value.trim().length > 0))), common = { http, description: Option.match(diagnostic, { onNone: () => modelFailureMessageOf(kind), onSome: (message) => message.slice(0, 500) }) }, reason = Match.value(kind).pipe(Match.when("Authentication", () => new AiError.AuthenticationError({ ...common, kind: response.status === 403 ? "InsufficientPermissions" : "InvalidKey" })), Match.when("Quota", () => new AiError.QuotaExhaustedError(common)), Match.when("RateLimit", () => new AiError.RateLimitError(common)), Match.when("InvalidRequest", () => new AiError.InvalidRequestError(common)), Match.when("ContextOverflow", () => new AiError.InvalidRequestError(common)), Match.when("InvalidResponse", () => new AiError.InvalidResponseError(common)), Match.when("Transient", () => new AiError.InternalProviderError(common)), Match.orElse(() => new AiError.UnknownError(common)));
+  return stampAiErrorFailure(AiError.make({ module: "Models", method: "request", reason }), kind);
+}, errorBody = Effect.fnUntraced(function* (response, call, attempt) {
+  const bytes = new Uint8Array(65536), retained = yield* Ref.make(0), size = yield* Stream.runFoldEffect(rejectedBody(response, call), () => 0, (size, piece) => {
+    const keep = Math.min(piece.byteLength, bytes.byteLength - size);
+    bytes.set(piece.subarray(0, keep), size);
+    return size + piece.byteLength > bytes.byteLength ? Effect.fail(stampAiErrorFailure(AiError.make({ module: "Models", method: "request", reason: new AiError.InvalidResponseError({ description: modelFailureMessageOf("InvalidResponse"), http: httpDetails(response, new TextDecoder().decode(bytes)) }) }), "InvalidResponse")) : Ref.set(retained, size + piece.byteLength).pipe(Effect.as(size + piece.byteLength));
+  }).pipe(Effect.tap((size) => observeModelBody(attempt, new TextDecoder().decode(bytes.subarray(0, size)), !0)), Effect.catchTag("HttpClientError", (error) => ["DecodeError", "EmptyBodyError", "TransportError"].includes(error.reason._tag) ? Ref.get(retained).pipe(Effect.tap((size) => observeModelBody(attempt, new TextDecoder().decode(bytes.subarray(0, size)), !1))) : Effect.fail(error)), Effect.tapError(() => Ref.get(retained).pipe(Effect.flatMap((size) => observeModelBody(attempt, new TextDecoder().decode(bytes.subarray(0, size)), !1)))));
+  return new TextDecoder().decode(bytes.subarray(0, size));
+}), errorKind = (error) => HttpClientError.isHttpClientError(error) ? Match.valueTags(error.reason, {
+  TransportError: () => "Transient",
+  EncodeError: () => "InvalidRequest",
+  InvalidUrlError: () => "InvalidRequest",
+  StatusCodeError: () => "Unknown",
+  DecodeError: () => "InvalidResponse",
+  EmptyBodyError: () => "InvalidResponse"
+}) : Option.getOrElse(modelFailureOf(error), () => "Unknown"), replayableBody = (request) => Match.valueTags(request.body, {
+  Empty: () => !0,
+  Uint8Array: () => !0,
+  Stream: () => !1,
+  FormData: () => !1,
+  Raw: (body) => typeof body.body === "string" || body.body instanceof ArrayBuffer || ArrayBuffer.isView(body.body)
+}), awaitReady = Effect.fnUntraced(function* (call) {
+  const now = yield* Clock.currentTimeMillis;
+  if (now >= call.deadline)
+    return yield* Effect.fail(timeoutFailure());
+  const state = yield* Ref.get(call.state), readyAt = ModelRequestState.match(state, { Ready: () => now, Rejected: (value) => value.retryAt ?? now, Sending: () => now, Committed: () => now });
+  if (readyAt > now)
+    yield* Effect.sleep(Duration.millis(Math.min(readyAt - now, call.deadline - now)));
+  if ((yield* Clock.currentTimeMillis) >= call.deadline)
+    return yield* Effect.fail(timeoutFailure());
+}), requestCall = Effect.fnUntraced(function* () {
+  const inherited = yield* CurrentModelRequestCall;
+  if (Option.isSome(inherited) && (yield* Ref.get(inherited.value.state))._tag !== "Committed")
+    return inherited.value;
+  return yield* makeModelRequestCall({ reserveFallback: !1 });
+});
+export const resilientRequest = Effect.fn("models.request")(function* (client, request, options) {
+  const call = yield* requestCall(), replayable = replayableBody(request), headerBound = options.settled ?? (yield* CurrentModelCallMethod) !== "Stream" ? call.policy.totalTimeoutMs : call.policy.requestTimeoutMs, run = (previous) => Effect.gen(function* () {
+    yield* awaitReady(call);
+    yield* options.beforeSend ?? Effect.void;
+    const started = yield* Ref.modify(call.state, (state) => Option.match(startAttemptState(state, call.policy, call.reserveFallback), { onNone: () => [Option.none(), state], onSome: (next) => [Option.some(next.attempts), next] }));
+    if (Option.isNone(started))
+      return yield* Option.match(previous, { onNone: () => Effect.fail(stampAiErrorFailure(AiError.make({ module: "Models", method: "request", reason: new AiError.InvalidRequestError({ description: modelFailureMessageOf("InvalidRequest") }) }), "InvalidRequest")), onSome: Effect.fail });
+    const ordinal = started.value, attempt = yield* beginModelAttempt(call.completion, ordinal, options.protocol), execute = client.execute(request).pipe(Effect.provideService(CurrentModelRequestCall, Option.some(call)), Effect.catchTag("HttpClientError", (error) => error.reason._tag === "StatusCodeError" ? Effect.succeed(error.reason.response) : Effect.fail(error))), result = yield* Effect.result(pendingRead(execute, call, headerBound).pipe(Effect.flatMap((response) => response.status >= 200 && response.status < 300 ? Ref.update(call.state, (state) => state._tag === "Sending" && state.attempts === ordinal ? { _tag: "Committed", rung: state.rung, attempts: ordinal } : state).pipe(Effect.andThen(wrapResponse(response, call, ordinal, attempt))) : errorBody(response, call, attempt).pipe(Effect.flatMap((body) => Effect.fail(responseFailure(response, body, options.protocol)))))));
+    if (result._tag === "Success")
+      return result.success;
+    const failure = result.failure;
+    if (isTurnError(failure))
+      return yield* Effect.fail(failure);
+    const kind = errorKind(failure);
+    yield* completeModelAttempt(attempt, { _tag: "Failed", failure: Option.some(kind) });
+    const now = yield* Clock.currentTimeMillis, hint = AiError.isAiError(failure) && "http" in failure.reason ? retryHintMillis(failure.reason.http?.response?.headers ?? {}, now) : Option.none(), delay = retryDelayMillis(call.policy, ordinal, yield* Random.next, hint);
+    yield* Ref.update(call.state, (state) => state._tag === "Sending" && state.attempts === ordinal ? { _tag: "Rejected", rung: state.rung, attempts: ordinal, kind, replayable, ...retryableModelFailure(kind) && replayable ? { retryAt: now + delay } : {} } : state);
+    const state = yield* Ref.get(call.state);
+    return Option.isSome(startAttemptState(state, call.policy, call.reserveFallback)) ? yield* run(Option.some(failure)) : yield* Effect.fail(failure);
+  });
+  return yield* run(Option.none()).pipe(Effect.onExit((exit) => Exit.isFailure(exit) ? completePendingAttempts(call.completion, exit) : Effect.void));
+}), resilientHttpClient = (client, options) => HttpClient.makeWith((prepared) => Effect.flatMap(prepared, (request) => resilientRequest(HttpClient.makeWith(client.postprocess, Effect.succeed), request, options).pipe(Effect.map(options.adaptResponse))), client.preprocess), withModelRequestCall = (method, selection, operation) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+  const call = yield* requestCall(), inherited = Option.contains(yield* CurrentModelCallMetadataOwner, call.completion.callId), effectiveMethod = inherited ? yield* CurrentModelCallMethod : method, effectiveSelection = inherited ? yield* CurrentModelCallSelection : Option.some(selection), result = yield* Effect.exit(restore(operation.pipe(Effect.provideService(CurrentModelRequestCall, Option.some(call)), Effect.provideService(CurrentModelCallMethod, effectiveMethod), Effect.provideService(CurrentModelCallSelection, effectiveSelection), Effect.provideService(CurrentModelCallMetadataOwner, Option.some(call.completion.callId)))));
+  yield* completePendingAttempts(call.completion, result);
+  return yield* Exit.match(result, { onSuccess: Effect.succeed, onFailure: Effect.failCause });
+})), withModelRequestStream = (method, selection, stream) => Stream.unwrap(Effect.gen(function* () {
+  const call = yield* requestCall(), inherited = Option.contains(yield* CurrentModelCallMetadataOwner, call.completion.callId), effectiveMethod = inherited ? yield* CurrentModelCallMethod : method, effectiveSelection = inherited ? yield* CurrentModelCallSelection : Option.some(selection);
+  return stream.pipe(Stream.provideService(CurrentModelRequestCall, Option.some(call)), Stream.provideService(CurrentModelCallMethod, effectiveMethod), Stream.provideService(CurrentModelCallSelection, effectiveSelection), Stream.provideService(CurrentModelCallMetadataOwner, Option.some(call.completion.callId)), Stream.onEnd(completePendingAttempts(call.completion, Exit.succeed(void 0))), Stream.onExit((exit) => completePendingAttempts(call.completion, Exit.isSuccess(exit) ? Exit.interrupt() : exit).pipe(Effect.catch((error) => Effect.die(error)))));
+}));