@xandreed/plugin-models 0.13.0 → 0.15.0

package/dist/llm/sse.js

@@ -1,20 +1,22 @@
 import { AiError } from "effect/ai";
-import { Effect, Option, Result, Stream } from "effect";
-export const usageFromCompletion = (usage) => {
-  const input = usage?.prompt_tokens ?? 0, cached = usage?.prompt_cache_hit_tokens ?? usage?.cached_tokens ?? usage?.prompt_tokens_details?.cached_tokens ?? 0;
+import { Cause, Effect, Exit, Match, Option, Result, Schema, Stream } from "effect";
+import { isTurnError, reasonOf } from "@xandreed/core";
+import { completeModelAttempt, modelOutcomeOfExit, observeModelAttempt } from "./model-completion.adapter.js";
+import { chunkErrorOf, decodeStreamChunk, decodeToolArguments, isQuotaExhausted } from "./chat-wire.entity.functions.js";
+import { redactCredentials } from "../transport/http-proxy.entity.functions.js";
+import { classifyAiError } from "./provider-failure.entity.functions.js";
+export const usageFromCompletion = (usage, reading = {}) => {
+  const input = usage?.prompt_tokens ?? 0, cached = usage?.prompt_cache_hit_tokens ?? usage?.cached_tokens ?? usage?.prompt_tokens_details?.cached_tokens ?? 0, written = usage?.prompt_tokens_details?.cache_write_tokens ?? 0, output = usage?.completion_tokens ?? 0, reasoning = reading.reasoning === !1 ? 0 : usage?.completion_tokens_details?.reasoning_tokens ?? 0;
   return {
-    inputTokens: { total: input, uncached: Math.max(0, input - cached), cacheRead: cached },
-    outputTokens: { total: usage?.completion_tokens ?? 0 }
+    inputTokens: { total: input, uncached: Math.max(0, input - cached - written), cacheRead: cached, cacheWrite: written },
+    outputTokens: { total: output, text: Math.max(0, output - reasoning), reasoning }
   };
-}, finishReasonFromWire = (raw) => {
-  if (raw === "tool_calls")
-    return "tool-calls";
-  if (raw === "length")
-    return "length";
-  if (raw === "content_filter")
-    return "content-filter";
-  return "stop";
 };
+const endOfWord = (word) => Match.value(word.trim().toLowerCase()).pipe(Match.whenOr("stop", "tool_calls", "function_call", "tool_use", "tool_call", "end_turn", "stop_sequence", "eos", () => "settled"), Match.whenOr("length", "max_tokens", () => "length"), Match.when("content_filter", () => "content-filter"), Match.whenOr("error", "insufficient_system_resource", () => "error"), Match.orElse(() => "other")), namedReason = (raw) => Option.filter(Option.fromNullishOr(raw), (word) => word.trim().length > 0);
+export const finishReasonFromWire = (raw, hasToolCalls) => {
+  const end = Option.match(Option.flatMap(raw, namedReason), { onNone: () => "settled", onSome: endOfWord });
+  return end === "settled" ? hasToolCalls ? "tool-calls" : "stop" : end;
+}, toolCallParams = (args, reason, invalid) => decodeToolArguments(args).pipe(Effect.catchTag("SchemaError", () => reason === "stop" || reason === "tool-calls" ? Effect.fail(invalid()) : Effect.succeed({})));
 const initialState = {
   textOpen: Option.none(),
   reasoningOpen: Option.none(),
@@ -68,51 +70,57 @@ const initialState = {
     args: call.args + (fragment.function?.arguments ?? "")
   } : call);
 }, malformed = (moduleName, description) => AiError.make({ module: moduleName, method: "streamText", reason: new AiError.InvalidOutputError({ description }) }), applyChunk = (moduleName, state, chunk) => {
-  if (chunk.error !== void 0 && chunk.error !== null)
-    return Effect.fail(AiError.make({
+  if (chunk.error !== void 0 && chunk.error !== null) {
+    const error = chunkErrorOf(chunk.error);
+    return Effect.fail(classifyAiError(AiError.make({
       module: moduleName,
       method: "streamText",
-      reason: new AiError.UnknownError({
-        description: `the stream carried an error chunk: ${JSON.stringify(chunk.error).slice(0, 500)}`
+      reason: isQuotaExhausted(Option.none(), error) ? new AiError.QuotaExhaustedError({ metadata: { [moduleName]: { ...Option.getOrElse(error, () => ({})) } } }) : new AiError.UnknownError({
+        description: `the stream carried an error chunk: ${JSON.stringify(chunk.error).slice(0, 500)}`,
+        metadata: { [moduleName]: { ...Option.getOrElse(error, () => ({})) } }
       })
-    }));
+    }), "compat"));
+  }
   const choice = chunk.choices?.[0], delta = choice?.delta, reasoning = delta?.reasoning_content ?? delta?.reasoning, content = delta?.content, afterReasoning = typeof reasoning === "string" && reasoning.length > 0 ? emitReasoning(state, reasoning) : [state, []], afterText = emitThen(afterReasoning, (s) => typeof content === "string" && content.length > 0 ? emitText(s, content) : [s, []]), [folded, parts] = afterText, next = {
     ...folded,
     toolCalls: (delta?.tool_calls ?? []).reduce(mergeToolFragment, folded.toolCalls),
-    finishReason: typeof choice?.finish_reason === "string" ? Option.some(choice.finish_reason) : folded.finishReason,
+    finishReason: Option.orElse(namedReason(choice?.finish_reason), () => folded.finishReason),
     usage: chunk.usage !== null && chunk.usage !== void 0 ? Option.some(chunk.usage) : folded.usage
   };
   return Effect.succeed([next, parts]);
-}, flush = (moduleName, state) => state.flushed ? Effect.succeed([state, []]) : Effect.gen(function* () {
-  const [closed, closeParts] = emitThen(closeText(state), closeReasoning), toolParts = yield* Effect.forEach(closed.toolCalls, (call, index) => Effect.try({
-    try: () => ({
-      type: "tool-call",
-      id: call.id.length > 0 ? call.id : `call_${index}`,
-      name: call.name,
-      params: JSON.parse(call.args.length > 0 ? call.args : "{}")
-    }),
-    catch: () => malformed(moduleName, `tool call ${call.name.length > 0 ? call.name : "?"} carried unparseable JSON arguments`)
-  })), finish = {
+}, flush = (moduleName, reading, state, end) => state.flushed ? Effect.succeed([state, []]) : Effect.gen(function* () {
+  const [closed, closeParts] = emitThen(closeText(state), closeReasoning), reason = end === "eof" && Option.isNone(closed.finishReason) ? "unknown" : finishReasonFromWire(closed.finishReason, closed.toolCalls.length > 0), toolParts = yield* Effect.forEach(closed.toolCalls, (call) => toolCallParams(call.args.length > 0 ? call.args : "{}", reason, () => malformed(moduleName, `tool call ${call.name.length > 0 ? call.name : "?"} carried unparseable JSON arguments`)).pipe(Effect.map((params) => ({
+    type: "tool-call",
+    id: call.id,
+    name: call.name,
+    params
+  }))), { concurrency: 1 }), finish = {
     type: "finish",
-    reason: toolParts.length > 0 ? "tool-calls" : finishReasonFromWire(Option.getOrUndefined(closed.finishReason)),
-    usage: usageFromCompletion(Option.getOrUndefined(closed.usage))
+    reason,
+    usage: usageFromCompletion(Option.getOrElse(closed.usage, () => ({})), reading)
   };
   return [
     { ...closed, flushed: !0 },
     [...closeParts, ...toolParts, finish]
   ];
-}), DONE = "[DONE]", step = (moduleName, state, payload) => payload === DONE ? flush(moduleName, state) : Effect.try({
-  try: () => JSON.parse(payload),
-  catch: () => malformed(moduleName, `a data: line was not JSON: ${payload.slice(0, 200)}`)
-}).pipe(Effect.flatMap((chunk) => applyChunk(moduleName, state, chunk)));
+}), DONE = "[DONE]", step = (moduleName, reading, state, payload, attempt, observeUsage) => {
+  const ended = (end) => Option.match(attempt, { onNone: () => Effect.void, onSome: (value) => completeModelAttempt(value, { _tag: "Completed" }) }).pipe(Effect.andThen(flush(moduleName, reading, state, end)));
+  return Match.valueTags(payload, {
+    End: () => ended("eof"),
+    Data: ({ data }) => data === DONE ? ended("done") : decodeStreamChunk(moduleName, data).pipe(Effect.tap((chunk) => {
+      const final = Option.isSome(state.finishReason) || (chunk.choices ?? []).some((choice) => choice.finish_reason != null);
+      return Option.match(attempt, { onNone: () => Effect.void, onSome: (value) => observeModelAttempt(value, chunk.usage, final, reading.reasoning ?? !0) }).pipe(Effect.andThen(observeUsage?.(chunk.usage, final) ?? Effect.void));
+    }), Effect.flatMap((chunk) => applyChunk(moduleName, state, chunk)))
+  });
+};
 export const sseStreamParts = (options) => Stream.fromReadableStream({
   evaluate: () => options.body,
-  onError: (cause) => AiError.make({
+  onError: (cause) => AiError.isAiError(cause) || isTurnError(cause) ? cause : AiError.make({
     module: options.moduleName,
     method: "streamText",
-    reason: new AiError.UnknownError({ description: `the response body stream failed: ${String(cause)}` })
+    reason: new AiError.UnknownError({ description: `the response body stream failed: ${redactCredentials(reasonOf(Cause.die(cause)))}` })
   })
 }).pipe(Stream.decodeText(), Stream.splitLines, Stream.filterMap((line) => {
   const trimmed = line.trim();
-  return trimmed.startsWith("data:") ? Result.succeed(trimmed.slice(5).trim()) : Result.fail(line);
-}), Stream.concat(Stream.succeed(DONE)), Stream.mapAccumEffect(() => initialState, (state, payload) => step(options.moduleName, state, payload)));
+  return trimmed.startsWith("data:") ? Result.succeed({ _tag: "Data", data: trimmed.slice(5).trim() }) : Result.fail(line);
+}), Stream.concat(Stream.succeed({ _tag: "End" })), Stream.mapAccumEffect(() => initialState, (state, payload) => step(options.moduleName, options.usage ?? {}, state, payload, options.attempt ?? Option.none(), options.observeUsage)), Stream.onExit((exit) => Option.match(options.attempt ?? Option.none(), { onNone: () => Effect.void, onSome: (attempt) => completeModelAttempt(attempt, Exit.isSuccess(exit) ? { _tag: "Interrupted" } : modelOutcomeOfExit(exit)).pipe(Effect.catch((error) => Effect.die(error))) })), Stream.catch((error) => isTurnError(error) ? Stream.die(error) : Stream.fail(error)));

package/dist/llm/thinking-binding.entity.d.ts

@@ -0,0 +1,49 @@
+import { Schema } from "effect";
+/**
+ * What a request tells a model that binds each thinking block to the
+ * conversation before it (`ModelProfile.bindsThinking`) to do with a block
+ * whose prefix changed: `provider-default` sends nothing and leaves it to
+ * the account (an account that enforces the binding refuses the request,
+ * one that does not passes the block on); `drop_block` drops that block and
+ * the later thinking blocks for the request; `error` refuses the request.
+ * Any value but `provider-default` turns the binding on for that request.
+ */
+export declare const ThinkingPrefixMismatch: Schema.Literals<readonly ["provider-default", "drop_block", "error"]>;
+export type ThinkingPrefixMismatch = typeof ThinkingPrefixMismatch.Type;
+/** The beta a request needs to carry `thinking.block_binding` (refused without it) and to be told what was dropped. */
+export declare const THINKING_BINDING_BETA = "thinking-binding-controls-2026-08-01";
+/** One change the provider made to a request's input before the model read it (`input_transformations`). */
+export declare const InputTransformation: Schema.Struct<{
+    /** `thinking_dropped`, `thinking_mismatch_allowed`, or another the provider adds later. */
+    readonly type: Schema.String;
+    /** Why: `prefix_binding_mismatch`, `model_binding_mismatch`, `organization_binding_mismatch`. */
+    readonly reason: Schema.optionalKey<Schema.String>;
+}>;
+export type InputTransformation = typeof InputTransformation.Type;
+/** What a settled response's body says it changed, its other fields left unread. */
+export declare const TransformedResponse: Schema.Struct<{
+    readonly input_transformations: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        /** `thinking_dropped`, `thinking_mismatch_allowed`, or another the provider adds later. */
+        readonly type: Schema.String;
+        /** Why: `prefix_binding_mismatch`, `model_binding_mismatch`, `organization_binding_mismatch`. */
+        readonly reason: Schema.optionalKey<Schema.String>;
+    }>>>;
+}>;
+/** A stream's `message_start` event: its message carries the changes (the event itself too, read either way). */
+export declare const TransformedMessageStart: Schema.Struct<{
+    readonly type: Schema.Literal<"message_start">;
+    readonly input_transformations: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        /** `thinking_dropped`, `thinking_mismatch_allowed`, or another the provider adds later. */
+        readonly type: Schema.String;
+        /** Why: `prefix_binding_mismatch`, `model_binding_mismatch`, `organization_binding_mismatch`. */
+        readonly reason: Schema.optionalKey<Schema.String>;
+    }>>>;
+    readonly message: Schema.optionalKey<Schema.Struct<{
+        readonly input_transformations: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            /** `thinking_dropped`, `thinking_mismatch_allowed`, or another the provider adds later. */
+            readonly type: Schema.String;
+            /** Why: `prefix_binding_mismatch`, `model_binding_mismatch`, `organization_binding_mismatch`. */
+            readonly reason: Schema.optionalKey<Schema.String>;
+        }>>>;
+    }>>;
+}>;

