@xandreed/plugin-models 0.13.0 → 0.15.0

package/dist/llm/retry.js

@@ -1,58 +1,39 @@
 import { AiError } from "effect/ai";
-import { Duration, Effect, Ref, Schedule, Stream } from "effect";
-import { CurrentEmptyResponseTolerance } from "@xandreed/core";
-export const LLM_REQUEST_TIMEOUT_MS = 300000, MAX_HONORED_RETRY_AFTER_MS = 60000;
-const retryAfterMillis = (headers) => {
-  const raw = headers?.["retry-after"];
-  if (raw === void 0)
-    return;
-  const seconds = Number(raw);
-  if (Number.isFinite(seconds))
-    return seconds * 1000;
-  const at = Date.parse(raw);
-  return Number.isNaN(at) ? void 0 : Math.max(0, at - Date.now());
-}, rateLimited = (waitMs) => waitMs !== void 0 && waitMs > MAX_HONORED_RETRY_AFTER_MS ? "permanent" : "transient";
-export const classifyLlmError = (error) => {
-  if (!AiError.isAiError(error)) {
-    const e = error;
-    return e?._tag === "HttpClientError" && e.reason?._tag === "TransportError" ? "transient" : "permanent";
-  }
+import { HttpClientError } from "effect/http";
+import { Effect, Option, Predicate, Stream } from "effect";
+import { CurrentEmptyResponseTolerance, modelFailureOf, stampAiErrorFailure } from "@xandreed/core";
+import { modelRetryDefaults } from "./model-retry-policy.entity.js";
+export const LLM_REQUEST_TIMEOUT_MS = modelRetryDefaults.requestTimeoutMs, LLM_CALL_BUDGET_MS = modelRetryDefaults.totalTimeoutMs, classifyLlmError = (error, _now = 0) => {
+  const failure = modelFailureOf(error);
+  if (Option.exists(failure, (kind) => ["ContextOverflow", "Authentication", "InvalidRequest", "Quota", "InvalidResponse"].includes(kind)))
+    return "permanent";
+  if (Option.exists(failure, (kind) => ["RateLimit", "Transient", "Timeout"].includes(kind)))
+    return "transient";
+  if (!AiError.isAiError(error))
+    return HttpClientError.isHttpClientError(error) && error.reason._tag === "TransportError" ? "transient" : "permanent";
   const reason = error.reason, response = "http" in reason ? reason.http?.response : void 0;
-  if (response !== void 0) {
-    if (response.status === 429)
-      return rateLimited(retryAfterMillis(response.headers));
-    return response.status >= 500 ? "transient" : "permanent";
-  }
-  if (reason._tag === "RateLimitError")
-    return rateLimited(reason.retryAfter === void 0 ? void 0 : Duration.toMillis(reason.retryAfter));
+  if (response !== void 0)
+    return response.status === 429 || response.status >= 500 ? "transient" : "permanent";
   return reason._tag === "InternalProviderError" || reason._tag === "NetworkError" || reason._tag === "UnknownError" ? "transient" : "permanent";
 };
-const fastRetries = Schedule.max([
-  Schedule.exponential(Duration.seconds(1)).pipe(Schedule.jittered),
-  Schedule.recurs(3)
-]), routerError = (method, description) => AiError.make({ module: "Router", method, reason: new AiError.UnknownError({ description }) }), timeoutError = (label, method, timeoutMs) => routerError(method, `the ${label} request exceeded ${timeoutMs / 1000}s and was cut off`), emptyError = (label, method) => routerError(method, `${label} returned an empty response (no text, tool call, or reasoning) \u2014 treated as a transient provider failure`), isContentPart = (part) => {
-  const t = part?.type;
-  return t === "text" || t === "tool-call" || t === "reasoning";
+const emptyError = (label, method) => stampAiErrorFailure(AiError.make({
+  module: "Router",
+  method,
+  reason: new AiError.UnknownError({ description: `${label} returned an empty response (no text, tool call, or reasoning) \u2014 treated as a transient provider failure` })
+}), "Transient"), partType = (part) => Predicate.hasProperty(part, "type") && Predicate.isString(part.type) ? part.type : "", isContentPart = (part) => {
+  const type = partType(part);
+  return type === "text" || type === "tool-call" || type === "reasoning";
 };
-export const rejectEmptyResponse = (label) => (effect) => Effect.service(CurrentEmptyResponseTolerance).pipe(Effect.flatMap((tolerant) => tolerant ? effect : effect.pipe(Effect.filterOrFail((res) => res.content.some(isContentPart), () => emptyError(label, "generateText"))))), retryableLlm = (label) => (effect) => effect.pipe(Effect.timeoutOrElse({
-  duration: Duration.millis(LLM_REQUEST_TIMEOUT_MS),
-  orElse: () => Effect.fail(timeoutError(label, "generateText", LLM_REQUEST_TIMEOUT_MS))
-}), Effect.retry({
-  schedule: fastRetries,
-  while: (error) => classifyLlmError(error) === "transient"
-}), Effect.tapError((error) => classifyLlmError(error) === "transient" ? Effect.logWarning(`${label}: transient failure exhausted retries: ${String(error)}`) : Effect.void));
-const isContentPartEncoded = (part) => {
-  const p = part;
-  if (p === null || typeof p !== "object")
-    return !1;
-  if (p.type === "tool-call")
+export const rejectEmptyResponse = (label) => (effect) => Effect.service(CurrentEmptyResponseTolerance).pipe(Effect.flatMap((tolerant) => tolerant ? effect : effect.pipe(Effect.filterOrFail((res) => Option.isSome(modelFailureOf(res.content)) || res.content.some(isContentPart), () => emptyError(label, "generateText")))));
+const carriesMetadata = (part) => Predicate.hasProperty(part, "metadata") && Predicate.isObject(part.metadata) && Object.keys(part.metadata).length > 0, isStreamContentPart = (part) => {
+  const type = partType(part);
+  if (type === "tool-call")
     return !0;
-  return (p.type === "text-delta" || p.type === "reasoning-delta") && typeof p.delta === "string" && p.delta.length > 0;
-}, isFinishPartEncoded = (part) => part?.type === "finish";
-export const retryableLlmStream = (label, timeoutMs = LLM_REQUEST_TIMEOUT_MS) => (stream) => Stream.unwrap(Effect.gen(function* () {
-  const contentSeen = yield* Ref.make(!1);
-  return stream.pipe(Stream.mapEffect((part) => isContentPartEncoded(part) ? Ref.set(contentSeen, !0).pipe(Effect.as(part)) : isFinishPartEncoded(part) ? Ref.get(contentSeen).pipe(Effect.flatMap((seen) => seen ? Effect.succeed(part) : Effect.fail(emptyError(label, "streamText")))) : Effect.succeed(part)), Stream.timeoutOrElse({
-    duration: Duration.millis(timeoutMs),
-    orElse: () => Stream.fail(timeoutError(label, "streamText", timeoutMs))
-  }), Stream.retry(fastRetries.pipe(Schedule.while(({ input }) => Ref.get(contentSeen).pipe(Effect.map((seen) => !seen && classifyLlmError(input) === "transient"))))), Stream.tapError((error) => classifyLlmError(error) === "transient" ? Effect.logWarning(`${label}: transient stream failure was final: ${String(error)}`) : Effect.void));
-}));
+  if ((type === "reasoning-start" || type === "reasoning-delta" || type === "reasoning-end") && carriesMetadata(part))
+    return !0;
+  return (type === "text-delta" || type === "reasoning-delta") && Predicate.hasProperty(part, "delta") && Predicate.isString(part.delta) && part.delta.length > 0;
+}, isFinishPart = (part) => partType(part) === "finish";
+export const rejectEmptyStream = (label) => (stream) => Stream.unwrap(Effect.map(Effect.service(CurrentEmptyResponseTolerance), (tolerant) => tolerant ? stream : stream.pipe(Stream.mapAccumEffect(() => !1, (seen, part) => {
+  const content = seen || Option.isSome(modelFailureOf(part)) || isStreamContentPart(part);
+  return !content && isFinishPart(part) ? Effect.fail(emptyError(label, "streamText")) : Effect.succeed([content, [part]]);
+}))));

package/dist/llm/router.d.ts

@@ -1,34 +1,47 @@
-import { LanguageModel } from "effect/ai";
+import { AiError, LanguageModel } from "effect/ai";
+import type { Response } from "effect/ai";
 import { HttpClient } from "effect/http";
 import { Effect, Layer, Option, Stream } from "effect";
-import { AuthStore, SettingsStore } from "@xandreed/core";
+import { AuthStore } from "../ports/auth-store.port.js";
+import { SettingsStore } from "../ports/settings-store.port.js";
 import type { ModelSelection } from "@xandreed/core";
-/** Build + call one provider generateText for an explicit selection.
- *  `isFallback` only labels telemetry — the fallback rung must be visible
- *  in Grafana without changing the metric identities. */
-export declare const generateWith: (selection: ModelSelection, options: unknown, isFallback?: boolean) => Effect.Effect<{
+import type { EngineSettings } from "../ports/settings-store.port.js";
+import type { PromptOptions, ProviderServices } from "./providers.js";
+import type { ModelRequestCall } from "../transport/resilient-http-client.adapter.js";
+/** Apply the persisted model effort only when a dedicated agent has not
+ * already pinned a complete call policy in its own execution profile. */
+export declare const withConfiguredEffort: <A, E, R>(effect: Effect.Effect<A, E, R>, effort: EngineSettings["reasoningEffort"]) => Effect.Effect<A, E, R>;
+/** One routed call's settled response, as {@link generateOver} returns it. */
+type Generated = {
     readonly content: ReadonlyArray<unknown>;
     readonly usage: unknown;
-}, unknown, AuthStore | HttpClient.HttpClient>;
+};
+/** Build + call one provider generateText for an explicit selection, over
+ *  the given provider services (a routed model's, read where its layer was
+ *  built). `isFallback` only labels telemetry — the fallback rung must be
+ *  visible in Grafana without changing the metric identities. `budget` is
+ *  the routed call's, shared with its fallback rung; a call made without
+ *  one gets its own. */
+export declare const generateOver: (services: ProviderServices) => <O extends PromptOptions>(selection: ModelSelection, options: O, isFallback?: boolean, budget?: ModelRequestCall) => Effect.Effect<Generated, AiError.AiError, AuthStore | HttpClient.HttpClient>;
+/** {@link generateOver} over the provider services where it runs
+ *  (`CurrentModelEndpoints`, `CurrentModelSettings`, `ModelsTransport`), for a call made outside a
+ *  routed model. */
+export declare const generateWith: <O extends PromptOptions>(selection: ModelSelection, options: O, isFallback?: boolean, budget?: ModelRequestCall) => Effect.Effect<Generated, AiError.AiError, AuthStore | HttpClient.HttpClient>;
+/** The fallback rung uses its reserved last attempt only after eligible primary
+ * HTTP failures exhaust their allowance. A committed response, permanent failure
+ * or elapsed deadline cannot start another model call. */
+export declare const withFallbackRung: <A, E, R>(primary: ModelSelection, fallback: Option.Option<ModelSelection>, call: (selection: ModelSelection, isFallback: boolean) => Effect.Effect<A, E, R>, budget: ModelRequestCall) => Effect.Effect<A, E | AiError.AiError, R>;
 /**
- * The fallback rung: run the primary; if it fails TRANSIENT after the fast
- * retries exhausted and a DIFFERENT fallback selection is configured, run
- * the call once more there. Permanent errors (bad request, decode) pass
- * through — a fallback can't fix those; an unset or identical fallback is a
- * no-op. Exported pure-in-shape so the rung's decision table is testable
- * without building providers.
- */
-export declare const withFallbackRung: <A, R>(primary: ModelSelection, fallback: Option.Option<ModelSelection>, call: (selection: ModelSelection, isFallback: boolean) => Effect.Effect<A, unknown, R>) => Effect.Effect<A, unknown, R>;
-/**
- * Stamp the RESOLVED selection onto the finish part — the trail must answer
- * "which model produced this message" from the db alone. The response MUST be
+ * Stamp the RESOLVED selection onto the finish part (core's
+ * `stampResponseModel`) — the trail must answer "which model produced this
+ * message" from the db alone. The response MUST be
  * rebuilt as a real `GenerateTextResponse`: it's a class whose
  * text/finishReason/usage are prototype GETTERS, so a `{...res}` spread
  * silently strips them — finishReason read as undefined and the loop treated
  * every tool turn as "done" (the one-tool-call-then-dead bug, live-caught).
  */
 export declare const stampResponse: (res: {
-    readonly content: ReadonlyArray<unknown>;
+    readonly content: ReadonlyArray<Response.AnyPart>;
 }, label: string) => LanguageModel.GenerateTextResponse<never>;
 /**
  * The stream twin of `generateWith`'s telemetry: accumulate over the flowing
@@ -37,19 +50,34 @@ export declare const stampResponse: (res: {
  * content. Outcome + duration finalize per terminal state (`onDone` /
  * `tapErrorCause`), so retries inside count once, like the settled path.
  */
-export declare const tapStreamTelemetry: (label: string) => <E, R>(stream: Stream.Stream<unknown, E, R>) => Stream.Stream<unknown, E, R>;
-/** Build + call one provider streamText for an explicit selection — the
- *  stream twin of {@link generateWith}: same resolution, same option
- *  shaping (anthropic cache breakpoints inherit for free), same stamp, the
- *  stream-aware retry, and finish-part telemetry. */
-export declare const streamWith: (selection: ModelSelection, options: unknown) => Stream.Stream<unknown, unknown, AuthStore | HttpClient.HttpClient>;
+export declare const tapStreamTelemetry: (label: string) => <A, E, R>(stream: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R>;
+export declare const throughTransport: (services: ProviderServices) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * The provider services of a routed model's layer, read once where it is
+ * built: the configured endpoints (`CurrentModelEndpoints`), per-model controls
+ * (`CurrentModelSettings`), the transport
+ * (`ModelsTransport`), and an OpenAI subscription session cache of the
+ * layer's own: each conversation keeps its session id while the layer
+ * lives, bounded to the conversations used last, and two layers (two agents
+ * in one process) never share one.
+ */
+export declare const layerProviderServices: Effect.Effect<ProviderServices>;
 /**
  * `LanguageModelLive` — the engine loop's `LanguageModel`, routed per call.
  * Requires `SettingsStore` + `AuthStore`; brings its own fetch-backed
- * `HttpClient` so drivers don't have to.
+ * `HttpClient` so drivers don't have to. Reads `CurrentModelEndpoints`,
+ * `CurrentModelSettings` and `ModelsTransport` once, where it is built: built over a transport (as the
+ * models plugin builds it), every call goes through that transport.
+ *
+ * @public
  */
-export declare const LanguageModelLive: Layer.Layer<LanguageModel.LanguageModel, never, SettingsStore | AuthStore>;
+export declare const LanguageModelLive: Layer.Layer<LanguageModel.LanguageModel, never, AuthStore | SettingsStore>;
 /** A profile-pinned routed model. Unlike LanguageModelLive it never consults
  * SettingsStore; dedicated agents use this so global role edits cannot
- * silently change an evalled execution profile. */
+ * silently change an evalled execution profile. Like it, it reads its
+ * provider services once, where it is built.
+ *
+ * @public
+ */
 export declare const LanguageModelSelectionLive: (primary: ModelSelection, fallback: Option.Option<ModelSelection>) => Layer.Layer<LanguageModel.LanguageModel, never, AuthStore>;
+export {};

package/dist/llm/router.js

@@ -1,20 +1,31 @@
 import { AiError, LanguageModel } from "effect/ai";
 import { FetchHttpClient, HttpClient } from "effect/http";
-import { Clock, Duration, Effect, Layer, Metric, Option, Ref, Stream } from "effect";
-import { AuthStore, CurrentModelCallPolicy, describeModel, formatModelSelection, HarnessError, parseModelSelection, resolvingModel, SettingsStore } from "@xandreed/core";
-import { buildProvider, prependClaudeCode, withAnthropicCacheBreakpoints } from "./providers.js";
-import {
-  classifyLlmError,
-  rejectEmptyResponse,
-  retryableLlm,
-  retryableLlmStream
-} from "./retry.js";
+import { Cause, Clock, Config, Context, Duration, Effect, Layer, Metric, Option, Predicate, Ref, References, Result, Stream } from "effect";
+import { CurrentModelCallPolicy, CurrentTraceContent, describeModel, formatModelSelection, harnessError, messagesOf, parseModelSelection, resolvingModel, stampPartModel, stampResponseModel, storedJson } from "@xandreed/core";
+import { AuthError, AuthStore } from "../ports/auth-store.port.js";
+import { SettingsStore } from "../ports/settings-store.port.js";
+import { extractUsage } from "@xandreed/core/internal";
+import { buildProviderOver, endpointOwnKey, modelSettingsFailure, prependClaudeCode, providerServices, resolveMessagesConfiguration } from "./providers.js";
+import { makeOpenAiCodexSessions } from "./openAiCodexWebSocket.js";
+import { transportFetch } from "../transport/models-transport.adapter.js";
+import { rejectEmptyResponse, rejectEmptyStream } from "./retry.js";
+import { CurrentModelRequestCall } from "../ports/model-retry-policy.port.js";
+import { enterModelFallback, makeModelRequestCall } from "../transport/resilient-http-client.adapter.js";
 const configError = (message) => AiError.make({ module: "Router", method: "selection", reason: new AiError.UnknownError({ description: message }) }), llmInputTokens = Metric.counter("llm.usage.input_tokens", {
   description: "prompt tokens consumed by routed LLM calls",
   incremental: !0
 }), llmOutputTokens = Metric.counter("llm.usage.output_tokens", {
   description: "completion tokens produced by routed LLM calls",
   incremental: !0
+}), llmCacheReadTokens = Metric.counter("llm.usage.cache_read_tokens", {
+  description: "prompt tokens of routed LLM calls read from the provider's prompt cache",
+  incremental: !0
+}), llmCacheWriteTokens = Metric.counter("llm.usage.cache_write_tokens", {
+  description: "prompt tokens of routed LLM calls written to the provider's prompt cache",
+  incremental: !0
+}), llmReasoningTokens = Metric.counter("llm.usage.reasoning_tokens", {
+  description: "completion tokens of routed LLM calls spent on reasoning",
+  incremental: !0
 }), llmRequests = Metric.counter("llm.requests", {
   description: "routed LLM calls by final outcome (after retries)",
   incremental: !0
@@ -23,71 +34,96 @@ const configError = (message) => AiError.make({ module: "Router", method: "selec
 }), byModel = (metric, label) => Metric.withAttributes(metric, { "llm.model": label }), countRequest = (label, outcome, isFallback) => Metric.update(Metric.withAttributes(byModel(llmRequests, label), {
   outcome,
   ...isFallback === void 0 ? {} : { fallback: isFallback ? "true" : "false" }
-}), 1), usageTotals = (usage) => {
-  const u = usage;
-  return { input: u?.inputTokens?.total ?? 0, output: u?.outputTokens?.total ?? 0 };
-}, tracedContent = (content) => process.env.EFFERENT_TRACE_CONTENT === "1" ? content.slice(0, 500) : "[redacted]", shapeOptions = (selection, shouldPrependClaudeCode, options) => {
-  const cached = selection.provider === "anthropic" ? withAnthropicCacheBreakpoints(options) : options;
-  return shouldPrependClaudeCode ? prependClaudeCode(cached) : cached;
-}, currentSelection = Effect.gen(function* () {
+}), 1), usageOf = (usage) => extractUsage(usage, []), usageAttributes = (usage) => ({
+  "llm.usage.input_tokens": usage.inputTokens,
+  "llm.usage.output_tokens": usage.outputTokens,
+  "llm.usage.cache_read_tokens": usage.cacheReadTokens,
+  "llm.usage.cache_write_tokens": usage.cacheWriteTokens,
+  "llm.usage.reasoning_tokens": usage.reasoningTokens
+}), countUsage = (label, usage) => Effect.all([
+  Metric.update(byModel(llmInputTokens, label), usage.inputTokens),
+  Metric.update(byModel(llmOutputTokens, label), usage.outputTokens),
+  Metric.update(byModel(llmCacheReadTokens, label), usage.cacheReadTokens),
+  Metric.update(byModel(llmCacheWriteTokens, label), usage.cacheWriteTokens),
+  Metric.update(byModel(llmReasoningTokens, label), usage.reasoningTokens)
+], { concurrency: 1, discard: !0 }), traceContentVariable = Config.option(Config.String("EFFERENT_TRACE_CONTENT")).pipe(Effect.map(Option.exists((value) => value === "1")), Effect.catch((error) => Effect.logWarning(`EFFERENT_TRACE_CONTENT cannot be read: ${error.message}`).pipe(Effect.as(!1)))), tracedContent = Effect.all([Effect.service(CurrentTraceContent), traceContentVariable], { concurrency: 1 }).pipe(Effect.map(([capture, variable]) => (content) => capture || variable ? content.slice(0, 500) : "[redacted]")), shapeOptions = (built, options) => built.prependClaudeCode ? prependClaudeCode(options) : options, currentSelection = Effect.gen(function* () {
   const loaded = yield* (yield* SettingsStore).load.pipe(Effect.mapError((e) => configError(`settings load failed: ${e.message}`))), raw = Option.getOrElse(loaded.model, () => "");
   return {
     primary: yield* Option.match(parseModelSelection(raw), {
-      onNone: () => Effect.fail(configError(raw.length === 0 ? "no model configured \u2014 choose /model in the terminal or set the models plugin's model option in efferent.config.json" : `the configured model "${raw}" is not a "<provider>:<modelId>" selection`)),
+      onNone: () => Effect.fail(configError(raw.length === 0 ? `no model configured \u2014 set the models plugin's model option, or a SettingsStore model, to "<provider>:<modelId>"` : `the configured model "${raw}" is not a "<provider>:<modelId>" selection`)),
       onSome: Effect.succeed
     }),
     fallback: Option.flatMap(loaded.fallbackModel, parseModelSelection),
     effort: loaded.reasoningEffort
   };
-}), withConfiguredEffort = (effect, effort) => Effect.service(CurrentModelCallPolicy).pipe(Effect.flatMap((current) => Option.isSome(current) || Option.isNone(effort) ? effect : effect.pipe(Effect.provideService(CurrentModelCallPolicy, Option.some({ effort: effort.value }))))), describeSelection = (primary, fallback, effort) => Effect.service(CurrentModelCallPolicy).pipe(Effect.map((current) => ({
-  provider: primary.provider,
-  model: primary.modelId,
-  settings: {
+});
+export const withConfiguredEffort = (effect, effort) => Effect.service(CurrentModelCallPolicy).pipe(Effect.flatMap((current) => Option.isSome(current) || Option.isNone(effort) ? effect : effect.pipe(Effect.provideService(CurrentModelCallPolicy, Option.some({ effort: effort.value })))));
+const describeSelection = Effect.fnUntraced(function* (primary, fallback, effort, services) {
+  const current = yield* CurrentModelCallPolicy, policy = Option.orElse(current, () => Option.map(effort, (value) => ({ effort: value }))), endpoint = Object.hasOwn(services.endpoints, primary.provider) ? Option.fromNullishOr(services.endpoints[primary.provider]) : Option.none(), messages = Option.filter(endpoint, (value) => value.api === "anthropic-messages"), configuration = (configured) => resolveMessagesConfiguration(primary, services.modelSettings, policy, services.thinkingPrefixMismatch, configured), native = yield* Option.match(messages, {
+    onSome: () => Effect.fromResult(configuration(messages)).pipe(Effect.map((value) => value.settings), Effect.mapError((error) => harnessError("request.model", error.message, error))),
+    onNone: () => Effect.succeed(Option.isNone(endpoint) && primary.provider === "anthropic" ? {
+      messagesProfile: { kind: "requested", apiVersion: "2023-06-01", ...Result.match(configuration(Option.none()), {
+        onSuccess: (value) => ({ settings: value.settings }),
+        onFailure: (error) => ({ controls: Object.hasOwn(services.modelSettings, formatModelSelection(primary)) ? services.modelSettings[formatModelSelection(primary)] ?? {} : {}, unresolved: error.reason })
+      }) }
+    } : {})
+  }), settings = yield* storedJson({
     fallback: Option.getOrElse(Option.map(fallback, formatModelSelection), () => null),
-    policy: Option.getOrElse(Option.orElse(current, () => Option.map(effort, (value) => ({ effort: value }))), () => null)
-  }
-})));
-export const generateWith = (selection, options, isFallback = !1) => Effect.gen(function* () {
-  const auth = yield* AuthStore, label = formatModelSelection(selection), credential = Option.getOrUndefined(yield* auth.get(selection.provider)), key = Option.getOrUndefined(yield* auth.resolveKey(selection.provider)), built = yield* buildProvider(selection, credential, key);
-  return yield* built.svc.generateText(shapeOptions(selection, built.prependClaudeCode, options)).pipe(rejectEmptyResponse(label), retryableLlm(label), Effect.map((res) => stampResponse(res, label)), Effect.tap((res) => Effect.annotateCurrentSpan({
+    policy: Option.getOrElse(policy, () => null),
+    ...native
+  }).pipe(Effect.mapError((error) => harnessError("request.model", `the routed model's settings are not JSON: ${error.message}`, error)));
+  return { provider: primary.provider, model: primary.modelId, settings };
+}), credentialFor = Effect.fn("models.credentials")(function* (selection, endpoints) {
+  const own = yield* Option.match(Object.hasOwn(endpoints, selection.provider) ? Option.fromNullishOr(endpoints[selection.provider]) : Option.none(), {
+    onNone: () => Effect.succeedNone,
+    onSome: (endpoint) => endpointOwnKey(endpoint).pipe(Effect.mapError((error) => new AuthError({ provider: selection.provider, message: `cannot read the endpoint's key variable: ${error.message}` })))
+  });
+  if (Option.isSome(own))
+    return { credential: void 0, key: own.value };
+  const auth = yield* AuthStore;
+  return {
+    credential: Option.getOrUndefined(yield* auth.get(selection.provider)),
+    key: Option.getOrUndefined(yield* auth.resolveKey(selection.provider))
+  };
+}), authenticationFailure = (error) => AiError.make({
+  module: "Router",
+  method: "credentials",
+  reason: new AiError.AuthenticationError({ kind: "Unknown", description: error.message, metadata: { router: { provider: error.provider } } })
+}), providerFor = (selection, services) => credentialFor(selection, services.endpoints).pipe(Effect.mapError(authenticationFailure), Effect.flatMap(({ credential, key }) => buildProviderOver(services)(selection, credential, key).pipe(Effect.mapError((error) => error._tag === "AuthError" ? authenticationFailure(error) : modelSettingsFailure(error))))), recorded = (label, isFallback) => (call) => call.pipe(Effect.tap((res) => countUsage(label, usageOf(res.usage))), Effect.tap(() => countRequest(label, "ok", isFallback)), Effect.tapError(() => countRequest(label, "error", isFallback)), Effect.timed, Effect.tap(([duration]) => Metric.update(byModel(llmDuration, label), duration)), Effect.map(([, res]) => res)), modelAttributes = (selection) => ({ "llm.model": formatModelSelection(selection) }), providerCall = (selection) => (call) => call.pipe(Effect.annotateLogs(modelAttributes(selection)), Effect.withSpan("providers.generate", { attributes: modelAttributes(selection) })), providerStream = (selection) => (stream) => stream.pipe(Stream.updateService(References.CurrentLogAnnotations, (annotations) => ({ ...annotations, ...modelAttributes(selection) })), Stream.withSpan("providers.generate", { attributes: modelAttributes(selection) }));
+export const generateOver = (services) => (selection, options, isFallback = !1, budget) => Effect.gen(function* () {
+  const label = formatModelSelection(selection), traced = yield* tracedContent, bound = budget ?? (yield* makeModelRequestCall({ reserveFallback: !1 })), built = yield* providerFor(selection, services);
+  return yield* built.svc.generateText(shapeOptions(built, options)).pipe(rejectEmptyResponse(label), Effect.provideService(CurrentModelRequestCall, Option.some(bound)), Effect.map((res) => stampResponse(res, label)), Effect.tap((res) => Effect.annotateCurrentSpan({
     "llm.finish_reason": String(res.finishReason),
-    "llm.usage.input_tokens": usageTotals(res.usage).input,
-    "llm.usage.output_tokens": usageTotals(res.usage).output,
+    ...usageAttributes(usageOf(res.usage)),
     "llm.response_chars": res.text.length,
-    "llm.tool_calls": res.content.flatMap((part) => {
-      const p = part;
-      return p.type === "tool-call" ? [p.name ?? ""] : [];
-    }).join(","),
-    "llm.reasoning": tracedContent(res.reasoningText ?? ""),
+    "llm.tool_calls": res.content.flatMap((part) => part.type === "tool-call" ? [part.name] : []).join(","),
+    "llm.reasoning": traced(res.reasoningText ?? ""),
     "llm.fallback": isFallback
-  })), Effect.tap((res) => Effect.all([
-    Metric.update(byModel(llmInputTokens, label), usageTotals(res.usage).input),
-    Metric.update(byModel(llmOutputTokens, label), usageTotals(res.usage).output)
-  ], { discard: !0 })), Effect.tap(() => countRequest(label, "ok", isFallback)), Effect.tapError(() => countRequest(label, "error", isFallback)), Effect.timed, Effect.tap(([duration]) => Metric.update(byModel(llmDuration, label), duration)), Effect.map(([, res]) => res), Effect.withSpan("providers.generate", {
-    attributes: { "llm.model": label }
-  }));
-}).pipe(Effect.scoped), withFallbackRung = (primary, fallback, call) => call(primary, !1).pipe(Effect.catch((error) => Option.match(Option.filter(fallback, (fb) => formatModelSelection(fb) !== formatModelSelection(primary) && classifyLlmError(error) === "transient"), {
+  })), recorded(label, isFallback));
+}).pipe(Effect.scoped, providerCall(selection)), generateWith = (selection, options, isFallback = !1, budget) => Effect.flatMap(providerServices, (services) => generateOver(services)(selection, options, isFallback, budget));
+const objectOver = (services) => (selection, options, isFallback, budget) => Effect.gen(function* () {
+  const label = formatModelSelection(selection), built = yield* providerFor(selection, services);
+  return yield* built.svc.generateObject(shapeOptions(built, options)).pipe(Effect.provideService(CurrentModelRequestCall, Option.some(budget)), Effect.tap((res) => Effect.annotateCurrentSpan({
+    "llm.finish_reason": String(res.finishReason),
+    ...usageAttributes(usageOf(res.usage)),
+    "llm.fallback": isFallback
+  })), recorded(label, isFallback));
+}).pipe(Effect.scoped, providerCall(selection));
+export const withFallbackRung = (primary, fallback, call, budget) => call(primary, !1).pipe(Effect.catch((error) => Effect.flatMap(enterModelFallback(budget, error), (again) => Option.match(Option.filter(fallback, (fb) => again && formatModelSelection(fb) !== formatModelSelection(primary)), {
   onNone: () => Effect.fail(error),
-  onSome: (fb) => Effect.logWarning(`${formatModelSelection(primary)} exhausted retries (${String(error).slice(0, 200)}) \u2014 falling back to ${formatModelSelection(fb)}`).pipe(Effect.andThen(call(fb, !0)))
-})));
-const stampModel = (part, label) => {
-  if (typeof part !== "object" || part === null)
-    return part;
-  const p = part;
-  if (p.type !== "finish")
-    return part;
-  const metadata = typeof p.metadata === "object" && p.metadata !== null ? p.metadata : {};
-  return { ...p, metadata: { ...metadata, router: { model: label } } };
-};
-export const stampResponse = (res, label) => new LanguageModel.GenerateTextResponse(res.content.map((part) => stampModel(part, label)));
-const accumulateStats = (stats, part) => {
-  const p = part;
-  if (p.type === "text-delta")
-    return { ...stats, textChars: stats.textChars + (p.delta ?? "").length };
-  if (p.type === "reasoning-delta")
-    return { ...stats, reasoning: stats.reasoning + (p.delta ?? "") };
-  if (p.type === "tool-call")
-    return { ...stats, toolNames: [...stats.toolNames, p.name ?? ""] };
+  onSome: (fb) => Effect.logWarning(`exhausted retries (${String(error).slice(0, 200)}) \u2014 falling back`).pipe(Effect.annotateLogs({ ...modelAttributes(primary), "llm.fallback_model": formatModelSelection(fb) }), Effect.andThen(call(fb, !0)))
+})))), stampResponse = (res, label) => new LanguageModel.GenerateTextResponse(stampResponseModel(res.content, label));
+const fieldOf = (part, key) => Predicate.hasProperty(part, key) ? part[key] : void 0, textOf = (part, key) => {
+  const value = fieldOf(part, key);
+  return Predicate.isString(value) ? value : "";
+}, accumulateStats = (stats, part) => {
+  const type = textOf(part, "type");
+  if (type === "text-delta")
+    return { ...stats, textChars: stats.textChars + textOf(part, "delta").length };
+  if (type === "reasoning-delta")
+    return { ...stats, reasoning: stats.reasoning + textOf(part, "delta") };
+  if (type === "tool-call")
+    return { ...stats, toolNames: [...stats.toolNames, textOf(part, "name")] };
   return stats;
 };
 export const tapStreamTelemetry = (label) => (stream) => Stream.unwrap(Effect.gen(function* () {
@@ -95,47 +131,48 @@ export const tapStreamTelemetry = (label) => (stream) => Stream.unwrap(Effect.ge
     textChars: 0,
     reasoning: "",
     toolNames: []
-  }), startedAt = yield* Clock.currentTimeMillis, recordDuration = Clock.currentTimeMillis.pipe(Effect.flatMap((now) => Metric.update(byModel(llmDuration, label), Duration.millis(now - startedAt))));
+  }), startedAt = yield* Clock.currentTimeMillis, traced = yield* tracedContent, recordDuration = Clock.currentTimeMillis.pipe(Effect.flatMap((now) => Metric.update(byModel(llmDuration, label), Duration.millis(now - startedAt))));
   return stream.pipe(Stream.mapEffect((part) => {
-    const p = part;
-    if (p.type !== "finish")
+    if (textOf(part, "type") !== "finish")
       return Ref.update(stats, (s) => accumulateStats(s, part)).pipe(Effect.as(part));
+    const usage = usageOf(fieldOf(part, "usage"));
     return Ref.get(stats).pipe(Effect.flatMap((s) => Effect.annotateCurrentSpan({
-      "llm.finish_reason": String(p.reason),
-      "llm.usage.input_tokens": usageTotals(p.usage).input,
-      "llm.usage.output_tokens": usageTotals(p.usage).output,
+      "llm.finish_reason": String(fieldOf(part, "reason")),
+      ...usageAttributes(usage),
       "llm.response_chars": s.textChars,
       "llm.tool_calls": s.toolNames.join(","),
-      "llm.reasoning": tracedContent(s.reasoning)
-    })), Effect.andThen(Effect.all([
-      Metric.update(byModel(llmInputTokens, label), usageTotals(p.usage).input),
-      Metric.update(byModel(llmOutputTokens, label), usageTotals(p.usage).output)
-    ], { discard: !0 })), Effect.as(part));
+      "llm.reasoning": traced(s.reasoning)
+    })), Effect.andThen(countUsage(label, usage)), Effect.as(part));
   }), Stream.onEnd(countRequest(label, "ok").pipe(Effect.andThen(recordDuration))), Stream.tapCause(() => countRequest(label, "error").pipe(Effect.andThen(recordDuration))));
