@xandreed/plugin-models 0.14.0 → 0.15.1

package/dist/llm/providers.js

@@ -1,163 +1,332 @@
-import { LanguageModel, Prompt } from "effect/ai";
+import { AiError, LanguageModel, Prompt } from "effect/ai";
 import { AnthropicClient, AnthropicLanguageModel } from "@effect/ai-anthropic";
 import { OpenAiClient, OpenAiLanguageModel } from "@effect/ai-openai";
-import { HttpClient, HttpClientRequest } from "effect/http";
-import { Effect, Option, Redacted } from "effect";
-import { AuthError, CurrentModelCallPolicy, CurrentPromptCacheKey, describeModel, formatModelSelection, modelRequestDescriptorOf } from "@xandreed/core";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http";
+import { Config, Effect, Match, Metric, Option, Predicate, Redacted, Ref, Result, Stream } from "effect";
+import { isTurnError, CurrentModelCallPolicy, CurrentPromptCacheKey, describeModel, formatModelSelection, modelFailureOf, modelRequestDescriptorOf, stampAiErrorFailure } from "@xandreed/core";
+import { isVolatileContext, stripVolatileContext } from "@xandreed/core/internal";
+import { CurrentPromptCacheFrame } from "../ports/prompt-cache-frame.port.js";
+import { PromptCacheError } from "./prompt-cache.entity.js";
+import { planBreakpoints } from "./prompt-cache.entity.functions.js";
+import { AuthError } from "../ports/auth-store.port.js";
 import { ANTHROPIC_OAUTH_BETA, CLAUDE_CODE_SYSTEM } from "../auth/anthropicOAuth.js";
 import { makeCompatLanguageModel, promptWithImageLabels } from "./compat.js";
-import { imageInputFor, usesOpenCodeResponses } from "./modelCatalog.js";
+import { publicReasoningEffort, usesOpenCodeResponses } from "./modelCatalog.js";
 import { makeOpenAiCodexLanguageModel, OPENAI_CODEX_API_URL } from "./openAiCodex.js";
+import { CurrentOpenAiCodexSessions } from "./openAiCodexWebSocket.js";
+import { BuiltInProvider } from "./provider-profile.entity.js";
+import { anthropicProfileOf, profileOf } from "./provider-profile.entity.functions.js";
 import { openAiCodexAccountId } from "../auth/openAiCodexOAuth.js";
 import { CurrentModelEndpoints } from "../ports/model-endpoints.port.js";
-import { ModelsTransport } from "../ports/models-transport.port.js";
-export const OPENCODE_CHAT_URL = "https://opencode.ai/zen/go/v1/chat/completions", OPENCODE_RESPONSES_API_URL = "https://opencode.ai/zen/v1", GOOGLE_CHAT_URL = "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions";
-
+import { CurrentManagedModelsTransport, ModelsTransport } from "../ports/models-transport.port.js";
+import { CurrentModelSettings } from "../ports/model-settings.port.js";
+import { CurrentModelCallPurpose } from "../ports/model-call-completion.port.js";
+import { ModelSettingsError, ModelThinking } from "./model-settings.entity.js";
+import { resolveAnthropicSettings, validateAnthropicRequest } from "./model-settings.entity.functions.js";
+import { CurrentThinkingPrefixMismatch } from "../ports/thinking-binding.port.js";
+import { THINKING_BINDING_BETA } from "./thinking-binding.entity.js";
+import { bindingFor, droppedInBody, droppedInMessageStart, firstEventData, mergeBetas } from "./thinking-binding.entity.functions.js";
+import { classifyAiError } from "./provider-failure.entity.functions.js";
+import { providerFailureProtocol, withAnthropicFailures, withOpenAiFailures } from "./provider-client.adapter.js";
+import { retainModelAttempt } from "./model-completion.adapter.js";
+import { observedResponse, resilientHttpClient, withModelRequestCall, withModelRequestStream } from "../transport/resilient-http-client.adapter.js";
+export { GOOGLE_CHAT_URL, OPENCODE_CHAT_URL, OPENCODE_RESPONSES_API_URL } from "./provider-profile.entity.functions.js";
 export { usesOpenCodeResponses };