package/dist/llm/thinking-binding.entity.functions.d.ts

@@ -0,0 +1,21 @@
+import { Option } from "effect";
+import type { InputTransformation, ThinkingPrefixMismatch } from "./thinking-binding.entity.js";
+/**
+ * An `anthropic-beta` header with `betas` added: the values it holds first,
+ * in order, then each new one once. Never a replacement: the client's own
+ * betas (structured outputs, the subscription's) stay.
+ */
+export declare const mergeBetas: (existing: Option.Option<string>, betas: ReadonlyArray<string>) => string;
+/** The binding a request to a model carries: none for a model that does not bind, or with `provider-default`. */
+export declare const bindingFor: (bindsThinking: boolean, mismatch: ThinkingPrefixMismatch) => Option.Option<Exclude<ThinkingPrefixMismatch, "provider-default">>;
+/** The reasons of the thinking blocks the provider dropped, one per block, in order. */
+export declare const droppedReasonsOf: (transformations: ReadonlyArray<InputTransformation>) => ReadonlyArray<string>;
+/** What a settled response's JSON body says the provider dropped; nothing when it is not that JSON. */
+export declare const droppedInBody: (body: string) => ReadonlyArray<string>;
+/**
+ * The first event of a server-sent stream, when `text` (the stream so far)
+ * holds it whole: its `data` lines joined. None until its blank line came.
+ */
+export declare const firstEventData: (text: string) => Option.Option<string>;
+/** What a stream's `message_start` data says the provider dropped (on the event or its message); nothing for another event. */
+export declare const droppedInMessageStart: (data: string) => ReadonlyArray<string>;