-})), streamWith = (selection, options) => Stream.unwrap(Effect.gen(function* () {
-  const auth = yield* AuthStore, label = formatModelSelection(selection), credential = Option.getOrUndefined(yield* auth.get(selection.provider)), key = Option.getOrUndefined(yield* auth.resolveKey(selection.provider)), built = yield* buildProvider(selection, credential, key);
-  return built.svc.streamText(shapeOptions(selection, built.prependClaudeCode, options)).pipe(retryableLlmStream(label), Stream.map((part) => stampModel(part, label)), tapStreamTelemetry(label), Stream.withSpan("providers.generate", {
-    attributes: { "llm.model": label }
-  }));
 }));
-const withConfiguredEffortStream = (stream, effort) => Stream.unwrap(Effect.service(CurrentModelCallPolicy).pipe(Effect.map((current) => Option.isSome(current) || Option.isNone(effort) ? stream : stream.pipe(Stream.provideService(CurrentModelCallPolicy, Option.some({ effort: effort.value })))))), selectionModel = (primary, fallback, effort, context, http) => {
+const streamOver = (services) => (selection, options, budget) => Stream.unwrap(Effect.gen(function* () {
+  const label = formatModelSelection(selection), built = yield* providerFor(selection, services);
+  return built.svc.streamText(shapeOptions(built, options)).pipe(rejectEmptyStream(label), Stream.provideService(CurrentModelRequestCall, Option.some(budget)), Stream.map((part) => stampPartModel(part, label)), tapStreamTelemetry(label));
+})).pipe(providerStream(selection)), withConfiguredEffortStream = (stream, effort) => Stream.unwrap(Effect.service(CurrentModelCallPolicy).pipe(Effect.map((current) => Option.isSome(current) || Option.isNone(effort) ? stream : stream.pipe(Stream.provideService(CurrentModelCallPolicy, Option.some({ effort: effort.value })))))), requestFetch = (services) => Effect.map(Effect.context(), (context) => Option.match(services.transport, {
+  onNone: () => Context.get(context, FetchHttpClient.Fetch),
+  onSome: (transport) => Option.getOrElse(Option.filter(Option.fromNullishOr(Context.getOrUndefined(context, FetchHttpClient.Fetch)), () => Option.contains(services.managedTransport, transport)), () => transportFetch(transport))
+}));
+export const throughTransport = (services) => (effect) => Effect.flatMap(requestFetch(services), (fetch) => Effect.provideService(effect, FetchHttpClient.Fetch, fetch));
+const throughTransportStream = (services) => (stream) => Stream.unwrap(Effect.map(requestFetch(services), (fetch) => Stream.provideService(stream, FetchHttpClient.Fetch, fetch)));
+export const layerProviderServices = Effect.all([providerServices, makeOpenAiCodexSessions()], { concurrency: 1 }).pipe(Effect.map(([services, sessions]) => ({ ...services, sessions: Option.some(sessions) })));
+const selectionModel = (primary, fallback, effort, stores, http, services) => {
   const service = {
     [LanguageModel.TypeId]: LanguageModel.TypeId,
-    generateText: (options) => withConfiguredEffort(withFallbackRung(primary, fallback, (selection, isFallback) => generateWith(selection, options, isFallback)), effort).pipe(Effect.provide(context), Effect.provideService(HttpClient.HttpClient, http)),
-    generateObject: () => Effect.fail(configError("generateObject is not wired on the new line yet")),
-    streamText: (options) => withConfiguredEffortStream(streamWith(primary, options), effort).pipe(Stream.provideContext(context), Stream.provideService(HttpClient.HttpClient, http))
+    generateText: (options) => makeModelRequestCall({ reserveFallback: Option.exists(fallback, (value) => formatModelSelection(value) !== formatModelSelection(primary)) }).pipe(Effect.flatMap((budget) => withConfiguredEffort(withFallbackRung(primary, fallback, (selection, isFallback) => generateOver(services)(selection, options, isFallback, budget), budget), effort)), throughTransport(services), Effect.provide(stores), Effect.provideService(HttpClient.HttpClient, http)),
+    generateObject: (options) => makeModelRequestCall({ reserveFallback: Option.exists(fallback, (value) => formatModelSelection(value) !== formatModelSelection(primary)) }).pipe(Effect.flatMap((budget) => withConfiguredEffort(withFallbackRung(primary, fallback, (selection, isFallback) => objectOver(services)(selection, options, isFallback, budget), budget), effort)), throughTransport(services), Effect.provide(stores), Effect.provideService(HttpClient.HttpClient, http)),
+    streamText: (options) => withConfiguredEffortStream(Stream.unwrap(Effect.map(makeModelRequestCall({ reserveFallback: !1 }), (budget) => streamOver(services)(primary, options, budget))), effort).pipe(throughTransportStream(services), Stream.provideContext(stores), Stream.provideService(HttpClient.HttpClient, http))
   };
-  return describeModel(service, describeSelection(primary, fallback, effort));
+  return describeModel(service, describeSelection(primary, fallback, effort, services));
 };
 export const LanguageModelLive = Layer.effect(LanguageModel.LanguageModel, Effect.gen(function* () {
-  const context = yield* Effect.context(), http = yield* HttpClient.HttpClient, selected = currentSelection.pipe(Effect.map(({ primary, fallback, effort }) => selectionModel(primary, fallback, effort, context, http)), Effect.provide(context)), service = {
+  const stores = Context.pick(AuthStore, SettingsStore)(yield* Effect.context()), services = yield* layerProviderServices, http = yield* HttpClient.HttpClient, selected = currentSelection.pipe(Effect.map(({ primary, fallback, effort }) => selectionModel(primary, fallback, effort, stores, http, services)), Effect.provide(stores)), service = {
     [LanguageModel.TypeId]: LanguageModel.TypeId,
     generateText: (options) => selected.pipe(Effect.flatMap((model) => model.generateText(options))),
-    generateObject: () => Effect.fail(configError("generateObject is not wired on the new line yet")),
+    generateObject: (options) => selected.pipe(Effect.flatMap((model) => model.generateObject(options))),
     streamText: (options) => Stream.unwrap(selected.pipe(Effect.map((model) => model.streamText(options))))
-  }, asHarness = (error) => new HarnessError({ code: "request.model", message: String(error) });
-  return resolvingModel(describeModel(service, currentSelection.pipe(Effect.flatMap(({ primary, fallback, effort }) => describeSelection(primary, fallback, effort)), Effect.provide(context), Effect.mapError(asHarness))), selected.pipe(Effect.mapError(asHarness)));
+  }, asHarness = (error) => harnessError("request.model", messagesOf(Cause.fail(error)), error);
+  return resolvingModel(describeModel(service, currentSelection.pipe(Effect.mapError(asHarness), Effect.flatMap(({ primary, fallback, effort }) => describeSelection(primary, fallback, effort, services)), Effect.provide(stores))), selected.pipe(Effect.mapError(asHarness)));
 })).pipe(Layer.provide(FetchHttpClient.layer)), LanguageModelSelectionLive = (primary, fallback) => Layer.effect(LanguageModel.LanguageModel, Effect.gen(function* () {
-  const context = yield* Effect.context(), http = yield* HttpClient.HttpClient;
-  return selectionModel(primary, fallback, Option.none(), context, http);
+  const stores = Context.pick(AuthStore)(yield* Effect.context()), http = yield* HttpClient.HttpClient;
+  return selectionModel(primary, fallback, Option.none(), stores, http, yield* layerProviderServices);
 })).pipe(Layer.provide(FetchHttpClient.layer));

package/dist/llm/sse.d.ts

@@ -1,6 +1,8 @@
 import { AiError } from "effect/ai";
 import type { Response } from "effect/ai";
-import { Stream } from "effect";
+import { Effect, Option, Schema, Stream } from "effect";
+import type { ModelAttempt } from "./model-completion.adapter.js";
+import type { CompletionUsage } from "./chat-wire.entity.js";
 /**
  * The OpenAI-compatible SSE wire → `@effect/ai` `StreamPartEncoded`s, as a
  * PURE state machine over `data:` lines. Owned here so `compat.ts` imports
@@ -10,41 +12,68 @@ import { Stream } from "effect";
  * text/reasoning delta or a completed tool call — empty deltas emit nothing.
  * The retry gate (S2) and the engine fold (S3) both hinge on that.
  *
- * A DONE sentinel is concatenated after the wire lines so the flush (open
+ * An end marker is concatenated after the wire lines so the flush (open
  * chunk ends → accumulated tool calls → finish) runs even when the gateway
- * never sends `[DONE]`; a second sentinel is idempotent via `flushed`.
+ * never sends `[DONE]`; a second flush is idempotent via `flushed`. A body
+ * that ends with neither `[DONE]` nor a finish reason was cut off on the
+ * way (a dropped connection, a gateway that gave up): its finish is
+ * `unknown`, which the loop treats as a cut when the reply holds tool calls.
+ *
+ * Each chunk is decoded (`chat-wire.entity.ts`): a `data:` line that is no
+ * chunk (not JSON, `null`, a field of the wrong type) fails the stream with
+ * the provider's `InvalidResponseError`, never the model's invalid output.
  */
-/** The usage object OpenAI-compatible completions carry (streaming sends it
- *  on the last chunk under `stream_options: {include_usage: true}`). */
-export interface CompletionUsage {
-    readonly prompt_tokens?: number;
-    readonly completion_tokens?: number;
-    readonly total_tokens?: number;
-    /** DeepSeek-style cache accounting. */
-    readonly prompt_cache_hit_tokens?: number;
-    /** Moonshot-style cache accounting. */
-    readonly cached_tokens?: number;
-    /** OpenAI-native cache accounting. */
-    readonly prompt_tokens_details?: {
-        readonly cached_tokens?: number;
-    };
+/** How a compat endpoint's usage is read. */
+export interface UsageReading {
+    /**
+     * Read `completion_tokens_details.reasoning_tokens` (default true). The
+     * built-in `google` provider sets false: Gemini's `completion_tokens` may
+     * leave its thoughts out, which would break reasoning inside the output,
+     * so its reasoning reads 0. Configured endpoints and `local` credentials
+     * read it.
+     */
+    readonly reasoning?: boolean;
 }
 /** The vendor cached-token fallback chain, shared with the non-streaming
  *  parser — the gateway fronts upstreams with three cache vocabularies.
- *  `prompt_tokens` already counts the cached tokens: it is the full input. */
-export declare const usageFromCompletion: (usage: CompletionUsage | undefined) => {
-    inputTokens: {
-        total: number;
-        uncached: number;
-        cacheRead: number;
-    };
-    outputTokens: {
-        total: number;
-    };
-};
-export declare const finishReasonFromWire: (raw: string | undefined) => "stop" | "length" | "content-filter" | "tool-calls";
+ *  `prompt_tokens` already counts the cached and written tokens: it is the
+ *  full input, and `completion_tokens` the full output, reasoning included. */
+export declare const usageFromCompletion: (usage: CompletionUsage | null | undefined, reading?: UsageReading) => typeof Response.Usage.Encoded;
+/** The finish reasons that cut a response short, as `@effect/ai` names them. */
+type WireCut = "length" | "content-filter" | "error" | "other";
+/**
+ * A wire response's finish reason: one that ended on its own (`stop`,
+ * `tool-calls`), a cut, or `unknown`: a stream that ended with neither a
+ * finish reason nor `[DONE]`, which may have been cut off anywhere.
+ */
+export type WireFinishReason = "stop" | "tool-calls" | WireCut | "unknown";
+/**
+ * The wire's `finish_reason` as `@effect/ai`'s finish reason, for the settled
+ * and the streamed parser alike, decided before any tool call's arguments are
+ * read. A response that ended on its own (a settling word, or no reason at
+ * all on a whole completion or a stream the server ended with `[DONE]`)
+ * finishes on `tool-calls` when it holds tool calls, else on `stop`. A cut
+ * stays a cut whatever the response holds, so the loop runs no call of a
+ * cut reply. A stream that ended with neither is the flush's `unknown`.
+ */
+export declare const finishReasonFromWire: (raw: Option.Option<string>, hasToolCalls: boolean) => WireFinishReason;
+/**
+ * A tool call's params from its wire arguments, once the response's finish
+ * reason is known. Arguments that do not parse fail a response that ended on
+ * its own with the model's invalid output (`invalid`: the loop's corrective
+ * path). A cut response's call, or an `unknown` one's, is kept with params
+ * `{}`: its arguments may end mid-JSON, and the loop answers each call of a
+ * cut reply as cut and never runs it.
+ */
+export declare const toolCallParams: (args: string, reason: WireFinishReason, invalid: () => AiError.AiError) => Effect.Effect<Schema.Json, AiError.AiError>;
 /** Parse a streaming chat-completions body into encoded stream parts. */
 export declare const sseStreamParts: (options: {
     readonly moduleName: string;
     readonly body: ReadableStream<Uint8Array>;
+    readonly attempt?: Option.Option<ModelAttempt>;
+    /** How the final chunk's usage is read (see `usageFromCompletion`). */
+    readonly usage?: UsageReading;
+    /** Observe raw cumulative counters before SDK defaults; a finish signal establishes output finality. */
+    readonly observeUsage?: (usage: unknown, final: boolean) => Effect.Effect<void>;
 }) => Stream.Stream<Response.StreamPartEncoded, AiError.AiError>;
+export {};