@xandreed/plugin-models 0.14.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";
+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 - 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, reading, 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), reading)
+    reason,
+    usage: usageFromCompletion(Option.getOrElse(closed.usage, () => ({})), reading)
   };
   return [
     { ...closed, flushed: !0 },
     [...closeParts, ...toolParts, finish]
   ];
-}), DONE = "[DONE]", step = (moduleName, reading, state, payload) => payload === DONE ? flush(moduleName, reading, 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, options.usage ?? {}, 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. Built over a `ModelsTransport`, its calls go through it.
+ * 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, replayableContext, SettingsStore, UtilityError, UtilityLlm } from "@xandreed/core";
-import { generateWith, transportFetchOf } 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 = replayableContext(yield* Effect.context()), http = yield* HttpClient.HttpClient, fetch = yield* transportFetchOf, 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) })), (call) => Option.match(fetch, { onNone: () => call, onSome: (value) => Effect.provideService(call, FetchHttpClient.Fetch, value) }), 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,6 +1,8 @@
 import { LanguageModel } from "effect/ai";
 import { Config as EffectConfig, Redacted } from "effect";
-import { AuthStore, HarnessError, ModelCatalog, SessionEnvironment, SettingsStore, UtilityLlm } from "@xandreed/core";
+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.
@@ -13,6 +15,8 @@ import { AuthStore, HarnessError, ModelCatalog, SessionEnvironment, SettingsStor
  * 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;
@@ -24,8 +28,49 @@ export declare const modelsPlugin: import("@xandreed/core").TypedPlugin<{
             readonly url: string;
             readonly images?: boolean;
             readonly apiKey?: string | Redacted.Redacted<string>;
-            readonly apiKeyEnv?: 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";
@@ -38,8 +83,8 @@ export declare const modelsPlugin: import("@xandreed/core").TypedPlugin<{
             readonly access: Redacted.Redacted<string>;
             readonly refresh: Redacted.Redacted<string>;
             readonly expires: number;
-            readonly accountId?: string;
-            readonly installationId?: string;
+            readonly accountId?: string & import("effect/Brand").Brand<"AccountId">;
+            readonly installationId?: string & import("effect/Brand").Brand<"InstallationId">;
         } | {
             readonly type: "local";
             readonly baseUrl?: string;
@@ -50,6 +95,7 @@ export declare const modelsPlugin: import("@xandreed/core").TypedPlugin<{
     };
     readonly proxy: string | Redacted.Redacted<string>;
     readonly noProxy: string;
+    readonly thinkingPrefixMismatch: "error" | "provider-default" | "drop_block";
 }, {
     readonly model: string;
     readonly fastModel: string;
@@ -60,8 +106,49 @@ export declare const modelsPlugin: import("@xandreed/core").TypedPlugin<{
             readonly url: string;
             readonly images?: boolean;
             readonly apiKey?: string | Redacted.Redacted<string>;
-            readonly apiKeyEnv?: 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: "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";
@@ -86,5 +173,6 @@ export declare const modelsPlugin: import("@xandreed/core").TypedPlugin<{
     };
     readonly proxy: string | Redacted.Redacted<string>;
     readonly noProxy: string;
-}, SettingsStore | AuthStore | ModelCatalog | UtilityLlm | LanguageModel.LanguageModel, HarnessError | import("@xandreed/core").AuthError | EffectConfig.ConfigError, SessionEnvironment>;
+    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,7 +1,9 @@
 import { homedir } from "node:os";
 import { LanguageModel } from "effect/ai";
 import { Config as EffectConfig, Context, Effect, Layer, Match, Option, Redacted, Schema } from "effect";
-import { AuthStore, definePlugin, EngineSettings, HarnessError, ModelCatalog, SessionEnvironment, SettingsError, SettingsStore, UtilityLlm } from "@xandreed/core";
+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";
@@ -13,27 +15,33 @@ 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";
-import { ModelsTransport } from "./ports/models-transport.port.js";
+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 { modelsTransportFor } from "./transport/models-transport.adapter.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
+  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: Redacted.value(key) }])))), seed = new Map([...fromEnv.flatMap(Option.toArray), ...credentialsOf(config.credentials)]);
+  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({
@@ -43,23 +51,20 @@ const Config = Schema.Struct({
   })));
   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.succeed(ModelsTransport, host)),
-  onNone: () => Effect.succeed(Layer.effectContext(modelsTransportFor({ proxy: config.proxy, noProxy: config.noProxy }).pipe(Effect.map(Option.match({
-    onNone: () => Context.empty(),
-    onSome: (transport) => Context.make(ModelsTransport, transport)
-  })), Effect.mapError((error) => optionError(error.message)))))
+  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.14.0",
+  version: "0.15.0",
   scope: "runtime",
   config: Config,
-  defaults: { model: "", fastModel: "", fallbackModel: "", inheritPrevious: !0, endpoints: {}, storage: "local", credentials: {}, credentialEnv: {}, proxy: "", noProxy: "" },
+  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, 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)).pipe(Layer.provideMerge(transport));
+    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));
   }))
 });