package/dist/llm/thinking-binding.entity.functions.js

@@ -0,0 +1,16 @@
+import { Option, Schema } from "effect";
+import { TransformedMessageStart, TransformedResponse } from "./thinking-binding.entity.js";
+export const mergeBetas = (existing, betas) => {
+  return [...Option.match(existing, { onNone: () => [], onSome: (value) => value.split(",").map((beta) => beta.trim()).filter((beta) => beta.length > 0) }), ...betas].filter((beta, index, all) => all.indexOf(beta) === index).join(",");
+}, bindingFor = (bindsThinking, mismatch) => bindsThinking && mismatch !== "provider-default" ? Option.some(mismatch) : Option.none(), droppedReasonsOf = (transformations) => transformations.filter((change) => change.type === "thinking_dropped").map((change) => change.reason ?? "unknown");
+const decodeResponse = Schema.decodeUnknownOption(Schema.fromJsonString(TransformedResponse)), decodeMessageStart = Schema.decodeUnknownOption(Schema.fromJsonString(TransformedMessageStart));
+export const droppedInBody = (body) => Option.match(decodeResponse(body), { onNone: () => [], onSome: (response) => droppedReasonsOf(response.input_transformations ?? []) }), firstEventData = (text) => {
+  const end = text.search(/\r?\n\r?\n/);
+  if (end < 0)
+    return Option.none();
+  return Option.some(text.slice(0, end).split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join(`
+`));
+}, droppedInMessageStart = (data) => Option.match(decodeMessageStart(data), {
+  onNone: () => [],
+  onSome: (event) => droppedReasonsOf([...event.input_transformations ?? [], ...event.message?.input_transformations ?? []])
+});

