@xandreed/plugin-models 0.14.0 → 0.15.0

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)))));
+}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xandreed/plugin-models",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "engines": {
     "node": ">=24.5",
     "bun": ">=1.3.0"
@@ -13,13 +13,15 @@
       "default": "./dist/index.js"
     },
     "./compat": {
-      "types": "./dist/llm/compat.d.ts",
-      "default": "./dist/llm/compat.js"
+      "types": "./dist/compat/index.d.ts",
+      "default": "./dist/compat/index.js"
+    },
+    "./conformance": {
+      "types": "./dist/conformance/index.d.ts",
+      "default": "./dist/conformance/index.js"
     }
   },
   "dependencies": {
-    "@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",
@@ -27,6 +29,10 @@
   },
   "private": false,
   "types": "./dist/index.d.ts",
+  "peerDependencies": {
+    "@xandreed/core": "^0.15.0",
+    "effect": "^4.0.7"
+  },
   "files": [
     "dist",
     "skills",

package/dist/auth/anthropicOAuth.test.d.ts

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

package/dist/auth/credential-refresh.entity.functions.test.d.ts

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

package/dist/auth/localAuth.test.d.ts

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

package/dist/auth/memory-auth.adapter.test.d.ts

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

package/dist/llm/compat.test.d.ts

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

package/dist/llm/modelCatalog.test.d.ts

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

package/dist/llm/openAiCodexWebSocket.test.d.ts

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

package/dist/llm/providers.test.d.ts

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

package/dist/llm/retry.test.d.ts

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

package/dist/llm/router.test.d.ts

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

package/dist/llm/sse.test.d.ts

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

package/dist/plugin.adapter.test.d.ts

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

package/dist/settings/localSettings.test.d.ts

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

package/dist/settings/memory-settings.adapter.test.d.ts

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

package/dist/settings/roleView.test.d.ts

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

package/dist/settings/settings-value.entity.functions.test.d.ts

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

package/dist/transport/http-proxy.entity.functions.test.d.ts

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

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

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

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

@@ -1,33 +0,0 @@
-/** 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>;