package/dist/ports/auth-store.port.d.ts

@@ -0,0 +1,73 @@
+import { Context, Option, Schema } from "effect";
+import type { Effect, Redacted } from "effect";
+import type { ProviderId } from "@xandreed/core";
+/**
+ * A stored provider credential: a raw API key, an OAuth subscription (with
+ * refresh material and absolute expiry, epoch ms), or a local provider that
+ * needs no key. Its secrets (`key`, `access`, `refresh`) are `Redacted`, so
+ * they print as `<redacted>` in errors, logs and fingerprints; unwrap one
+ * with `Redacted.value` only where a request is built. The encoded form is
+ * the on-disk `auth.json` vocabulary the previous line established, secrets
+ * in the clear, so existing credentials keep working. Store a credential
+ * through `Schema.encodeEffect(Credential)`, never `JSON.stringify`, which
+ * writes `"<redacted>"` in place of each secret.
+ *
+ * @public
+ */
+export declare const Credential: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"api_key">;
+    readonly key: Schema.RedactedFromValue<Schema.String>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"oauth">;
+    readonly access: Schema.RedactedFromValue<Schema.String>;
+    readonly refresh: Schema.RedactedFromValue<Schema.String>;
+    readonly expires: Schema.Number;
+    readonly accountId: Schema.optionalKey<Schema.String>;
+    readonly installationId: Schema.optionalKey<Schema.String>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"local">;
+    readonly baseUrl: Schema.optionalKey<Schema.String>;
+}>]>;
+export type Credential = typeof Credential.Type;
+declare const AuthError_base: Schema.Class<AuthError, Schema.TaggedStruct<"AuthError", {
+    readonly provider: Schema.String;
+    readonly message: Schema.String;
+    /**
+     * `auth.corrupt`: the store's backing data could not be read or decoded.
+     * Nothing was read as absent and nothing was written over it.
+     */
+    readonly code: Schema.optionalKey<Schema.Literal<"auth.corrupt">>;
+}>, import("effect/Cause").YieldableError>;
+export declare class AuthError extends AuthError_base {
+}
+declare const AuthStore_base: Context.ServiceClass<AuthStore, "@xandreed/core/AuthStore", {
+    readonly all: Effect.Effect<ReadonlyMap<string, Credential>, AuthError>;
+    readonly get: (p: ProviderId) => Effect.Effect<Option.Option<Credential>, AuthError>;
+    readonly resolveKey: (p: ProviderId) => Effect.Effect<Option.Option<Redacted.Redacted<string>>, AuthError>;
+    /** Persist a credential (a login). */
+    readonly set: (p: ProviderId, credential: Credential) => Effect.Effect<void, AuthError>;
+    /** Remove a provider's credential everywhere it is stored (a logout). */
+    readonly remove: (p: ProviderId) => Effect.Effect<void, AuthError>;
+}>;
+/**
+ * The credential store, read lazily per request: `resolveKey` returns a
+ * usable secret (refreshing a near-expiry OAuth token first, and persisting
+ * it where the store keeps credentials), so a credential added mid-session
+ * takes effect on the next call with no restart. `None` means the provider
+ * is not configured. Every secret it hands out, through `get` and `all` as
+ * through `resolveKey`, is `Redacted`.
+ *
+ * One refresh of a credential runs at a time: concurrent calls on one
+ * expired token send one token request and share its result. A `set` or
+ * `remove` made while that request is in flight wins over the refreshed
+ * token. A store whose backing data cannot be read or decoded fails every
+ * call with an `AuthError` of code `auth.corrupt` instead of reading it as
+ * empty, so no write replaces credentials it could not read.
+ * `authStoreConformance` (`@xandreed/plugin-models/conformance`) checks a
+ * store against this contract. Its key stays `@xandreed/core/AuthStore`, the
+ * package it was first declared in: plugins' `provides` and hosts' bindings
+ * name it, so it never changes.
+ */
+export declare class AuthStore extends AuthStore_base {
+}
+export {};

package/dist/ports/auth-store.port.js

@@ -0,0 +1,24 @@
+import { Context, Option, Schema } from "effect";
+const Secret = Schema.RedactedFromValue(Schema.String);
+export const Credential = Schema.Union([
+  Schema.Struct({ type: Schema.Literal("api_key"), key: Secret }),
+  Schema.Struct({
+    type: Schema.Literal("oauth"),
+    access: Secret,
+    refresh: Secret,
+    expires: Schema.Number,
+    accountId: Schema.optionalKey(Schema.String),
+    installationId: Schema.optionalKey(Schema.String)
+  }),
+  Schema.Struct({ type: Schema.Literal("local"), baseUrl: Schema.optionalKey(Schema.String) })
+]);
+
+export class AuthError extends Schema.TaggedError()("AuthError", {
+  provider: Schema.String,
+  message: Schema.String,
+  code: Schema.optionalKey(Schema.Literal("auth.corrupt"))
+}) {
+}
+
+export class AuthStore extends Context.Service()("@xandreed/core/AuthStore") {
+}