package/dist/llm/thinking-binding.entity.js

@@ -0,0 +1,11 @@
+import { Schema } from "effect";
+export const ThinkingPrefixMismatch = Schema.Literals(["provider-default", "drop_block", "error"]), THINKING_BINDING_BETA = "thinking-binding-controls-2026-08-01", InputTransformation = Schema.Struct({
+  type: Schema.String,
+  reason: Schema.optionalKey(Schema.String)
+}), TransformedResponse = Schema.Struct({
+  input_transformations: Schema.optionalKey(Schema.Array(InputTransformation))
+}), TransformedMessageStart = Schema.Struct({
+  type: Schema.Literal("message_start"),
+  input_transformations: Schema.optionalKey(Schema.Array(InputTransformation)),
+  message: Schema.optionalKey(TransformedResponse)
+});

package/dist/llm/utilityLlm.d.ts

@@ -1,8 +1,17 @@
 import { Layer } from "effect";
-import { AuthStore, SettingsStore, UtilityLlm } from "@xandreed/core";
+import { UtilityLlm } from "@xandreed/core";
+import { AuthStore } from "../ports/auth-store.port.js";
+import { SettingsStore } from "../ports/settings-store.port.js";
 /**
- * The fast helper tier: one-shot completions on `fastModel ?? model`. No
- * toolkit, no cache breakpoints, no loop — a title/digest call that can never
- * park a turn.
+ * The fast helper tier: one-shot completions on `fastModel ?? model`, at
+ * `fastReasoningEffort ?? reasoningEffort` (the fast role, as
+ * `roleModelView("fast")` reads it; a call policy the caller pinned wins).
+ * No toolkit or loop; a Messages helper prompt carries no automatic cache
+ * breakpoint, since a one-shot prompt is never read back.
+ * A helper completion cannot park a turn. Like the routed model, it reads
+ * its provider services once, where it is built: over a `ModelsTransport`,
+ * its calls go through it.
+ *
+ * @public
  */
-export declare const UtilityLlmLive: Layer.Layer<UtilityLlm, never, SettingsStore | AuthStore>;
+export declare const UtilityLlmLive: Layer.Layer<UtilityLlm, never, AuthStore | SettingsStore>;

package/dist/llm/utilityLlm.js

@@ -1,25 +1,30 @@
-import { Prompt } from "effect/ai";
+import { Prompt, Response } from "effect/ai";
 import { FetchHttpClient, HttpClient } from "effect/http";
