@xandreed/plugin-models 0.12.0 → 0.14.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.functions.test.d.ts

@@ -0,0 +1 @@
+export {};

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/models-transport.adapter.d.ts

@@ -0,0 +1,48 @@
+import { Config, Effect, Layer, Option } from "effect";
+import type { Context, Scope } from "effect";
+import { ModelsTransport } 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;
+/**
+ * The transport a proxy setting calls for, or `None` when no proxy applies
+ * and nothing has to be held direct: then the plugin adds no transport and
+ * every call uses the runtime's own fetch, as it did before the plugin knew
+ * proxies (a `FetchHttpClient.Fetch` the host provides still reaches the
+ * provider SDKs). With the proxy turned off (`*`) on Node it is a transport
+ * over undici's direct agent, since Node's global fetch and agents apply the
+ * environment's proxy under `NODE_USE_ENV_PROXY`. 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 scope.
+ */
+export declare const modelsTransportFor: (options: HttpProxyOptions) => Effect.Effect<Option.Option<Context.Service.Shape<typeof ModelsTransport>>, 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`). With no proxy at all it is the global fetch, unchanged;
+ * with `noProxy: "*"` on Node, undici's direct agent. 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,102 @@
+import { Agent as HttpAgent } from "node:http";
+import { Agent as HttpsAgent } from "node:https";
+import { Config, Effect, Layer, Match, Option, Redacted } from "effect";
+import { 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, turnsProxyOff, 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]))))).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) }), 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, init),
+    onSome: ([target, proxy]) => throughProxy(target, proxy, globalThis.fetch(input, { ...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", codeOf = (error) => ("code" in error) ? error.code : void 0, tunnelOnce = (connect, proxy) => (options, callback) => connect(options, (...result) => {
+  const [error] = result;
+  return error !== null && codeOf(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 under a proxy setting, could not be loaded: ${describeFailure(cause)}` })
+}), nodeDirect = (undici) => Effect.gen(function* () {
+  const dispatcher = new undici.Agent, sockets = { https: new HttpsAgent, http: new HttpAgent };
+  yield* Effect.addFinalizer(() => Effect.all([
+    Effect.promise(() => dispatcher.destroy().then(() => {
+      return;
+    }, () => {
+      return;
+    })),
+    Effect.sync(() => [sockets.https, sockets.http].forEach((agent) => agent.destroy()))
+  ], { 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),
+    factory: (origin, options) => {
+      const connect = Reflect.get(options, "connect");
+      return new undici.Pool(origin, { ...options, ...isConnector(connect) ? { connect: tunnelOnce(connect, proxy) } : {} });
+    }
+  }), 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, (dispatcher) => Effect.promise(() => dispatcher.destroy().then(() => {
+      return;
+    }, () => {
+      return;
+    })), { discard: !0 }),
+    Effect.sync(() => [...Option.toArray(socketAgents.https), ...Option.toArray(socketAgents.http)].forEach((agent) => agent.destroy()))
+  ], { 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)`))
+    })
+  });
+});
+export const modelsTransportFor = (options) => Effect.gen(function* () {
+  const config = yield* Effect.fromResult(resolveProxy(options, yield* readEnvironment)), runtime = currentRuntime();
+  if (!usesProxy(config))
+    return yield* Match.value(runtime).pipe(Match.tag("Node", () => turnsProxyOff(config) ? Effect.map(nodeDirectTransport, Option.some) : Effect.succeedNone), Match.orElse(() => Effect.succeedNone));
+  return Option.some(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));
+}), ModelsTransportLive = (options = {}) => Layer.effect(ModelsTransport, Effect.map(modelsTransportFor(options), Option.getOrElse(() => 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/models-transport.adapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/transport/recording-proxy.testing.d.ts

@@ -0,0 +1,33 @@
+/** One request a `RecordingProxy` received: a CONNECT tunnel (`host:port`) or an absolute-form request (its URL). */
+export interface ProxiedRequest {
+    readonly kind: "connect" | "absolute";
+    readonly target: string;
+    readonly authorization: string | null;
+}
+export interface RecordingProxy {
+    readonly url: string;
+    readonly port: number;
+    readonly seen: ReadonlyArray<ProxiedRequest>;
+    readonly close: () => Promise<void>;
+}
+/**
+ * A recording HTTP proxy on 127.0.0.1 for tests, over raw sockets (so no
+ * environment proxy applies to it): it records every request, opens CONNECT
+ * tunnels and forwards absolute-form requests to `*.invalid` hosts on this
+ * machine (the port as asked), and refuses every other host with 403, so a
+ * test never reaches the network. `reset: true` makes it close every
+ * connection as soon as it opens; `authenticate: true` answers every request
+ * with 407 (Proxy Authentication Required).
+ */
+export declare const startRecordingProxy: (options?: {
+    readonly reset?: boolean;
+    readonly authenticate?: boolean;
+}) => Promise<RecordingProxy>;
+/**
+ * Whether the machine running the tests has a proxy in its environment. Bun's
+ * fetch applies one to every request without a `proxy` option, whatever a
+ * test's `ConfigProvider` says, so the tests of direct requests skip then.
+ */
+export declare const ambientProxy: boolean;
+/** A port on 127.0.0.1 that nothing listens on (bound, then released). */
+export declare const closedPort: () => Promise<number>;

package/dist/transport/undici-fetch.adapter.d.ts

@@ -0,0 +1,13 @@
+import type { Dispatcher } from "undici";
+import type { ModelsFetch } from "../ports/models-transport.port.js";
+/**
+ * undici's `fetch` through `dispatcher`, typed as the global `fetch`. The
+ * npm undici's requests and responses have the shape of the global fetch
+ * types, but are distinct classes (Node's own fetch is a bundled undici of
+ * its own), and undici declares its own `Headers`, `Blob` and streams. So
+ * nothing downstream may rely on `instanceof Response` or `Headers`: effect's
+ * `FetchHttpClient`, the OpenAI-compatible client and the OAuth requests
+ * read them by shape. This file
+ * is the type-erasure boundary between the two declarations.
+ */
+export declare const undiciFetch: (fetch: typeof import("undici").fetch, dispatcher: Dispatcher) => ModelsFetch;

package/dist/transport/undici-fetch.adapter.js

@@ -0,0 +1 @@
+export const undiciFetch = (fetch, dispatcher) => (input, init) => fetch(input, { ...init, dispatcher });

package/package.json

@@ -1,6 +1,10 @@
 {
   "name": "@xandreed/plugin-models",
-  "version": "0.12.0",
+  "version": "0.14.0",
+  "engines": {
+    "node": ">=24.5",
+    "bun": ">=1.3.0"
+  },
   "type": "module",
   "main": "./dist/index.js",
   "exports": {
@@ -14,10 +18,11 @@
     }
   },
   "dependencies": {
-    "@xandreed/core": "0.12.0",
-    "effect": "4.0.0-rc.118",
-    "@effect/ai-anthropic": "4.0.0-rc.118",
-    "@effect/ai-openai": "4.0.0-rc.118",
+    "@xandreed/core": "0.14.0",
+    "effect": "4.0.7",
+    "@effect/ai-anthropic": "4.0.7",
+    "@effect/ai-openai": "4.0.7",
+    "undici": "^7.30.1",
     "ws": "^8.21.0"
   },
   "private": false,
@@ -29,9 +34,5 @@
     "README.md",
     "LICENSE"
   ],
-  "engines": {
-    "node": ">=24",
-    "bun": ">=1.3.0"
-  },
   "license": "MIT"
 }