+export const withPrompt = (options, f) => ({ ...options, prompt: f(Prompt.make(options.prompt)) });
 const withImageLabels = (model) => {
-  const relabeled = (options) => ({
-    ...options,
-    prompt: promptWithImageLabels(Prompt.make(options.prompt))
-  });
+  const relabeled = (options) => withPrompt(options, promptWithImageLabels);
   return {
     ...model,
     generateText: (options) => model.generateText(relabeled(options)),
     generateObject: (options) => model.generateObject(relabeled(options)),
     streamText: (options) => model.streamText(relabeled(options))
   };
-}, anthropicOAuthTransform = (access) => (client) => client.pipe(HttpClient.mapRequest((req) => req.pipe(HttpClientRequest.setHeaders({
-  Authorization: `Bearer ${Redacted.value(access)}`,
-  "anthropic-beta": ANTHROPIC_OAUTH_BETA
-})))), claudeCodePrompt = Prompt.make([{ role: "system", content: CLAUDE_CODE_SYSTEM }]);
-export const prependClaudeCode = (options) => ({
-  ...options,
-  prompt: Prompt.concat(claudeCodePrompt, Prompt.make(options.prompt))
-}), withAnthropicCacheBreakpoints = (options) => {
-  const messages = Prompt.make(options.prompt).content;
-  if (messages.length === 0)
-    return options;
-  const lastSystem = messages.reduce((acc, m, i) => m.role === "system" ? i : acc, -1), nonSystem = messages.flatMap((m, i) => m.role === "system" ? [] : [i]), stampIdx = new Set([
-    ...lastSystem >= 0 ? [lastSystem] : [],
-    ...nonSystem.slice(-2)
-  ]), stamped = messages.map((msg, i) => {
-    if (!stampIdx.has(i))
-      return msg;
-    const anthropic = msg.options.anthropic ?? {};
-    if (anthropic.cacheControl !== void 0)
-      return msg;
-    return Prompt.makeMessage(msg.role, {
-      ...msg,
-      options: {
-        ...msg.options,
-        anthropic: { ...anthropic, cacheControl: { type: "ephemeral" } }
-      }
+}, withStrippedVolatileContext = (model) => ({
+  ...model,
+  generateText: (options) => model.generateText(withoutVolatilePrompt(options)),
+  generateObject: (options) => model.generateObject(withoutVolatilePrompt(options)),
+  streamText: (options) => model.streamText(withoutVolatilePrompt(options))
+}), withProviderFailures = (model, protocol, selection, limits) => {
+  const actual = { provider: selection.provider, modelId: selection.modelId }, bounds = { ...limits }, failure = (error) => {
+    if (!AiError.isAiError(error))
+      return error;
+    const classified = classifyAiError(error, protocol);
+    return Option.contains(modelFailureOf(classified), "ContextOverflow") ? stampAiErrorFailure(classified, "ContextOverflow", { model: { ...actual }, limits: { ...bounds } }) : classified;
+  };
+  return {
+    ...model,
+    generateText: (options) => model.generateText(options).pipe(Effect.mapError(failure)),
+    generateObject: (options) => model.generateObject(options).pipe(Effect.mapError(failure)),
+    streamText: (options) => model.streamText(options).pipe(Stream.mapError(failure))
+  };
+}, withProviderAccounting = (model, selection) => ({
+  ...model,
+  generateText: (options) => withModelRequestCall("Text", selection, model.generateText(options)).pipe(Effect.catch((error) => isTurnError(error) ? Effect.die(error) : Effect.fail(error))),
+  generateObject: (options) => withModelRequestCall("Object", selection, model.generateObject(options)).pipe(Effect.catch((error) => isTurnError(error) ? Effect.die(error) : Effect.fail(error))),
+  streamText: (options) => withModelRequestStream("Stream", selection, model.streamText(options))
+}), withAnthropicBetas = (betas) => (client) => betas.length === 0 ? client : client.pipe(HttpClient.mapRequest((req) => HttpClientRequest.setHeader(req, "anthropic-beta", mergeBetas(Option.fromNullishOr(req.headers["anthropic-beta"]), betas)))), anthropicOAuthTransform = (access) => (client) => client.pipe(HttpClient.mapRequest((req) => HttpClientRequest.setHeader(req, "Authorization", `Bearer ${Redacted.value(access)}`)), withAnthropicBetas(ANTHROPIC_OAUTH_BETA.split(","))), llmThinkingDropped = Metric.counter("llm.thinking.dropped", {
+  description: "thinking blocks the provider dropped from a request whose conversation changed before them",
+  incremental: !0
+}), reportDropped = (label) => (reasons) => reasons.length === 0 ? Effect.void : Effect.gen(function* () {
+  yield* Effect.annotateCurrentSpan("llm.thinking.dropped", reasons.length);
+  yield* Effect.forEach(reasons, (reason) => Metric.update(Metric.withAttributes(llmThinkingDropped, { "llm.model": label, reason }), 1), { concurrency: 1, discard: !0 });
+  yield* Effect.logWarning(`the provider dropped ${reasons.length} thinking block(s) from the request: the conversation before them changed (${[...new Set(reasons)].join(", ")})`);
+}), firstEventObserver = (report) => Effect.gen(function* () {
+  const decoder = new TextDecoder, pending = yield* Ref.make(Option.some(""));
+  return (bytes) => Ref.modify(pending, (seen) => Option.match(seen, {
+    onNone: () => [Option.none(), Option.none()],
+    onSome: (before) => {
+      const text = before + decoder.decode(bytes, { stream: !0 }), first = firstEventData(text);
+      return Option.isSome(first) ? [first, Option.none()] : [Option.none(), Option.some(text)];
+    }
+  })).pipe(Effect.flatMap(Option.match({ onNone: () => Effect.void, onSome: (data) => report(droppedInMessageStart(data)) })));
+}), reportingDroppedThinking = (label) => (client) => HttpClient.transformResponse(client, Effect.flatMap((response) => {
+  const rebuilt = (body) => retainModelAttempt(response, HttpClientResponse.fromWeb(response.request, new Response(body, { status: response.status, headers: new Headers(Object.entries(response.headers)) })));
+  return (response.headers["content-type"] ?? "").includes("text/event-stream") ? firstEventObserver(reportDropped(label)).pipe(Effect.flatMap((observe) => observedResponse(response, observe)), Effect.map((observed) => observed)) : response.text.pipe(Effect.tap((text) => reportDropped(label)(droppedInBody(text))), Effect.map(rebuilt));
+})), claudeCodePrompt = Prompt.make([{ role: "system", content: CLAUDE_CODE_SYSTEM }]);
+export const prependClaudeCode = (options) => withPrompt(options, (prompt) => Prompt.concat(claudeCodePrompt, prompt));
+const withoutVolatilePrompt = (options) => withPrompt(options, (prompt) => Prompt.fromMessages(prompt.content.map((message) => {
+  const cleaned = stripVolatileContext(message.options);
+  return cleaned === message.options ? message : Prompt.makeMessage(message.role, { ...message, options: cleaned });
+}))), prepareCachePrompt = (options, policy, capability) => {
+  const prompt = Prompt.make(options.prompt), firstVolatile = prompt.content.findIndex((message) => isVolatileContext(message.options)), cut = firstVolatile < 0 ? prompt.content.length : firstVolatile, relocatedVolatile = prompt.content.slice(cut).some((message) => message.role === "system"), ttl = capability && !relocatedVolatile ? Match.valueTags(policy, {
+    Auto: (value) => Option.some(value.ttl),
+    TopLevel: () => Option.none(),
+    Off: () => Option.none()
+  }) : Option.none(), stable = prompt.content.slice(0, cut), lastSystem = stable.findLastIndex((message) => message.role === "system"), targets = [...stable.flatMap((message, index) => message.role === "system" ? [] : [index]).slice(-2).toReversed().map((index, priority) => ({ index, priority })), ...lastSystem < 0 ? [] : [{ index: lastSystem, priority: 2 }]], prepared = prompt.content.reduce((state, message, index) => {
+    const target = targets.find((value) => value.index === index), own = message.options.anthropic, cache = Predicate.hasProperty(own, "cacheControl") ? own.cacheControl : void 0, candidate = target !== void 0 && cache === void 0 && (own == null || Predicate.isObject(own)) ? Option.map(ttl, (value) => ({ priority: target.priority, control: value === "5m" ? { type: "ephemeral" } : { type: "ephemeral", ttl: value } })) : Option.none(), cleaned = stripVolatileContext(message.options), next = Option.match(candidate, {
+      onNone: () => cleaned === message.options ? message : Prompt.makeMessage(message.role, { ...message, options: cleaned }),
+      onSome: ({ control }) => Prompt.makeMessage(message.role, { ...message, options: { ...cleaned, anthropic: { ...Predicate.isObject(own) ? own : {}, cacheControl: control } } })
     });
-  });
+    return { messages: [...state.messages, next], candidates: [...state.candidates, ...Option.toArray(candidate)] };
+  }, { messages: [], candidates: [] });
+  return { options: { ...options, prompt: Prompt.fromMessages(prepared.messages) }, frame: { candidates: prepared.candidates, policy, capability } };
+}, cacheField = (value, key) => Predicate.hasProperty(value, key) ? value[key] : void 0, cachePathKey = (path) => path.join("/"), cacheableBlock = (block) => {
+  const type = cacheField(block, "type");
+  return type !== "thinking" && type !== "redacted_thinking" && (type !== "text" || typeof cacheField(block, "text") === "string" && cacheField(block, "text") !== "");
+}, cacheSlotsInBlocks = (blocks, path) => Array.isArray(blocks) ? blocks.flatMap((block, index) => {
+  const at = [...path, index];
+  return [
+    ...cacheField(block, "type") === "tool_result" ? cacheSlotsInBlocks(cacheField(block, "content"), [...at, "content"]) : [],
+    { path: at, control: cacheField(block, "cache_control"), cacheable: cacheableBlock(block) }
+  ];
+}) : [], preparedCacheSlots = (payload) => [
+  ...cacheSlotsInBlocks(cacheField(payload, "tools"), ["tools"]),
+  ...cacheSlotsInBlocks(cacheField(payload, "system"), ["system"]),
+  ...Option.match(Option.filter(Option.fromNullishOr(cacheField(payload, "messages")), Array.isArray), {
+    onNone: () => [],
+    onSome: (messages) => messages.flatMap((message, index) => cacheSlotsInBlocks(cacheField(message, "content"), ["messages", index, "content"]))
+  })
+], cacheFailure = (error) => AiError.make({
+  module: "Models",
+  method: "promptCache",
+  reason: new AiError.InvalidRequestError({ description: error.message })
+}), withoutCacheField = (value) => Object.fromEntries(Object.entries(value).filter(([key]) => key !== "cache_control")), rewriteCachePayload = (payload, patches, topLevel, capability) => {
+  const blocks = (value, path) => Array.isArray(value) ? value.map((block, index) => {
+    if (!Predicate.isObject(block))
+      return block;
+    const at = [...path, index], nested = cacheField(block, "type") === "tool_result" && Array.isArray(cacheField(block, "content")) ? { ...block, content: blocks(cacheField(block, "content"), [...at, "content"]) } : block, patch = patches.get(cachePathKey(at));
+    return patch === void 0 ? nested : { ...withoutCacheField(nested), ...Option.match(patch, { onNone: () => ({}), onSome: (control) => ({ cache_control: control }) }) };
+  }) : value, messages = cacheField(payload, "messages");
   return {
-    ...options,
-    prompt: Prompt.fromMessages(stamped)
+    ...withoutCacheField(payload),
+    ...cacheField(payload, "tools") === void 0 ? {} : { tools: blocks(cacheField(payload, "tools"), ["tools"]) },
+    ...cacheField(payload, "system") === void 0 ? {} : { system: blocks(cacheField(payload, "system"), ["system"]) },
+    ...Array.isArray(messages) ? { messages: messages.map((message, index) => Predicate.isObject(message) ? { ...message, content: blocks(cacheField(message, "content"), ["messages", index, "content"]) } : message) } : {},
+    ...Option.match(topLevel, { onNone: () => capability && cacheField(payload, "cache_control") === null ? { cache_control: null } : {}, onSome: (control) => ({ cache_control: control }) })
   };
-};
-const missingKey = (selection) => new AuthError({
+}, finalizeCachePayload = (payload) => Effect.gen(function* () {
+  const frame = yield* CurrentPromptCacheFrame, slots = preparedCacheSlots(payload), origin = (slot) => Option.fromNullishOr(frame.candidates.find((candidate) => candidate.control === slot.control));
+  if (slots.some((slot) => !slot.cacheable && slot.control != null && Option.isNone(origin(slot))))
+    return yield* Effect.fail(cacheFailure(new PromptCacheError({ reason: "Control", message: "a prompt cache control needs a nonempty cacheable content block" })));
+  const eligible = slots.filter((slot) => slot.cacheable), plan = yield* Effect.fromResult(planBreakpoints({
+    positions: eligible.map((slot) => Option.match(origin(slot), {
+      onSome: ({ priority }) => ({ _tag: "Auto", priority }),
+      onNone: () => slot.control == null ? { _tag: "Unmarked" } : { _tag: "Caller", control: slot.control }
+    })),
+    policy: frame.policy,
+    capability: frame.capability,
+    callerTopLevel: cacheField(payload, "cache_control")
+  })).pipe(Effect.mapError(cacheFailure)), selected = new Set(eligible.flatMap((slot, index) => plan.selectedAuto.includes(index) ? [cachePathKey(slot.path)] : [])), patches = new Map(slots.flatMap((slot) => Option.isSome(origin(slot)) ? [[cachePathKey(slot.path), selected.has(cachePathKey(slot.path)) ? Option.map(origin(slot), (candidate) => candidate.control) : Option.none()]] : !frame.capability ? [[cachePathKey(slot.path), Option.none()]] : []));
+  return rewriteCachePayload(payload, patches, plan.topLevel, frame.capability);
+}), withCachePlanning = (client) => ({
+  ...client,
+  createMessage: (options) => finalizeCachePayload(options.payload).pipe(Effect.flatMap((payload) => client.createMessage({ ...options, payload }))),
+  createMessageStream: (options) => finalizeCachePayload(options.payload).pipe(Effect.flatMap((payload) => client.createMessageStream({ ...options, payload })))
+}), missingKey = (selection) => new AuthError({
   provider: selection.provider,
   message: `no credential for ${selection.provider} \u2014 sign in through the AuthStore (storage "local" keeps it in ~/.efferent/runtime/auth.json), or give the models plugin one in credentials or credentialEnv (storage "memory")`
-}), openCodeResponsesConfig = (cacheKey, policy) => ({
-  strictJsonSchema: !1,
-  prompt_cache_key: Option.getOrElse(cacheKey, () => "efferent"),
-  ...Option.match(policy, {
-    onNone: () => ({}),
-    onSome: (value) => ({
-      ...value.maxOutputTokens === void 0 ? {} : { max_output_tokens: value.maxOutputTokens },
-      reasoning: {
-        effort: value.effort === "xhigh" || value.effort === "max" ? "high" : value.effort === "none" ? "low" : value.effort
-      }
-    })
+}), notWired = (selection) => new AuthError({
+  provider: selection.provider,
+  message: `provider "${selection.provider}" is not wired (built in: ${BuiltInProvider.literals.join(", ")}; add others as models plugin endpoints)`
+}), responsesPolicy = (policy, sendsEffort) => Option.match(policy, {
+  onNone: () => ({}),
+  onSome: (value) => ({
+    ...value.maxOutputTokens === void 0 ? {} : { max_output_tokens: value.maxOutputTokens },
+    ...sendsEffort ? { reasoning: { effort: publicReasoningEffort(value.effort) } } : {}
   })
 });
-export const chatCompletionsUrl = (baseUrl) => `${baseUrl.replace(/\/+$/, "")}/chat/completions`, endpointOwnKey = (endpoint) => Option.fromNullishOr(endpoint.apiKey).pipe(Option.map((key) => Redacted.isRedacted(key) ? key : Redacted.make(key)), Option.orElse(() => Option.flatMap(Option.fromNullishOr(endpoint.apiKeyEnv), (name) => Option.map(Option.fromNullishOr(process.env[name]), (value) => Redacted.make(value)))));
-const endpointKey = (endpoint, stored) => endpointOwnKey(endpoint).pipe(Option.orElse(() => Option.fromNullishOr(stored)), Option.map(Redacted.value), Option.filter((value) => value.length > 0)), compatFetch = (transport) => Option.match(transport, { onNone: () => ({}), onSome: ({ fetch }) => ({ fetchImpl: fetch }) }), codexWebSocketProxy = (transport) => Option.match(Option.flatMap(transport, (found) => Option.fromNullishOr(found.webSocketAgent)), {
+export const chatCompletionsUrl = (baseUrl) => `${baseUrl.replace(/\/+$/, "")}/chat/completions`, endpointOwnKey = (endpoint) => Option.match(Option.fromNullishOr(endpoint.apiKey), {
+  onSome: (key) => Effect.succeed(Option.some(Redacted.isRedacted(key) ? key : Redacted.make(key))),
+  onNone: () => Option.match(Option.fromNullishOr(endpoint.apiKeyEnv), {
+    onNone: () => Effect.succeedNone,
+    onSome: (name) => Config.option(Config.Redacted(name))
+  })
+});
+const endpointKey = (selection, endpoint, stored) => endpointOwnKey(endpoint).pipe(Effect.mapError((error) => new AuthError({ provider: selection.provider, message: `cannot read the endpoint's key variable: ${error.message}` })), Effect.map((own) => own.pipe(Option.orElse(() => Option.fromNullishOr(stored)), Option.map(Redacted.value), Option.filter((value) => value.length > 0))));
+export const providerServices = Effect.all({
+  endpoints: Effect.service(CurrentModelEndpoints),
+  modelSettings: Effect.service(CurrentModelSettings),
+  transport: Effect.serviceOption(ModelsTransport),
+  managedTransport: Effect.service(CurrentManagedModelsTransport),
+  sessions: Effect.service(CurrentOpenAiCodexSessions),
+  thinkingPrefixMismatch: Effect.service(CurrentThinkingPrefixMismatch)
+}, { concurrency: 1 });
+const compatFetch = (transport, managed) => Option.match(Option.filter(transport, (value) => !Option.contains(managed, value)), { onNone: () => ({}), onSome: ({ fetch }) => ({ fetchImpl: fetch }) }), codexWebSocketProxy = (selection, transport) => Option.match(Option.flatMap(transport, (found) => Option.fromNullishOr(found.webSocketAgent)), {
   onNone: () => Effect.succeed(Option.none()),
-  onSome: (route) => route(new URL(OPENAI_CODEX_API_URL)).pipe(Effect.mapError((error) => new AuthError({ provider: "openai-codex", message: error.message })))
-}), endpointModel = (selection, url, key, standardOnly, images, transport) => makeCompatLanguageModel({
+  onSome: (route) => route(new URL(OPENAI_CODEX_API_URL)).pipe(Effect.mapError((error) => new AuthError({ provider: selection.provider, message: error.message })))
+}), endpointModel = (selection, url, key, standardOnly, images, transport, managedTransport) => makeCompatLanguageModel({
   moduleName: selection.provider,
   chatUrl: chatCompletionsUrl(url),
   model: selection.modelId,
   standardOnly,
   images,
-  ...compatFetch(transport),
+  ...compatFetch(transport, managedTransport),
   ...Option.match(key, { onNone: () => ({}), onSome: (apiKey) => ({ apiKey }) })
-}).pipe(Effect.map((svc) => ({ svc, prependClaudeCode: !1, images }))), buildProviderService = (selection, credential, key) => Effect.flatMap(Effect.all({ endpoints: Effect.service(CurrentModelEndpoints), transport: Effect.serviceOption(ModelsTransport) }), ({ endpoints, transport }) => {
-  const endpoint = Option.fromNullishOr(endpoints[selection.provider]);
-  if (Option.isSome(endpoint))
-    return endpointModel(selection, endpoint.value.url, endpointKey(endpoint.value, key), endpoint.value.standardOnly ?? !0, endpoint.value.images ?? !1, transport);
-  if (credential?.type === "local" && credential.baseUrl !== void 0)
-    return endpointModel(selection, credential.baseUrl, Option.none(), !0, !1, transport);
-  return buildBuiltInProvider(selection, credential, key, transport);
-}), buildBuiltInProvider = (selection, credential, key, transport) => {
-  const oauth = credential?.type === "oauth", images = imageInputFor(formatModelSelection(selection));
-  if (selection.provider === "opencode") {
-    if (key === void 0)
-      return Effect.fail(missingKey(selection));
-    if (usesOpenCodeResponses(selection.modelId))
-      return Effect.all({
-        cacheKey: Effect.service(CurrentPromptCacheKey),
-        policy: Effect.service(CurrentModelCallPolicy)
-      }).pipe(Effect.flatMap(({ cacheKey, policy }) => OpenAiClient.make({ apiKey: key, apiUrl: OPENCODE_RESPONSES_API_URL }).pipe(Effect.flatMap((client) => OpenAiLanguageModel.make({
-        model: selection.modelId,
-        config: openCodeResponsesConfig(cacheKey, policy)
-      }).pipe(Effect.provideService(OpenAiClient.OpenAiClient, client))), Effect.map((svc) => ({ svc, prependClaudeCode: !1, images })))));
-    return makeCompatLanguageModel({
-      moduleName: "OpenCode",
-      chatUrl: OPENCODE_CHAT_URL,
-      apiKey: Redacted.value(key),
-      model: selection.modelId,
-      images,
-      ...compatFetch(transport)
-    }).pipe(Effect.map((svc) => ({ svc, prependClaudeCode: !1, images })));
-  }
-  if (selection.provider === "google")
-    return key === void 0 ? Effect.fail(missingKey(selection)) : makeCompatLanguageModel({
-      moduleName: "Google",
-      chatUrl: GOOGLE_CHAT_URL,
-      apiKey: Redacted.value(key),
-      model: selection.modelId,
-      standardOnly: !0,
-      usage: { reasoning: !1 },
-      images,
-      ...compatFetch(transport)
-    }).pipe(Effect.map((svc) => ({ svc, prependClaudeCode: !1, images })));
-  if (selection.provider === "anthropic") {
-    if (key === void 0)
-      return Effect.fail(missingKey(selection));
-    return (oauth ? AnthropicClient.make({
-      apiKey: void 0,
-      transformClient: anthropicOAuthTransform(key)
-    }) : AnthropicClient.make({ apiKey: key })).pipe(Effect.flatMap((client) => AnthropicLanguageModel.make({ model: selection.modelId }).pipe(Effect.provideService(AnthropicClient.AnthropicClient, client))), Effect.map((svc) => ({ svc, prependClaudeCode: oauth, images })));
-  }
-  if (selection.provider === "openai-codex") {
-    if (key === void 0 || credential?.type !== "oauth")
-      return Effect.fail(missingKey(selection));
-    const accountId = Option.orElse(Option.fromNullishOr(credential.accountId), () => openAiCodexAccountId(Redacted.value(key)));
-    if (Option.isNone(accountId))
-      return Effect.fail(new AuthError({ provider: selection.provider, message: "the OpenAI subscription token has no ChatGPT account id \u2014 sign in to the subscription again and store the new token" }));
-    return codexWebSocketProxy(transport).pipe(Effect.flatMap((webSocketProxy) => makeOpenAiCodexLanguageModel({ model: selection.modelId, accessToken: key, accountId: accountId.value, webSocketProxy })), Effect.map((svc) => ({ svc, prependClaudeCode: !1, images })));
+}).pipe(Effect.map((svc) => ({ svc, settings: Option.none(), prependClaudeCode: !1, images, route: "compat" }))), buildProviderService = (selection, credential, key, services) => {
+  const endpoint = Object.hasOwn(services.endpoints, selection.provider) ? Option.fromNullishOr(services.endpoints[selection.provider]) : Option.none();
+  if (Option.isSome(endpoint)) {
+    const configured = endpoint.value;
+    return Effect.flatMap(endpointKey(selection, configured, key), (own) => {
+      if (configured.api === "anthropic-messages") {
+        const model = anthropicProfileOf(selection.modelId);
+        return anthropicModel({ selection, model, modelSettings: services.modelSettings, thinkingPrefixMismatch: services.thinkingPrefixMismatch }, {
+          _tag: "Api",
+          key: Option.map(own, Redacted.make),
+          endpoint: Option.some(configured)
+        }).pipe(Effect.map((built) => ({ ...built, images: configured.images ?? model.images, route: "anthropic" })));
+      }
+      return otherRouteSettings(selection, services.modelSettings).pipe(Effect.andThen(endpointModel(selection, configured.url, own, configured.standardOnly ?? !0, configured.images ?? !1, services.transport, services.managedTransport)));
+    });
   }
-  if (selection.provider === "openai")
-    return key === void 0 ? Effect.fail(missingKey(selection)) : Effect.flatMap(Effect.service(CurrentPromptCacheKey), (cacheKey) => OpenAiClient.make({ apiKey: key }).pipe(Effect.flatMap((client) => OpenAiLanguageModel.make({
+  if (credential?.type === "local" && credential.baseUrl !== void 0)
+    return otherRouteSettings(selection, services.modelSettings).pipe(Effect.andThen(endpointModel(selection, credential.baseUrl, Option.none(), !0, !1, services.transport, services.managedTransport)));
+  return buildBuiltInProvider(selection, credential, key, services);
+};
+export const anthropicBaseUrl = (base) => base.replace(/\/+$/, "").replace(/\/v1$/, ""), modelSettingsFailure = (error) => AiError.make({
+  module: "Models",
+  method: "settings",
+  reason: new AiError.InvalidRequestError({ description: error.message })
+});
+const otherRouteSettings = (selection, settings) => Object.hasOwn(settings, formatModelSelection(selection)) && Object.keys(settings[formatModelSelection(selection)] ?? {}).length > 0 ? Effect.fail(new ModelSettingsError({ reason: "Selection", message: "per-model settings require an Anthropic Messages route for this selection" })) : Effect.void, forcedTool = (choice) => choice === "required" || Predicate.isObject(choice) && (("tool" in choice) || choice.mode === "required"), pinnedAnthropicNativeJson = (model) => typeof model !== "string" || ["claude-sonnet-4-5", "claude-opus-4-5", "claude-haiku-4-5", "claude-opus-4-1"].some((id) => model.includes(id)) || !["claude-sonnet-4-0", "claude-sonnet-4-20250514", "claude-opus-4-0", "claude-opus-4-20250514", "claude-3-"].some((id) => model.includes(id)), withAnthropicSettings = (model, resolved, wire, binding, capability) => {
+  const prepare = (options, object = !1) => Effect.flatMap(Effect.all([Effect.serviceOption(AnthropicLanguageModel.Config), Effect.service(CurrentModelCallPurpose)], { concurrency: 1 }), ([ambient, purpose]) => {
+    const { thinking: _thinking, output_config: _outputConfig, ...unowned } = Option.getOrElse(ambient, () => ({})), nativeJson = unowned.structuredOutputs ?? pinnedAnthropicNativeJson(wire.model);
+    return Effect.fromResult(validateAnthropicRequest(resolved, { forcedTool: forcedTool(options.toolChoice) || object && !nativeJson, binding })).pipe(Effect.mapError(modelSettingsFailure), Effect.map(() => ({ config: { ...unowned, ...wire }, ...prepareCachePrompt(options, purpose === "Helper" ? { _tag: "Off" } : resolved.promptCache, capability) })));
+  });
+  return {
+    ...model,
+    generateText: (options) => prepare(options).pipe(Effect.flatMap(({ config, options: shaped, frame }) => model.generateText(shaped).pipe(Effect.provideService(AnthropicLanguageModel.Config, config), Effect.provideService(CurrentPromptCacheFrame, frame)))),
+    generateObject: (options) => prepare(options, !0).pipe(Effect.flatMap(({ config, options: shaped, frame }) => model.generateObject(shaped).pipe(Effect.provideService(AnthropicLanguageModel.Config, config), Effect.provideService(CurrentPromptCacheFrame, frame)))),
+    streamText: (options) => Stream.unwrap(prepare(options).pipe(Effect.map(({ config, options: shaped, frame }) => model.streamText(shaped).pipe(Stream.provideService(AnthropicLanguageModel.Config, config), Stream.provideService(CurrentPromptCacheFrame, frame)))))
+  };
+};
+export const resolveMessagesConfiguration = (selection, modelSettings, policy, thinkingPrefixMismatch, endpoint) => Result.flatMap(resolveAnthropicSettings(formatModelSelection(selection), modelSettings, policy), (resolved) => {
+  const binding = bindingFor(anthropicProfileOf(selection.modelId).bindsThinking && Option.exists(resolved.thinking, (value) => value._tag === "Adaptive"), thinkingPrefixMismatch);
+  return Result.map(validateAnthropicRequest(resolved, { forcedTool: !1, binding: Option.isSome(binding) }), () => {
+    const wire = {
       model: selection.modelId,
-      config: {
-        prompt_cache_key: Option.getOrElse(cacheKey, () => "efferent")
+      max_tokens: resolved.maxOutputTokens,
+      ...Option.match(resolved.effort, { onNone: () => ({}), onSome: (effort) => ({ output_config: { effort } }) }),
+      ...Option.match(resolved.thinking, { onNone: () => ({}), onSome: (thinking) => ({ thinking: ModelThinking.match(thinking, {
+        Adaptive: (value) => ({ type: "adaptive", display: value.display ?? "summarized", ...Option.match(binding, { onNone: () => ({}), onSome: (behavior) => ({ block_binding: { prefix_mismatch_behavior: behavior } }) }) }),
+        Budget: (value) => ({ type: "enabled", budget_tokens: value.budgetTokens, display: value.display ?? "summarized" }),
+        BetweenTools: () => ({ type: "between_tools" }),
+        Off: () => ({ type: "disabled" })
+      }) }) })
+    }, settings = {
+      ...wire,
+      promptCache: resolved.promptCache,
+      cacheControl: Option.match(endpoint, { onNone: () => !0, onSome: (value) => value.cacheControl ?? !0 }),
+      ...Option.match(endpoint, { onNone: () => ({}), onSome: (value) => ({ endpoint: { api: value.api, url: anthropicBaseUrl(value.url), auth: value.auth ?? "x-api-key", apiVersion: value.apiVersion ?? "2023-06-01", betas: value.betas ?? [], cacheControl: value.cacheControl ?? !0 } }) }),
+      ...Option.match(binding, { onNone: () => ({}), onSome: (behavior) => ({ thinkingPrefixMismatch: behavior }) })
+    };
+    return { resolved, binding, wire, settings };
+  });
+});
+const requestClient = (client, protocol) => resilientHttpClient(client, { protocol, adaptResponse: (response) => response }), anthropicModel = ({ selection, modelSettings, thinkingPrefixMismatch }, authentication) => Effect.gen(function* () {
+  const endpoint = Match.valueTags(authentication, { Api: (value) => value.endpoint, Subscription: () => Option.none() }), { resolved, binding, wire, settings } = yield* Effect.fromResult(resolveMessagesConfiguration(selection, modelSettings, yield* CurrentModelCallPolicy, thinkingPrefixMismatch, endpoint)), bound = (client) => Option.match(binding, {
+    onNone: () => client,
+    onSome: () => client.pipe(withAnthropicBetas([THINKING_BINDING_BETA]), reportingDroppedThinking(formatModelSelection(selection)))
+  }), options = Match.valueTags(authentication, {
+    Subscription: ({ access }) => ({ transformClient: (client) => bound(requestClient(anthropicOAuthTransform(access)(client), "anthropic")) }),
+    Api: ({ key, endpoint }) => ({
+      ...Option.match(key, { onNone: () => ({}), onSome: (apiKey) => Option.exists(endpoint, (value) => value.auth === "bearer") ? {} : { apiKey } }),
+      ...Option.match(endpoint, { onNone: () => ({}), onSome: (value) => ({ apiUrl: anthropicBaseUrl(value.url), ...value.apiVersion === void 0 ? {} : { apiVersion: value.apiVersion } }) }),
+      transformClient: (client) => {
+        const authenticated = Option.match(Option.filter(endpoint, (value) => value.auth === "bearer"), {
+          onNone: () => client,
+          onSome: () => Option.match(key, { onNone: () => client, onSome: (apiKey) => client.pipe(HttpClient.mapRequest((request) => HttpClientRequest.setHeader(request, "Authorization", `Bearer ${Redacted.value(apiKey)}`))) })
+        });
+        return bound(requestClient(authenticated.pipe(withAnthropicBetas(Option.match(endpoint, { onNone: () => [], onSome: (value) => value.betas ?? [] }))), "anthropic"));
       }
-    }).pipe(Effect.provideService(OpenAiClient.OpenAiClient, client))), Effect.map((svc) => ({ svc, prependClaudeCode: !1, images }))));
-  return Effect.fail(new AuthError({
-    provider: selection.provider,
-    message: `provider "${selection.provider}" is not wired (built in: opencode, google, anthropic, openai, openai-codex; add others as models plugin endpoints)`
-  }));
-};
-export const buildProvider = (selection, credential, key) => buildProviderService(selection, credential, key).pipe(Effect.flatMap((built) => Effect.gen(function* () {
-  const cacheKey = yield* Effect.service(CurrentPromptCacheKey), policy = yield* Effect.service(CurrentModelCallPolicy), responses = selection.provider === "opencode" && usesOpenCodeResponses(selection.modelId), settings = selection.provider === "anthropic" ? { systemPrelude: built.prependClaudeCode ? CLAUDE_CODE_SYSTEM : null } : responses ? openCodeResponsesConfig(cacheKey, policy) : { prompt_cache_key: Option.getOrElse(cacheKey, () => "efferent") }, descriptor = { provider: selection.provider, model: selection.modelId, settings };
+    })
+  }), client = withAnthropicFailures(withCachePlanning(yield* AnthropicClient.make(options))), service = yield* AnthropicLanguageModel.make({ model: selection.modelId, config: wire }).pipe(Effect.provideService(AnthropicClient.AnthropicClient, client)), oauth = authentication._tag === "Subscription";
+  return {
+    svc: withAnthropicSettings(service, resolved, wire, Option.isSome(binding), Option.match(endpoint, { onNone: () => !0, onSome: (value) => value.cacheControl ?? !0 })),
+    settings: Option.some({ ...wire, systemPrelude: oauth ? CLAUDE_CODE_SYSTEM : null, ...settings }),
+    prependClaudeCode: oauth,
+    overflowLimits: { ...resolved.limits, maxOutputTokens: resolved.maxOutputTokens }
+  };
+}), responsesModel = (route, { selection, model, key }) => Effect.all({ cacheKey: Effect.service(CurrentPromptCacheKey), policy: Effect.service(CurrentModelCallPolicy) }, { concurrency: 1 }).pipe(Effect.flatMap(({ cacheKey, policy }) => {
+  const config = {
+    ...Option.match(route.strictJsonSchema, { onNone: () => ({}), onSome: (strictJsonSchema) => ({ strictJsonSchema }) }),
+    prompt_cache_key: Option.getOrElse(cacheKey, () => "efferent"),
+    ...responsesPolicy(policy, route.effort === "always" || model.efforts.length > 0)
+  };
+  return OpenAiClient.make({ apiKey: key, transformClient: (client) => requestClient(client, "openai"), ...Option.match(route.apiUrl, { onNone: () => ({}), onSome: (apiUrl) => ({ apiUrl }) }) }).pipe(Effect.flatMap((client) => OpenAiLanguageModel.make({ model: selection.modelId, config }).pipe(Effect.provideService(OpenAiClient.OpenAiClient, withOpenAiFailures(client)))), Effect.map((svc) => ({ svc, settings: Option.some(config), prependClaudeCode: !1 })));
+})), codexModel = ({ selection, credential, key, transport, sessions }) => {
+  if (credential?.type !== "oauth")
+    return Effect.fail(missingKey(selection));
+  const accountId = Option.orElse(Option.fromNullishOr(credential.accountId), () => openAiCodexAccountId(Redacted.value(key)));
+  if (Option.isNone(accountId))
+    return Effect.fail(new AuthError({ provider: selection.provider, message: "the OpenAI subscription token has no ChatGPT account id \u2014 sign in to the subscription again and store the new token" }));
+  return codexWebSocketProxy(selection, transport).pipe(Effect.flatMap((webSocketProxy) => makeOpenAiCodexLanguageModel({ model: selection.modelId, accessToken: key, accountId: accountId.value, webSocketProxy }).pipe(Effect.provideService(CurrentOpenAiCodexSessions, sessions))), Effect.map((svc) => ({ svc, settings: Option.none(), prependClaudeCode: !1 })));
+}, chatModel = (route, { selection, model, key, transport, managedTransport }) => makeCompatLanguageModel({
+  moduleName: route.moduleName,
+  chatUrl: route.chatUrl,
+  apiKey: Redacted.value(key),
+  model: selection.modelId,
+  standardOnly: route.standardOnly,
+  usage: route.usage,
+  images: model.images,
+  ...compatFetch(transport, managedTransport)
+}).pipe(Effect.map((svc) => ({ svc, settings: Option.none(), prependClaudeCode: !1 }))), buildBuiltInProvider = (selection, credential, key, { transport, managedTransport, sessions, thinkingPrefixMismatch, modelSettings }) => Option.match(profileOf(selection.provider), {
+  onNone: () => Effect.fail(notWired(selection)),
+  onSome: (profile) => Option.match(Option.fromNullishOr(key), {
+    onNone: () => Effect.fail(missingKey(selection)),
+    onSome: (found) => {
+      const call = { selection, model: profile.modelOf(selection.modelId), credential, key: found, transport, managedTransport, sessions, thinkingPrefixMismatch, modelSettings }, route = profile.routeOf(selection.modelId), built = Match.valueTags(route, {
+        anthropic: () => anthropicModel(call, credential?.type === "oauth" ? { _tag: "Subscription", access: found } : { _tag: "Api", key: Option.some(found), endpoint: Option.none() }),
+        "openai-responses": (responses) => responsesModel(responses, call),
+        "openai-codex": () => codexModel(call),
+        compat: (chat) => chatModel(chat, call)
+      });
+      return Effect.map(route._tag === "anthropic" ? built : otherRouteSettings(selection, modelSettings).pipe(Effect.andThen(built)), (routed) => ({ ...routed, images: call.model.images, route: route._tag }));
+    }
+  })
+}), descriptorOf = (selection, built) => Option.match(built.settings, {
+  onSome: (settings) => Effect.succeed({ provider: selection.provider, model: selection.modelId, settings }),
+  onNone: () => modelRequestDescriptorOf(built.svc).pipe(Effect.map(Option.match({
+    onNone: () => ({ provider: selection.provider, model: selection.modelId, settings: {} }),
+    onSome: (value) => ({ ...value, provider: selection.provider })
+  })))
+});
+export const buildProviderOver = (services) => (selection, credential, key) => buildProviderService(selection, credential, key, services).pipe(Effect.map((built) => {
+  const classified = withProviderAccounting(withProviderFailures(built.svc, providerFailureProtocol(built.route), selection, built.overflowLimits ?? {}), selection), labeled = built.images ? classified : withImageLabels(classified);
   return {
-    ...built,
-    svc: describeModel(built.images ? built.svc : withImageLabels(built.svc), modelRequestDescriptorOf(built.svc).pipe(Effect.map((existing) => Option.match(existing, { onNone: () => descriptor, onSome: (value) => ({ ...value, provider: selection.provider }) }))))
+    svc: describeModel(built.route === "anthropic" ? labeled : withStrippedVolatileContext(labeled), descriptorOf(selection, built)),
+    prependClaudeCode: built.prependClaudeCode,
+    images: built.images,
+    route: built.route
   };
-})));
+})), buildProvider = (selection, credential, key) => Effect.flatMap(providerServices, (services) => buildProviderOver(services)(selection, credential, key));

package/dist/llm/retry.d.ts

@@ -1,54 +1,18 @@
 import { AiError } from "effect/ai";
 import { Effect, Stream } from "effect";
-/**
- * Transient-failure resilience for every routed LLM call — the survival
- * learnings from the previous line, v1-scoped:
- *
- * - Retry ONLY transients (429 / 5xx / transport / timeout / empty body) —
- *   never a 4xx client error or a decode failure, which are permanent.
- * - Every request is bounded by a {@link LLM_REQUEST_TIMEOUT_MS} fiber-level
- *   timeout (official provider clients ship none), classified transient.
- * - An HTTP 200 with no text/tool-call/reasoning content is rejected as a
- *   transient failure (the "empty response that fake-completes a turn
- *   mid-thought" class) and rides the same retries.
- * - A 429 whose `Retry-After` exceeds {@link MAX_HONORED_RETRY_AFTER_MS} is
- *   a daily quota, not an outage — {@link classifyLlmError} calls it
- *   PERMANENT so it fails fast instead of burning retries into the same
- *   wall (the uncapped-Retry-After lesson: never park a run on a quota).
- *   The fast-retry schedule itself never sleeps on the header.
- *
- * The previous line's multi-phase patient ladder (30-minute interactive
- * outage waits) is deliberately NOT ported yet — it needs a per-run
- * interaction policy the engine doesn't carry; add it when live use demands.
- */
-export declare const LLM_REQUEST_TIMEOUT_MS = 300000;
-export declare const MAX_HONORED_RETRY_AFTER_MS = 60000;
+/** Default bound on a streamed request's pending headers; configure CurrentModelRetryPolicy per call. @public */
+export declare const LLM_REQUEST_TIMEOUT_MS: number;
+/** Default total request budget, shared with a configured fallback. @public */
+export declare const LLM_CALL_BUDGET_MS: number;
 export type ErrorClass = "transient" | "permanent";
-export declare const classifyLlmError: (error: unknown) => ErrorClass;
-/** Reject an HTTP-200-but-empty response so it retries instead of
- *  fake-completing the turn — UNLESS the loop has declared tolerance
+/** Semantic fallback eligibility. HTTP retries and Retry-After waits belong to the request policy. */
+export declare const classifyLlmError: (error: unknown, _now?: number) => ErrorClass;
+/** Reject an HTTP-200-but-empty response instead of fake-completing
+ *  the turn — UNLESS the loop has declared tolerance
  *  ({@link CurrentEmptyResponseTolerance}): once a run has executed tool
- *  calls, a following empty response is the model finishing, and rejecting
- *  it would park the turn in the patient outage ladder. */
+ *  calls, a following empty response is the model finishing. */
 export declare const rejectEmptyResponse: (label: string) => <A extends {
     readonly content: ReadonlyArray<unknown>;
 }, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | AiError.AiError, R>;
-/** Timeout + transient-only retries around one routed LLM connect. */
-export declare const retryableLlm: (label: string) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | AiError.AiError, R>;
-/**
- * The STREAM twin of {@link retryableLlm}, with semantics a settled call
- * doesn't need:
- *
- * - Retry covers connection + PRE-first-content failures only. Once a
- *   content part has flowed to the consumer, a replayed stream would emit
- *   duplicates — so after content, failures are final (a `Ref`-armed gate on
- *   the retry schedule).
- * - The empty guard WITHHOLDS the finish part: a finish with zero content
- *   parts fails as the transient empty-response error instead of
- *   fake-completing the turn — and, being pre-content by definition, it
- *   rides the same retries.
- * - The timeout is per-PART idle time (bounds time-to-first-part AND a
- *   mid-stream hang), not whole-request — a long healthy stream never trips
- *   it while tokens flow.
- */
-export declare const retryableLlmStream: (label: string, timeoutMs?: number) => <A, E, R>(stream: Stream.Stream<A, E, R>) => Stream.Stream<A, E | AiError.AiError, R>;
+/** Preserve streamed content and semantic failures; reject an empty finish without replaying its request. */
+export declare const rejectEmptyStream: (label: string) => <A, E, R>(stream: Stream.Stream<A, E, R>) => Stream.Stream<A, E | AiError.AiError, R>;