-import { Effect, Layer, Option } from "effect";
-import { AuthStore, extractUsage, parseModelSelection, SettingsStore, UtilityError, UtilityLlm } from "@xandreed/core";
-import { generateWith } from "./router.js";
+import { Cause, Context, Effect, Layer, Option } from "effect";
+import { isTurnError, parseModelSelection, reasonOf, responseModelOf, UtilityCompletion, UtilityError, UtilityLlm } from "@xandreed/core";
+import { AuthStore } from "../ports/auth-store.port.js";
+import { SettingsStore } from "../ports/settings-store.port.js";
+import { extractUsage } from "@xandreed/core/internal";
+import { generateOver, layerProviderServices, throughTransport, withConfiguredEffort } from "./router.js";
+import { CurrentModelCallPurpose } from "../ports/model-call-completion.port.js";
 export const UtilityLlmLive = Layer.effect(UtilityLlm, Effect.gen(function* () {
-  const context = yield* Effect.context(), http = yield* HttpClient.HttpClient, settings = yield* SettingsStore;
+  const stores = Context.pick(AuthStore)(yield* Effect.context()), services = yield* layerProviderServices, http = yield* HttpClient.HttpClient, settings = yield* SettingsStore;
   return {
-    complete: (prompt) => Effect.gen(function* () {
-      const loaded = yield* settings.load.pipe(Effect.mapError((e) => new UtilityError({ message: e.message }))), raw = Option.getOrElse(Option.orElse(loaded.fastModel, () => loaded.model), () => ""), selection = yield* Option.match(parseModelSelection(raw), {
+    complete: Effect.fn("models.utility")(function* (prompt) {
+      const loaded = yield* settings.load.pipe(Effect.mapError((e) => new UtilityError({ message: e.message, cause: e }))), raw = Option.getOrElse(Option.orElse(loaded.fastModel, () => loaded.model), () => ""), selection = yield* Option.match(parseModelSelection(raw), {
         onNone: () => Effect.fail(new UtilityError({ message: "no fast/general model configured" })),
         onSome: Effect.succeed
-      }), res = yield* generateWith(selection, {
+      }), res = yield* withConfiguredEffort(generateOver(services)(selection, {
         prompt: Prompt.make(prompt),
         tools: [],
         toolChoice: "none",
         responseFormat: { type: "text" }
-      }).pipe(Effect.mapError((e) => new UtilityError({ message: String(e) })), Effect.provide(context), Effect.provideService(HttpClient.HttpClient, http));
-      return { text: res.content.flatMap((p) => {
-        const part = p;
-        return part.type === "text" ? [part.text ?? ""] : [];
-      }).join(""), usage: extractUsage(res.usage, res.content) };
+      }), Option.orElse(loaded.fastReasoningEffort, () => loaded.reasoningEffort)).pipe(Effect.provideService(CurrentModelCallPurpose, "Helper"), Effect.catch((error) => isTurnError(error) ? Effect.die(error) : Effect.fail(new UtilityError({ message: reasonOf(Cause.fail(error)), cause: error }))), throughTransport(services), Effect.provide(stores), Effect.provideService(HttpClient.HttpClient, http)), parts = res.content.filter(Response.isPart), text = parts.flatMap((part) => part.type === "text" ? [part.text] : []).join(""), model = Option.flatMap(responseModelOf(parts), parseModelSelection);
+      return new UtilityCompletion({
+        text,
+        usage: extractUsage(res.usage, parts),
+        ...Option.match(model, { onNone: () => ({}), onSome: (selection) => ({ model: selection }) })
+      });
     })
   };
 })).pipe(Layer.provide(FetchHttpClient.layer));

package/dist/plugin.adapter.d.ts

@@ -1,5 +1,23 @@
 import { LanguageModel } from "effect/ai";
-import { AuthStore, ModelCatalog, SessionEnvironment, SettingsError, SettingsStore, UtilityLlm } from "@xandreed/core";
+import { Config as EffectConfig, Redacted } from "effect";
+import { HarnessError, ModelCatalog, SessionEnvironment, UtilityLlm } from "@xandreed/core";
+import { AuthStore } from "./ports/auth-store.port.js";
+import { SettingsStore } from "./ports/settings-store.port.js";
+/**
+ * The models plugin: the routed `LanguageModel`, the fast `UtilityLlm`, the
+ * `ModelCatalog`, and the `AuthStore` and `SettingsStore` they read.
+ * Runtime-scoped: built once per `Agent.define`, so credentials, refreshed
+ * tokens and settings edits held in memory last across turns. A turn's own
+ * services win over it (a per-turn `LanguageModel` replaces the routed one).
+ * When a proxy applies (the `proxy` option, else the environment's
+ * `https_proxy` / `HTTPS_PROXY` and `http_proxy` / `HTTP_PROXY`), every call
+ * it makes (the providers, the OpenAI-compatible endpoints, OAuth token
+ * refreshes, the OpenAI subscription's WebSocket) goes through one
+ * `ModelsTransport`, the `noProxy` / `NO_PROXY` hosts and loopback direct;
+ * so do they through a host's own transport.
+ *
+ * @public
+ */
 export declare const modelsPlugin: import("@xandreed/core").TypedPlugin<{
     readonly model: string;
     readonly fastModel: string;
@@ -8,11 +26,76 @@ export declare const modelsPlugin: import("@xandreed/core").TypedPlugin<{
     readonly endpoints: {
         readonly [x: string]: {
             readonly url: string;
-            readonly apiKey?: string;
-            readonly apiKeyEnv?: string;
+            readonly images?: boolean;
+            readonly apiKey?: string | Redacted.Redacted<string>;
+            readonly api?: "chat-completions";
             readonly standardOnly?: boolean;
+            readonly apiKeyEnv?: string;
+        } | {
+            readonly url: string;
+            readonly api: "anthropic-messages";
+            readonly images?: boolean;
+            readonly apiKey?: string | Redacted.Redacted<string>;
+            readonly auth?: "x-api-key" | "bearer";
+            readonly apiKeyEnv?: string;
+            readonly cacheControl?: boolean;
+            readonly apiVersion?: string;
+            readonly betas?: readonly string[];
         };
     };
+    readonly modelSettings: {
+        readonly [x: string]: {
+            readonly effort?: "none" | "low" | "medium" | "high" | "xhigh" | "max";
+            readonly limits?: {
+                readonly maxOutputTokens?: number;
+                readonly contextWindow?: number;
+            };
+            readonly thinking?: {
+                readonly _tag: "Off";
+            } | {
+                readonly _tag: "Adaptive";
+                readonly display?: "omitted" | "summarized";
+            } | {
+                readonly _tag: "Budget";
+                readonly budgetTokens: number;
+                readonly display?: "omitted" | "summarized";
+            } | {
+                readonly _tag: "BetweenTools";
+            };
+            readonly promptCache?: {
+                readonly _tag: "Auto";
+                readonly ttl: "5m" | "1h";
+            } | {
+                readonly _tag: "TopLevel";
+                readonly ttl: "5m" | "1h";
+            } | {
+                readonly _tag: "Off";
+            };
+        };
+    };
+    readonly storage: "local" | "memory";
+    readonly credentials: {
+        readonly [x: string]: {
+            readonly type: "api_key";
+            readonly key: Redacted.Redacted<string>;
+        } | {
+            readonly type: "oauth";
+            readonly access: Redacted.Redacted<string>;
+            readonly refresh: Redacted.Redacted<string>;
+            readonly expires: number;
+            readonly accountId?: string & import("effect/Brand").Brand<"AccountId">;
+            readonly installationId?: string & import("effect/Brand").Brand<"InstallationId">;
+        } | {
+            readonly type: "local";
+            readonly baseUrl?: string;
+        };
+    };
+    readonly credentialEnv: {
+        readonly [x: string]: string;
+    };
+    readonly proxy: string | Redacted.Redacted<string>;
+    readonly noProxy: string;
+    readonly thinkingPrefixMismatch: "error" | "provider-default" | "drop_block";
 }, {
     readonly model: string;
     readonly fastModel: string;
@@ -21,10 +104,75 @@ export declare const modelsPlugin: import("@xandreed/core").TypedPlugin<{
     readonly endpoints: {
         readonly [x: string]: {
             readonly url: string;
-            readonly apiKey?: string;
-            readonly apiKeyEnv?: string;
+            readonly images?: boolean;
+            readonly apiKey?: string | Redacted.Redacted<string>;
+            readonly api?: "chat-completions";
             readonly standardOnly?: boolean;
+            readonly apiKeyEnv?: string;
+        } | {
+            readonly url: string;
+            readonly api: "anthropic-messages";
+            readonly images?: boolean;
+            readonly apiKey?: string | Redacted.Redacted<string>;
+            readonly auth?: "x-api-key" | "bearer";
+            readonly apiKeyEnv?: string;
+            readonly cacheControl?: boolean;
+            readonly apiVersion?: string;
+            readonly betas?: readonly string[];
         };
     };
-}, SettingsStore | AuthStore | ModelCatalog | UtilityLlm | LanguageModel.LanguageModel, SettingsError, SessionEnvironment>;
+    readonly modelSettings: {
+        readonly [x: string]: {
+            readonly effort?: "none" | "low" | "medium" | "high" | "xhigh" | "max";
+            readonly limits?: {
+                readonly maxOutputTokens?: number;
+                readonly contextWindow?: number;
+            };
+            readonly thinking?: {
+                readonly _tag: "Adaptive";
+                readonly display?: "omitted" | "summarized";
+            } | {
+                readonly _tag: "Budget";
+                readonly budgetTokens: number;
+                readonly display?: "omitted" | "summarized";
+            } | {
+                readonly _tag: "BetweenTools";
+            } | {
+                readonly _tag: "Off";
+            };
+            readonly promptCache?: {
+                readonly _tag: "Off";
+            } | {
+                readonly _tag: "Auto";
+                readonly ttl: "5m" | "1h";
+            } | {
+                readonly _tag: "TopLevel";
+                readonly ttl: "5m" | "1h";
+            };
+        };
+    };
+    readonly storage: "local" | "memory";
+    readonly credentials: {
+        readonly [x: string]: {
+            readonly type: "api_key";
+            readonly key: Redacted.Redacted<string>;
+        } | {
+            readonly type: "oauth";
+            readonly access: Redacted.Redacted<string>;
+            readonly refresh: Redacted.Redacted<string>;
+            readonly expires: number;
+            readonly accountId?: string;
+            readonly installationId?: string;
+        } | {
+            readonly type: "local";
+            readonly baseUrl?: string;
+        };
+    };
+    readonly credentialEnv: {
+        readonly [x: string]: string;
+    };
+    readonly proxy: string | Redacted.Redacted<string>;
+    readonly noProxy: string;
+    readonly thinkingPrefixMismatch: "error" | "provider-default" | "drop_block";
+}, ModelCatalog | UtilityLlm | LanguageModel.LanguageModel | AuthStore | SettingsStore, HarnessError | import("./index.js").AuthError | EffectConfig.ConfigError, SessionEnvironment>;
 export default modelsPlugin;

package/dist/plugin.adapter.js

@@ -1,27 +1,70 @@
 import { homedir } from "node:os";
 import { LanguageModel } from "effect/ai";
-import { Effect, Layer, Option, Schema } from "effect";
-import { AuthStore, definePlugin, EngineSettings, ModelCatalog, SessionEnvironment, SettingsError, SettingsStore, UtilityLlm } from "@xandreed/core";
+import { Config as EffectConfig, Context, Effect, Layer, Match, Option, Redacted, Schema } from "effect";
+import { definePlugin, HarnessError, ModelCatalog, SessionEnvironment, UtilityLlm } from "@xandreed/core";
+import { AuthStore } from "./ports/auth-store.port.js";
+import { EngineSettings, SettingsError, SettingsStore } from "./ports/settings-store.port.js";
+import { CredentialInputs } from "./auth/credential-input.entity.js";
+import { credentialsOf } from "./auth/credential-input.entity.functions.js";
 import { LocalAuthStoreLive } from "./auth/localAuth.js";
+import { MemoryAuthStoreLive } from "./auth/memory-auth.adapter.js";
 import { LanguageModelLive } from "./llm/router.js";
 import { UtilityLlmLive } from "./llm/utilityLlm.js";
 import { ConfiguredModelCatalogLive } from "./llm/modelCatalog.js";
 import { LocalSettingsStoreLive } from "./settings/localSettings.js";
+import { MemorySettingsStoreLive } from "./settings/memory-settings.adapter.js";
+import { HostCredentials } from "./ports/host-credentials.port.js";
 import { CurrentModelEndpoints, ModelEndpoints } from "./ports/model-endpoints.port.js";
-const Config = Schema.Struct({ model: Schema.String, fastModel: Schema.String, fallbackModel: Schema.String, inheritPrevious: Schema.Boolean, endpoints: ModelEndpoints });
+import { CurrentModelSettings } from "./ports/model-settings.port.js";
+import { ModelSettingsMap } from "./llm/model-settings.entity.js";
+import { CurrentThinkingPrefixMismatch } from "./ports/thinking-binding.port.js";
+import { ThinkingPrefixMismatch } from "./llm/thinking-binding.entity.js";
+import { CurrentManagedModelsTransport, ModelsTransport } from "./ports/models-transport.port.js";
+import { ProxyUrlOption } from "./transport/http-proxy.entity.js";
+import { modelsTransportContextFor } from "./transport/models-transport.adapter.js";
+const Config = Schema.Struct({
+  model: Schema.String,
+  fastModel: Schema.String,
+  fallbackModel: Schema.String,
+  inheritPrevious: Schema.Boolean,
+  endpoints: ModelEndpoints,
+  modelSettings: ModelSettingsMap,
+  storage: Schema.Literals(["local", "memory"]),
+  credentials: CredentialInputs,
+  credentialEnv: Schema.Record(Schema.String, Schema.String),
+  proxy: ProxyUrlOption,
+  noProxy: Schema.String,
+  thinkingPrefixMismatch: ThinkingPrefixMismatch
+}).annotate({ messageUnexpectedKey: "not an option of the models plugin" }).check(Schema.makeFilter((config) => config.storage === "memory" || Object.keys(config.credentials).length === 0 && Object.keys(config.credentialEnv).length === 0 ? void 0 : 'credentials and credentialEnv need storage: "memory"')), optional = (value) => value.length === 0 ? Option.none() : Option.some(value), overlaid = (config) => (previous) => new EngineSettings({
+  ...previous,
+  model: Option.orElse(optional(config.model), () => previous.model),
+  fastModel: Option.orElse(optional(config.fastModel), () => previous.fastModel),
+  fallbackModel: Option.orElse(optional(config.fallbackModel), () => previous.fallbackModel)
+}), memoryStores = (config) => Layer.unwrap(Effect.gen(function* () {
+  const fromEnv = yield* Effect.forEach(Object.entries(config.credentialEnv), ([provider, name]) => EffectConfig.option(EffectConfig.Redacted(name)).pipe(Effect.map(Option.map((key) => [provider, { type: "api_key", key }]))), { concurrency: 1 }), seed = new Map([...fromEnv.flatMap(Option.toArray), ...credentialsOf(config.credentials)]);
+  return Layer.mergeAll(MemoryAuthStoreLive(seed), MemorySettingsStoreLive(overlaid(config)(new EngineSettings({}))));
+})), readOnly = (what) => () => Effect.fail(new SettingsError({ message: `Edit the models plugin configuration to change ${what}` })), localStores = (config, workspace) => {
+  const home = homedir(), files = Effect.service(SettingsStore).pipe(Effect.provide(LocalSettingsStoreLive(workspace, home))), settings = Layer.effect(SettingsStore, Effect.map(files, (stored) => SettingsStore.of({
+    load: config.inheritPrevious ? Effect.map(stored.load, overlaid(config)) : Effect.succeed(overlaid(config)(new EngineSettings({}))),
+    setRole: readOnly("a model"),
+    set: readOnly("settings")
+  })));
+  return Layer.mergeAll(settings, LocalAuthStoreLive(workspace, home, ".efferent/runtime", config.inheritPrevious ? ".efferent" : void 0));
+}, optionError = (message) => new HarnessError({ code: "config.options", plugin: "@xandreed/plugin-models", message }), transportLayer = (config) => Effect.flatMap(Effect.serviceOption(ModelsTransport), Option.match({
+  onSome: (host) => Redacted.isRedacted(config.proxy) || config.proxy.length > 0 || config.noProxy.length > 0 ? Effect.fail(optionError("the host provides ModelsTransport, so the proxy and noProxy options would not apply: give the proxy to the host's transport")) : Effect.succeed(Layer.succeedContext(Context.make(ModelsTransport, host).pipe(Context.add(CurrentManagedModelsTransport, Option.none())))),
+  onNone: () => Effect.succeed(Layer.effectContext(modelsTransportContextFor({ proxy: config.proxy, noProxy: config.noProxy }).pipe(Effect.mapError((error) => optionError(error.message)))))
+}));
 export const modelsPlugin = definePlugin({
   id: "@xandreed/plugin-models",
-  version: "0.13.0",
+  version: "0.15.0",
+  scope: "runtime",
   config: Config,
-  defaults: { model: "", fastModel: "", fallbackModel: "", inheritPrevious: !0, endpoints: {} },
+  defaults: { model: "", fastModel: "", fallbackModel: "", inheritPrevious: !0, endpoints: {}, modelSettings: {}, storage: "local", credentials: {}, credentialEnv: {}, proxy: "", noProxy: "", thinkingPrefixMismatch: "drop_block" },
   requires: [SessionEnvironment],
+  optional: [HostCredentials, ModelsTransport],
   provides: [LanguageModel.LanguageModel, UtilityLlm, AuthStore, SettingsStore, ModelCatalog],
   layer: (config) => Layer.unwrap(Effect.gen(function* () {
-    const { workspace } = yield* SessionEnvironment, previous = config.inheritPrevious ? yield* SettingsStore.pipe(Effect.flatMap((settings) => settings.load), Effect.provide(LocalSettingsStoreLive(workspace, homedir()))) : new EngineSettings({}), optional = (value) => value.length === 0 ? Option.none() : Option.some(value), settings = Layer.succeed(SettingsStore, {
-      load: Effect.succeed(new EngineSettings({ ...previous, model: Option.orElse(optional(config.model), () => previous.model), fastModel: Option.orElse(optional(config.fastModel), () => previous.fastModel), fallbackModel: Option.orElse(optional(config.fallbackModel), () => previous.fallbackModel) })),
-      setRole: () => Effect.fail(new SettingsError({ message: "Edit the models plugin configuration to change a model" })),
-      set: () => Effect.fail(new SettingsError({ message: "Edit the models plugin configuration to change settings" }))
-    }), base = Layer.mergeAll(settings, LocalAuthStoreLive(workspace, homedir(), ".efferent/runtime", config.inheritPrevious ? ".efferent" : void 0), Layer.succeed(CurrentModelEndpoints, config.endpoints));
+    const { workspace } = yield* SessionEnvironment, host = yield* Effect.serviceOption(HostCredentials), stores = yield* Match.value(config.storage).pipe(Match.when("memory", () => Effect.succeed(memoryStores(config))), Match.when("local", () => Option.isSome(host) ? Effect.fail(optionError('the host provides HostCredentials, which needs storage: "memory"')) : Effect.succeed(localStores(config, workspace))), Match.exhaustive), transport = yield* transportLayer(config), base = Layer.mergeAll(stores, Layer.succeed(CurrentModelEndpoints, config.endpoints), Layer.succeed(CurrentModelSettings, config.modelSettings), Layer.succeed(CurrentThinkingPrefixMismatch, config.thinkingPrefixMismatch)).pipe(Layer.provideMerge(transport));
     return Layer.mergeAll(LanguageModelLive, UtilityLlmLive, ConfiguredModelCatalogLive).pipe(Layer.provideMerge(base));
   }))
 });