@xandreed/plugin-models 0.4.0 → 0.8.0-next.0

package/README.md

@@ -1,5 +1,5 @@
 # @xandreed/plugin-models
 
-Efferent composable agent framework, 0.4.0. Bun on Linux.
+Efferent composable agent framework, 0.8.0-next.0. Bun on Linux.
 
 Documentation: https://github.com/xandreeddev/efferent

package/dist/auth/anthropicOAuth.js

@@ -63,7 +63,7 @@ export const generatePkce = Effect.promise(async () => {
   code_verifier: verifier,
   state: verifier
 }, "code exchange");
-const fromNullableTrimmed = (value) => Option.filter(Option.fromNullable(value), (v) => v.trim().length > 0);
+const fromNullableTrimmed = (value) => Option.filter(Option.fromNullishOr(value), (v) => v.trim().length > 0);
 export const parseAuthorizationInput = (input) => {
   const value = input.trim();
   if (value.length === 0)

package/dist/auth/localAuth.js

@@ -55,7 +55,7 @@ export const authPaths = (cwd, home, directory = ".efferent") => [
     }),
     get: (provider) => Effect.gen(function* () {
       const files = yield* Effect.forEach(paths, readAuthFile), merged = new Map(files.flatMap((f) => [...f.entries]));
-      return Option.fromNullable(merged.get(provider));
+      return Option.fromNullishOr(merged.get(provider));
     }),
     resolveKey: (provider) => Effect.gen(function* () {
       const holder = [...yield* Effect.forEach(paths, readAuthFile)].reverse().find((f) => f.entries.has(provider)), cred = holder?.entries.get(provider);

package/dist/auth/openAiCodexOAuth.js

@@ -1,4 +1,4 @@
-import { Effect, Either, Option } from "effect";
+import { Effect, Result, Option } from "effect";
 import { AuthError } from "@xandreed/core";
 import { generatePkce } from "./anthropicOAuth.js";
 export const OPENAI_CODEX_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
@@ -10,12 +10,12 @@ const SCOPE = "openid profile email offline_access", ACCOUNT_CLAIM = "https://ap
 };
 export const openAiCodexAccountId = (accessToken) => {
   const segment = accessToken.split(".")[1];
-  return Option.flatMap(Option.fromNullable(segment), (encoded) => Option.flatMap(Either.getRight(Either.try(() => base64UrlJson(encoded))), (payload) => {
+  return Option.flatMap(Option.fromNullishOr(segment), (encoded) => Option.flatMap(Result.getSuccess(Result.try(() => base64UrlJson(encoded))), (payload) => {
     const claim = payload[ACCOUNT_CLAIM];
     if (typeof claim !== "object" || claim === null)
       return Option.none();
     const accountId = claim.chatgpt_account_id;
-    return Option.filter(Option.fromNullable(typeof accountId === "string" ? accountId : void 0), (value) => value.length > 0);
+    return Option.filter(Option.fromNullishOr(typeof accountId === "string" ? accountId : void 0), (value) => value.length > 0);
   }));
 };
 const postToken = (body, stage) => Effect.tryPromise({

package/dist/llm/compat.d.ts

@@ -1,5 +1,5 @@
-import { AiError, LanguageModel, Tool } from "@effect/ai";
-import type { Prompt } from "@effect/ai";
+import { AiError, LanguageModel, Tool } from "effect/ai";
+import type { Prompt } from "effect/ai";
 import { Effect } from "effect";
 import type { CompletionUsage } from "./sse.js";
 /**
@@ -28,6 +28,10 @@ export interface CompatConfig {
     /** Gateway reasoning vocabulary, independent of provider-native thinking. */
     readonly reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
     readonly temperature?: number;
+    /** Send standard chat-completions fields only — no prompt-cache key,
+     *  thinking defaults or call policy — for endpoints that reject the
+     *  gateway extensions (Gemini's OpenAI-compatible API). */
+    readonly standardOnly?: boolean;
     /** Injectable for tests; defaults to global fetch. */
     readonly fetchImpl?: typeof fetch;
     /** Host-owned admission (e.g. reserve a worst-case cost) before every call. */
@@ -73,5 +77,5 @@ interface ChatCompletion {
 }
 /** Parse one non-streaming completion into `@effect/ai` encoded parts. */
 export declare const fromChatCompletion: (moduleName: string, body: ChatCompletion) => Effect.Effect<ReadonlyArray<unknown>, AiError.AiError>;
-export declare const makeCompatLanguageModel: (config: CompatConfig) => Effect.Effect<LanguageModel.Service>;
+export declare const makeCompatLanguageModel: (config: CompatConfig) => Effect.Effect<LanguageModel.LanguageModel>;
 export {};

package/dist/llm/compat.js

@@ -1,32 +1,28 @@
-import { AiError, LanguageModel, Tool } from "@effect/ai";
-import { Effect, Either, FiberRef, JSONSchema, Option, Stream } from "effect";
-import { CurrentModelCallPolicy, CurrentPromptCacheKey } from "@xandreed/core";
+import { AiError, LanguageModel, Tool } from "effect/ai";
+import { Effect, Result, Option, Stream } from "effect";
+import { CurrentModelCallPolicy, CurrentPromptCacheKey, describeModel, strictJsonSchema, toolParametersSchema } from "@xandreed/core";
 import { finishReasonFromWire, sseStreamParts, usageFromCompletion } from "./sse.js";
-const record = (value) => typeof value === "object" && value !== null ? value : {}, semanticGatewayError = (moduleName, method, body) => Option.flatMap(Option.fromNullable(Either.getOrUndefined(Either.try(() => JSON.parse(body)))), (decoded) => {
+const record = (value) => typeof value === "object" && value !== null ? value : {}, semanticGatewayError = (moduleName, method, body) => Option.flatMap(Option.fromNullishOr(Result.getOrUndefined(Result.try(() => JSON.parse(body)))), (decoded) => {
   const error = record(record(decoded).error), type = typeof error.type === "string" ? error.type : "", message = typeof error.message === "string" ? error.message : "";
   if (type === "ModelError" || /model .*not supported/i.test(message))
-    return Option.some(new AiError.MalformedInput({
+    return Option.some(AiError.make({
       module: moduleName,
       method,
-      description: message.length > 0 ? message : "the selected model is not supported"
+      reason: new AiError.InvalidRequestError({
+        description: message.length > 0 ? message : "the selected model is not supported"
+      })
     }));
   if (type === "CreditsError" || /insufficient (?:balance|credits)|usage limit|quota/i.test(message))
-    return Option.some(new AiError.UnknownError({
+    return Option.some(AiError.make({
       module: moduleName,
       method,
-      description: `CreditsError: ${message || "provider quota exhausted"}`
+      reason: new AiError.UnknownError({ description: `CreditsError: ${message || "provider quota exhausted"}` })
     }));
   return Option.none();
-}), aiUnknown = (moduleName, method, e) => new AiError.UnknownError({
-  module: moduleName,
-  method,
-  description: String(e),
-  cause: e
-}), requestInfo = (chatUrl) => ({
+}), aiUnknown = (moduleName, method, e) => AiError.make({ module: moduleName, method, reason: new AiError.UnknownError({ description: String(e) }) }), invalidOutput = (moduleName, method, description) => AiError.make({ module: moduleName, method, reason: new AiError.InvalidOutputError({ description }) }), requestInfo = (chatUrl) => ({
   method: "POST",
   url: chatUrl,
   urlParams: [],
-  hash: Option.none(),
   headers: { "content-type": "application/json" }
 });
 export const toChatMessages = (prompt) => prompt.content.flatMap((message) => {
@@ -63,7 +59,7 @@ export const toChatMessages = (prompt) => prompt.content.flatMap((message) => {
     function: {
       name: tool.name,
       description: Tool.getDescription(tool),
-      parameters: Tool.getJsonSchema(tool)
+      parameters: toolParametersSchema(tool)
     }
   }
 ] : []);
@@ -88,11 +84,7 @@ export const thinkingParams = (model) => {
 }, fromChatCompletion = (moduleName, body) => Effect.gen(function* () {
   const choice = body.choices?.[0];
   if (choice === void 0)
-    return yield* Effect.fail(new AiError.MalformedOutput({
-      module: moduleName,
-      method: "generateText",
-      description: "the completion carried no choices"
-    }));
+    return yield* Effect.fail(invalidOutput(moduleName, "generateText", "the completion carried no choices"));
   const message = choice.message ?? {}, reasoning = message.reasoning_content ?? message.reasoning, text = message.content, toolCalls = yield* Effect.forEach(message.tool_calls ?? [], (tc) => Effect.try({
     try: () => ({
       type: "tool-call",
@@ -100,11 +92,7 @@ export const thinkingParams = (model) => {
       name: tc.function?.name ?? "",
       params: JSON.parse(tc.function?.arguments ?? "{}")
     }),
-    catch: () => new AiError.MalformedOutput({
-      module: moduleName,
-      method: "generateText",
-      description: `tool call ${tc.function?.name ?? "?"} carried unparseable JSON arguments`
-    })
+    catch: () => invalidOutput(moduleName, "generateText", `tool call ${tc.function?.name ?? "?"} carried unparseable JSON arguments`)
   }));
   return [
     ...reasoning !== null && reasoning !== void 0 && reasoning.length > 0 ? [{ type: "reasoning", text: reasoning }] : [],
@@ -117,22 +105,10 @@ export const thinkingParams = (model) => {
     }
   ];
 });
-const chatRequestBody = (config, options, streaming) => Effect.all({ cacheKey: FiberRef.get(CurrentPromptCacheKey), policy: FiberRef.get(CurrentModelCallPolicy) }).pipe(Effect.map(({ cacheKey, policy }) => {
-  const tools = toChatTools(options.tools);
-  return {
-    model: config.model,
-    ...config.temperature === void 0 ? {} : { temperature: config.temperature },
-    messages: toChatMessages(options.prompt),
-    stream: streaming,
-    ...options.responseFormat.type === "json" ? { response_format: {
-      type: "json_schema",
-      json_schema: { name: options.responseFormat.objectName, strict: !0, schema: JSONSchema.make(options.responseFormat.schema) }
-    } } : {},
-    ...streaming ? { stream_options: { include_usage: !0 } } : {},
-    ...Option.match(cacheKey, {
-      onNone: () => ({}),
-      onSome: (key) => ({ prompt_cache_key: key })
-    }),
+const requestSettings = (config, cacheKey, policy) => ({
+  sampling: config.temperature === void 0 ? {} : { temperature: config.temperature },
+  extensions: config.standardOnly === !0 ? {} : {
+    ...Option.match(cacheKey, { onNone: () => ({}), onSome: (key) => ({ prompt_cache_key: key }) }),
     ...config.thinking === void 0 ? thinkingParams(config.model) : { thinking: { type: config.thinking } },
     ...config.reasoningEffort === void 0 ? {} : { reasoning: { effort: config.reasoningEffort } },
     ...Option.match(policy, {
@@ -141,11 +117,25 @@ const chatRequestBody = (config, options, streaming) => Effect.all({ cacheKey: F
         ...value.maxOutputTokens === void 0 ? {} : { max_tokens: value.maxOutputTokens },
         ...config.thinking === "disabled" || config.reasoningEffort !== void 0 ? {} : { reasoning_effort: value.effort }
       })
-    }),
+    })
+  }
+}), chatRequestBody = (config, options, streaming) => Effect.all({ cacheKey: Effect.service(CurrentPromptCacheKey), policy: Effect.service(CurrentModelCallPolicy) }).pipe(Effect.map(({ cacheKey, policy }) => {
+  const tools = toChatTools(options.tools), settings = requestSettings(config, cacheKey, policy);
+  return {
+    model: config.model,
+    ...settings.sampling,
+    messages: toChatMessages(options.prompt),
+    stream: streaming,
+    ...options.responseFormat.type === "json" ? { response_format: {
+      type: "json_schema",
+      json_schema: { name: options.responseFormat.objectName, strict: !0, schema: strictJsonSchema(options.responseFormat.schema) }
+    } } : {},
+    ...streaming ? { stream_options: { include_usage: !0 } } : {},
+    ...settings.extensions,
     ...tools.length > 0 ? { tools, tool_choice: toToolChoice(options.toolChoice) } : {}
   };
 })), postChat = (config, method, body, buffered = !1) => {
-  const request = (config.beforeRequest?.(body) ?? Effect.void).pipe(Effect.zipRight(Effect.tryPromise({
+  const request = (config.beforeRequest?.(body) ?? Effect.void).pipe(Effect.andThen(Effect.tryPromise({
     try: async (signal) => {
       const response = await (config.fetchImpl ?? fetch)(config.chatUrl, {
         signal,
@@ -172,13 +162,14 @@ const chatRequestBody = (config, options, streaming) => Effect.all({ cacheKey: F
   res.headers.forEach((value, headerName) => {
     headers[headerName] = value;
   });
-  return yield* Effect.fail(new AiError.HttpResponseError({
+  return yield* Effect.fail(AiError.make({
     module: config.moduleName,
     method,
-    reason: "StatusCode",
-    request: requestInfo(config.chatUrl),
-    response: { status: res.status, headers },
-    description: text.slice(0, 500)
+    reason: AiError.reasonFromHttpStatus({
+      status: res.status,
+      http: { request: requestInfo(config.chatUrl), response: { status: res.status, headers }, body: text.slice(0, 500) },
+      description: text.slice(0, 500)
+    })
   }));
 });
 export const makeCompatLanguageModel = (config) => LanguageModel.make({
@@ -191,11 +182,7 @@ export const makeCompatLanguageModel = (config) => LanguageModel.make({
       catch: (e) => aiUnknown(config.moduleName, "generateText", e)
     }), parsed = yield* Effect.try({
       try: () => JSON.parse(text),
-      catch: () => new AiError.MalformedOutput({
-        module: config.moduleName,
-        method: "generateText",
-        description: `the completion body was not JSON: ${text.slice(0, 200)}`
-      })
+      catch: () => invalidOutput(config.moduleName, "generateText", `the completion body was not JSON: ${text.slice(0, 200)}`)
     });
     return yield* fromChatCompletion(config.moduleName, parsed);
   }),
@@ -205,11 +192,10 @@ export const makeCompatLanguageModel = (config) => LanguageModel.make({
       return yield* failStatus(config, "streamText", res);
     const body = res.body;
     if (body === null)
-      return yield* Effect.fail(new AiError.MalformedOutput({
-        module: config.moduleName,
-        method: "streamText",
-        description: "the streaming response carried no body"
-      }));
+      return yield* Effect.fail(invalidOutput(config.moduleName, "streamText", "the streaming response carried no body"));
     return sseStreamParts({ moduleName: config.moduleName, body });
   }))
-});
+}).pipe(Effect.map((model) => describeModel(model, Effect.all({ cacheKey: Effect.service(CurrentPromptCacheKey), policy: Effect.service(CurrentModelCallPolicy) }).pipe(Effect.map(({ cacheKey, policy }) => {
+  const settings = requestSettings(config, cacheKey, policy);
+  return { provider: config.moduleName, model: config.model, settings: { ...settings.sampling, ...settings.extensions } };
+})))));

package/dist/llm/openAiCodex.d.ts

@@ -1,6 +1,6 @@
-import { LanguageModel } from "@effect/ai";
-import { HttpClient } from "@effect/platform";
-import { Effect, Redacted, Stream } from "effect";
+import { LanguageModel } from "effect/ai";
+import { HttpClient } from "effect/http";
+import { Effect, Redacted } from "effect";
 export declare const OPENAI_CODEX_API_URL = "https://chatgpt.com/backend-api/codex";
 type Json = Record<string, unknown>;
 /** Translate the standard Responses request into the Codex subscription dialect. */
@@ -10,9 +10,5 @@ export declare const makeOpenAiCodexLanguageModel: (args: {
     readonly model: string;
     readonly accessToken: Redacted.Redacted<string>;
     readonly accountId: string;
-}) => Effect.Effect<{
-    streamText: <Options extends import("effect/Types").NoExcessProperties<LanguageModel.GenerateTextOptions<any>, Options>, Tools extends Record<string, import("@effect/ai/Tool").Any> = {}>(options: Options & LanguageModel.GenerateTextOptions<Tools>) => Stream.Stream<import("@effect/ai/Response").StreamPart<Tools>, LanguageModel.ExtractError<Options>, LanguageModel.ExtractContext<Options>>;
-    generateText: LanguageModel.Service["generateText"];
-    generateObject: <A, I extends Record<string, unknown>, R, Options extends import("effect/Types").NoExcessProperties<LanguageModel.GenerateObjectOptions<any, A, I, R>, Options>, Tools extends Record<string, import("@effect/ai/Tool").Any> = {}>(options: Options & LanguageModel.GenerateObjectOptions<Tools, A, I, R>) => Effect.Effect<LanguageModel.GenerateObjectResponse<Tools, A>, LanguageModel.ExtractError<Options>, R | LanguageModel.ExtractContext<Options>>;
-}, never, import("effect/Scope").Scope | HttpClient.HttpClient>;
+}) => Effect.Effect<LanguageModel.LanguageModel, never, HttpClient.HttpClient>;
 export {};

package/dist/llm/openAiCodex.js

@@ -1,8 +1,8 @@
-import { AiError, LanguageModel } from "@effect/ai";
+import { AiError, LanguageModel } from "effect/ai";
 import { OpenAiClient, OpenAiLanguageModel } from "@effect/ai-openai";
-import { HttpClient, HttpClientRequest } from "@effect/platform";
-import { Effect, Either, FiberRef, Option, Redacted, Stream } from "effect";
-import { CurrentModelCallPolicy, CurrentPromptCacheKey, foldStreamParts } from "@xandreed/core";
+import { HttpClient, HttpClientRequest } from "effect/http";
+import { Effect, Result, Option, Redacted, Stream } from "effect";
+import { CurrentModelCallPolicy, CurrentPromptCacheKey, describeModel, foldStreamParts } from "@xandreed/core";
 import { OpenAiCodexWebSocketHttpClient } from "./openAiCodexWebSocket.js";
 export const OPENAI_CODEX_API_URL = "https://chatgpt.com/backend-api/codex";
 const record = (value) => typeof value === "object" && value !== null ? value : {}, instructionText = (message) => {
@@ -46,27 +46,26 @@ const transformRequest = (accountId, reasoningEffort) => (request) => {
   if (request.body._tag !== "Uint8Array")
     return withHeaders;
   const encodedBody = request.body.body;
-  return Option.match(Either.getRight(Either.try(() => JSON.parse(new TextDecoder().decode(encodedBody)))), {
+  return Option.match(Result.getSuccess(Result.try(() => JSON.parse(new TextDecoder().decode(encodedBody)))), {
     onNone: () => withHeaders,
-    onSome: (decoded) => HttpClientRequest.bodyUnsafeJson(withHeaders, toOpenAiCodexRequestBody(decoded, reasoningEffort))
+    onSome: (decoded) => HttpClientRequest.bodyJsonUnsafe(withHeaders, toOpenAiCodexRequestBody(decoded, reasoningEffort))
   });
-}, responseStatus = (error) => {
-  const value = record(error), response = record(value.response);
-  return typeof response.status === "number" ? response.status : void 0;
-};
-export const mapOpenAiCodexError = (model, error) => responseStatus(error) === 404 ? new AiError.MalformedInput({
+}, responseStatus = (error) => AiError.isAiError(error) && ("http" in error.reason) ? error.reason.http?.response?.status : void 0;
+export const mapOpenAiCodexError = (model, error) => responseStatus(error) === 404 ? AiError.make({
   module: "OpenAiCodex",
   method: "responses",
-  description: `model ${model} is not available to the configured ChatGPT subscription account`,
-  cause: error
-}) : responseStatus(error) === 200 ? new AiError.MalformedOutput({
+  reason: new AiError.InvalidRequestError({
+    description: `model ${model} is not available to the configured ChatGPT subscription account`
+  })
+}) : responseStatus(error) === 200 ? AiError.make({
   module: "OpenAiCodex",
   method: "responses",
-  description: `the ${model} subscription stream returned a rejected or incompatible event`,
-  cause: error
+  reason: new AiError.InvalidOutputError({
+    description: `the ${model} subscription stream returned a rejected or incompatible event`
+  })
 }) : error, makeOpenAiCodexLanguageModel = (args) => Effect.all({
-  cacheKey: FiberRef.get(CurrentPromptCacheKey),
-  policy: FiberRef.get(CurrentModelCallPolicy)
+  cacheKey: Effect.service(CurrentPromptCacheKey),
+  policy: Effect.service(CurrentModelCallPolicy)
 }).pipe(Effect.flatMap(({ cacheKey, policy }) => OpenAiClient.make({
   apiKey: args.accessToken,
   apiUrl: OPENAI_CODEX_API_URL,
@@ -74,7 +73,7 @@ export const mapOpenAiCodexError = (model, error) => responseStatus(error) === 4
 }).pipe(Effect.flatMap((client) => OpenAiLanguageModel.make({
   model: args.model,
   config: {
-    strict: !1,
+    strictJsonSchema: !1,
     store: !1,
     prompt_cache_key: Option.getOrElse(cacheKey, () => "efferent"),
     text: { verbosity: "low" },
@@ -90,10 +89,21 @@ export const mapOpenAiCodexError = (model, error) => responseStatus(error) === 4
     })
   }
 }).pipe(Effect.provideService(OpenAiClient.OpenAiClient, client))), Effect.map((streaming) => {
-  const streamText = (options) => streaming.streamText(options).pipe(Stream.mapError((error) => mapOpenAiCodexError(args.model, error)));
-  return {
+  const streamText = (options) => streaming.streamText(options).pipe(Stream.mapError((error) => mapOpenAiCodexError(args.model, error))), model = {
     ...streaming,
     streamText,
     generateText: (options) => foldStreamParts(streamText(options), () => Effect.void).pipe(Effect.map((turn) => new LanguageModel.GenerateTextResponse(turn.content)))
   };
+  return describeModel(model, {
+    provider: "openai-codex",
+    model: args.model,
+    settings: {
+      strictJsonSchema: !1,
+      store: !1,
+      stream: !0,
+      prompt_cache_key: Option.getOrElse(cacheKey, () => "efferent"),
+      text: { verbosity: "low" },
+      ...Option.match(policy, { onNone: () => ({}), onSome: (value) => ({ reasoning: { effort: value.effort, summary: "auto" } }) })
+    }
+  });
 }))));

package/dist/llm/openAiCodexWebSocket.d.ts

@@ -1,4 +1,4 @@
-import { HttpClient } from "@effect/platform";
+import { HttpClient } from "effect/http";
 /** ChatGPT's Luna router currently keys its internal route on Pi's
  * time-ordered UUIDv7 session shape; UUIDv4 reaches a nonexistent rollout
  * alias. Keep one v7 id per Efferent conversation/cache key. */

package/dist/llm/openAiCodexWebSocket.js

@@ -1,10 +1,5 @@
-import {
-  HttpClient,
-  HttpClientError,
-  HttpClientRequest,
-  HttpClientResponse
-} from "@effect/platform";
-import { Effect, Either } from "effect";
+import { HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/http";
+import { Effect, Result } from "effect";
 import { release } from "node:os";
 import WebSocket from "ws";
 const WEBSOCKET_BETA = "responses_websockets=2026-02-06", sessionIds = new Map, decodeBody = (request) => {
@@ -78,17 +73,17 @@ export const normalizeOpenAiCodexWebSocketEvent = (value) => {
     }, abort = () => fail(Error("OpenAI subscription request aborted"));
     signal.addEventListener("abort", abort, { once: !0 });
     socket.addEventListener("open", () => {
-      Either.match(Either.try(() => {
+      Result.match(Result.try(() => {
         socket.send(JSON.stringify({ type: "response.create", ...body }));
         state.settled = !0;
         return HttpClientResponse.fromWeb(safeRequest, new Response(stream, {
           status: 200,
           headers: { "content-type": "text/event-stream" }
         }));
-      }), { onLeft: fail, onRight: resolve });
+      }), { onFailure: fail, onSuccess: resolve });
     });
     socket.addEventListener("message", (event) => {
-      Either.match(Either.try(() => {
+      Result.match(Result.try(() => {
         const text = eventText(event.data);
         if (text === void 0)
           return;
@@ -107,7 +102,7 @@ export const normalizeOpenAiCodexWebSocketEvent = (value) => {
           signal.removeEventListener("abort", abort);
           socket.close(1000, "done");
         }
-      }), { onLeft: fail, onRight: () => {
+      }), { onFailure: fail, onSuccess: () => {
         return;
       } });
     });
@@ -117,10 +112,11 @@ export const normalizeOpenAiCodexWebSocketEvent = (value) => {
         fail(Error(`OpenAI subscription WebSocket closed ${event.code}: ${event.reason}`));
     });
   }),
-  catch: (cause) => new HttpClientError.RequestError({
-    request: request.pipe(HttpClientRequest.setHeader("authorization", "[redacted]"), HttpClientRequest.setHeader("chatgpt-account-id", "[redacted]")),
-    reason: "Transport",
-    description: `OpenAI subscription WebSocket failed: ${cause instanceof Error ? cause.message : String(cause)}`,
-    cause
+  catch: (cause) => new HttpClientError.HttpClientError({
+    reason: new HttpClientError.TransportError({
+      request: request.pipe(HttpClientRequest.setHeader("authorization", "[redacted]"), HttpClientRequest.setHeader("chatgpt-account-id", "[redacted]")),
+      description: `OpenAI subscription WebSocket failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+      cause
+    })
   })
 }));

package/dist/llm/providers.d.ts

@@ -1,25 +1,28 @@
-import { LanguageModel } from "@effect/ai";
-import { HttpClient } from "@effect/platform";
+import { LanguageModel } from "effect/ai";
+import { HttpClient } from "effect/http";
 import { Effect, Redacted } from "effect";
 import type { Scope } from "effect";
 import { AuthError } from "@xandreed/core";
 import type { Credential, ModelSelection } from "@xandreed/core";
 /**
- * Per-provider `LanguageModel.Service` construction. Built PER REQUEST from a
+ * Per-provider `LanguageModel` construction. Built PER REQUEST from a
  * freshly-resolved key (never captured at layer build), so a credential or
  * model switch applies on the next call.
  *
- * v1 providers: opencode (OpenAI-compatible gateway — the default), google,
- * anthropic (api key or subscription OAuth), openai (api key). OpenAI-OAuth
+ * v1 providers: opencode (OpenAI-compatible gateway — the default), google
+ * (Gemini's OpenAI-compatible endpoint), anthropic (api key or subscription
+ * OAuth), openai (api key). OpenAI-OAuth
  * (Codex) and ollama are deferred until an agent needs them.
  */
 export declare const OPENCODE_CHAT_URL = "https://opencode.ai/zen/go/v1/chat/completions";
 /** OpenCode serves GPT models through the OpenAI Responses protocol. */
 export declare const OPENCODE_RESPONSES_API_URL = "https://opencode.ai/zen/v1";
+/** Gemini through its OpenAI-compatible chat completions (Bearer API key). */
+export declare const GOOGLE_CHAT_URL = "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions";
 /** Pure protocol routing decision; provider details stay inside this adapter. */
 export declare const usesOpenCodeResponses: (modelId: string) => boolean;
 export interface BuiltProvider {
-    readonly svc: LanguageModel.Service;
+    readonly svc: LanguageModel.LanguageModel;
     /** Anthropic subscription auth requires the Claude Code system block first. */
     readonly prependClaudeCode: boolean;
 }
@@ -34,4 +37,5 @@ export declare const prependClaudeCode: (options: unknown) => unknown;
  * alone.
  */
 export declare const withAnthropicCacheBreakpoints: (options: unknown) => unknown;
+/** Preserve adapter descriptors and describe the public configuration of SDK-backed models. */
 export declare const buildProvider: (selection: ModelSelection, credential: Credential | undefined, key: Redacted.Redacted<string> | undefined) => Effect.Effect<BuiltProvider, AuthError, HttpClient.HttpClient | Scope.Scope>;

package/dist/llm/providers.js

@@ -1,22 +1,21 @@
-import { LanguageModel, Prompt } from "@effect/ai";
+import { LanguageModel, Prompt } from "effect/ai";
 import { AnthropicClient, AnthropicLanguageModel } from "@effect/ai-anthropic";
-import { GoogleClient, GoogleLanguageModel } from "@effect/ai-google";
 import { OpenAiClient, OpenAiLanguageModel } from "@effect/ai-openai";
-import { HttpClient, HttpClientRequest } from "@effect/platform";
-import { Effect, FiberRef, Option, Redacted } from "effect";
-import { AuthError, CurrentModelCallPolicy, CurrentPromptCacheKey } from "@xandreed/core";
+import { HttpClient, HttpClientRequest } from "effect/http";
+import { Effect, Option, Redacted } from "effect";
+import { AuthError, CurrentModelCallPolicy, CurrentPromptCacheKey, describeModel, modelRequestDescriptorOf } from "@xandreed/core";
 import { ANTHROPIC_OAUTH_BETA, CLAUDE_CODE_SYSTEM } from "../auth/anthropicOAuth.js";
 import { makeCompatLanguageModel } from "./compat.js";
 import { makeOpenAiCodexLanguageModel } from "./openAiCodex.js";
 import { openAiCodexAccountId } from "../auth/openAiCodexOAuth.js";
-export const OPENCODE_CHAT_URL = "https://opencode.ai/zen/go/v1/chat/completions", OPENCODE_RESPONSES_API_URL = "https://opencode.ai/zen/v1", usesOpenCodeResponses = (modelId) => /^gpt-/i.test(modelId);
+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", usesOpenCodeResponses = (modelId) => /^gpt-/i.test(modelId);
 const 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.merge(claudeCodePrompt, Prompt.make(options.prompt))
+  prompt: Prompt.concat(claudeCodePrompt, Prompt.make(options.prompt))
 }), withAnthropicCacheBreakpoints = (options) => {
   const messages = Prompt.make(options.prompt).content;
   if (messages.length === 0)
@@ -46,31 +45,30 @@ export const prependClaudeCode = (options) => ({
 const missingKey = (selection) => new AuthError({
   provider: selection.provider,
   message: `no credential for ${selection.provider} \u2014 add one to ~/.efferent/auth.json`
-});
-export const buildProvider = (selection, credential, key) => {
+}), 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
+      }
+    })
+  })
+}), buildProviderService = (selection, credential, key) => {
   const oauth = credential?.type === "oauth";
   if (selection.provider === "opencode") {
     if (key === void 0)
       return Effect.fail(missingKey(selection));
     if (usesOpenCodeResponses(selection.modelId))
       return Effect.all({
-        cacheKey: FiberRef.get(CurrentPromptCacheKey),
-        policy: FiberRef.get(CurrentModelCallPolicy)
+        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: {
-          strict: !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
-              }
-            })
-          })
-        }
+        config: openCodeResponsesConfig(cacheKey, policy)
       }).pipe(Effect.provideService(OpenAiClient.OpenAiClient, client))), Effect.map((svc) => ({ svc, prependClaudeCode: !1 })))));
     return makeCompatLanguageModel({
       moduleName: "OpenCode",
@@ -80,10 +78,13 @@ export const buildProvider = (selection, credential, key) => {
     }).pipe(Effect.map((svc) => ({ svc, prependClaudeCode: !1 })));
   }
   if (selection.provider === "google")
-    return key === void 0 ? Effect.fail(missingKey(selection)) : GoogleClient.make({ apiKey: key }).pipe(Effect.flatMap((client) => GoogleLanguageModel.make({
+    return key === void 0 ? Effect.fail(missingKey(selection)) : makeCompatLanguageModel({
+      moduleName: "Google",
+      chatUrl: GOOGLE_CHAT_URL,
+      apiKey: Redacted.value(key),
       model: selection.modelId,
-      config: { toolConfig: {} }
-    }).pipe(Effect.provideService(GoogleClient.GoogleClient, client))), Effect.map((svc) => ({ svc, prependClaudeCode: !1 })));
+      standardOnly: !0
+    }).pipe(Effect.map((svc) => ({ svc, prependClaudeCode: !1 })));
   if (selection.provider === "anthropic") {
     if (key === void 0)
       return Effect.fail(missingKey(selection));
@@ -95,13 +96,13 @@ export const buildProvider = (selection, credential, key) => {
   if (selection.provider === "openai-codex") {
     if (key === void 0 || credential?.type !== "oauth")
       return Effect.fail(missingKey(selection));
-    const accountId = Option.orElse(Option.fromNullable(credential.accountId), () => openAiCodexAccountId(Redacted.value(key)));
+    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 again with Smith :login" }));
     return makeOpenAiCodexLanguageModel({ model: selection.modelId, accessToken: key, accountId: accountId.value }).pipe(Effect.map((svc) => ({ svc, prependClaudeCode: !1 })));
   }
   if (selection.provider === "openai")
-    return key === void 0 ? Effect.fail(missingKey(selection)) : Effect.flatMap(FiberRef.get(CurrentPromptCacheKey), (cacheKey) => OpenAiClient.make({ apiKey: key }).pipe(Effect.flatMap((client) => OpenAiLanguageModel.make({
+    return key === void 0 ? Effect.fail(missingKey(selection)) : Effect.flatMap(Effect.service(CurrentPromptCacheKey), (cacheKey) => OpenAiClient.make({ apiKey: key }).pipe(Effect.flatMap((client) => OpenAiLanguageModel.make({
       model: selection.modelId,
       config: {
         prompt_cache_key: Option.getOrElse(cacheKey, () => "efferent")
@@ -112,3 +113,10 @@ export const buildProvider = (selection, credential, key) => {
     message: `provider "${selection.provider}" is not wired on the new line (v1: opencode, google, anthropic, openai, openai-codex)`
   }));
 };
+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 };
+  return {
+    ...built,
+    svc: describeModel(built.svc, modelRequestDescriptorOf(built.svc).pipe(Effect.map((existing) => Option.match(existing, { onNone: () => descriptor, onSome: (value) => ({ ...value, provider: selection.provider }) }))))
+  };
+})));

package/dist/llm/retry.d.ts

@@ -1,4 +1,4 @@
-import { AiError } from "@effect/ai";
+import { AiError } from "effect/ai";
 import { Effect, Stream } from "effect";
 /**
  * Transient-failure resilience for every routed LLM call — the survival
@@ -32,9 +32,9 @@ export declare const classifyLlmError: (error: unknown) => ErrorClass;
  *  it would park the turn in the patient outage ladder. */
 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.UnknownError, R>;
+}, 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.UnknownError, R>;
+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:
@@ -51,4 +51,4 @@ export declare const retryableLlm: (label: string) => <A, E, R>(effect: Effect.E
  *   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.UnknownError, R>;
+export declare const retryableLlmStream: (label: string, timeoutMs?: number) => <A, E, R>(stream: Stream.Stream<A, E, R>) => Stream.Stream<A, E | AiError.AiError, R>;

package/dist/llm/retry.js

@@ -1,5 +1,5 @@
-import { AiError } from "@effect/ai";
-import { Duration, Effect, FiberRef, Ref, Schedule, Stream } from "effect";
+import { AiError } from "effect/ai";
+import { Duration, Effect, Ref, Schedule, Stream } from "effect";
 import { CurrentEmptyResponseTolerance } from "@xandreed/core";
 export const LLM_REQUEST_TIMEOUT_MS = 300000, MAX_HONORED_RETRY_AFTER_MS = 60000;
 const retryAfterMillis = (headers) => {
@@ -11,38 +11,32 @@ const retryAfterMillis = (headers) => {
     return seconds * 1000;
   const at = Date.parse(raw);
   return Number.isNaN(at) ? void 0 : Math.max(0, at - Date.now());
-};
+}, rateLimited = (waitMs) => waitMs !== void 0 && waitMs > MAX_HONORED_RETRY_AFTER_MS ? "permanent" : "transient";
 export const classifyLlmError = (error) => {
-  const e = error;
-  if (e === null || typeof e !== "object")
-    return "permanent";
-  if (e._tag === "HttpResponseError") {
-    const status = e.response?.status ?? 0;
-    if (status === 429) {
-      const wait = retryAfterMillis(e.response?.headers);
-      return wait !== void 0 && wait > MAX_HONORED_RETRY_AFTER_MS ? "permanent" : "transient";
-    }
-    return status >= 500 ? "transient" : "permanent";
+  if (!AiError.isAiError(error)) {
+    const e = error;
+    return e?._tag === "HttpClientError" && e.reason?._tag === "TransportError" ? "transient" : "permanent";
+  }
+  const reason = error.reason, response = "http" in reason ? reason.http?.response : void 0;
+  if (response !== void 0) {
+    if (response.status === 429)
+      return rateLimited(retryAfterMillis(response.headers));
+    return response.status >= 500 ? "transient" : "permanent";
   }
-  if (e._tag === "UnknownError" || e._tag === "HttpRequestError")
-    return "transient";
-  return "permanent";
+  if (reason._tag === "RateLimitError")
+    return rateLimited(reason.retryAfter === void 0 ? void 0 : Duration.toMillis(reason.retryAfter));
+  return reason._tag === "InternalProviderError" || reason._tag === "NetworkError" || reason._tag === "UnknownError" ? "transient" : "permanent";
 };
-const fastRetries = Schedule.exponential(Duration.seconds(1)).pipe(Schedule.jittered, Schedule.intersect(Schedule.recurs(3))), timeoutError = (label, method, timeoutMs) => new AiError.UnknownError({
-  module: "Router",
-  method,
-  description: `the ${label} request exceeded ${timeoutMs / 1000}s and was cut off`
-}), emptyError = (label, method) => new AiError.UnknownError({
-  module: "Router",
-  method,
-  description: `${label} returned an empty response (no text, tool call, or reasoning) \u2014 treated as a transient provider failure`
-}), isContentPart = (part) => {
+const fastRetries = Schedule.max([
+  Schedule.exponential(Duration.seconds(1)).pipe(Schedule.jittered),
+  Schedule.recurs(3)
+]), routerError = (method, description) => AiError.make({ module: "Router", method, reason: new AiError.UnknownError({ description }) }), timeoutError = (label, method, timeoutMs) => routerError(method, `the ${label} request exceeded ${timeoutMs / 1000}s and was cut off`), emptyError = (label, method) => routerError(method, `${label} returned an empty response (no text, tool call, or reasoning) \u2014 treated as a transient provider failure`), isContentPart = (part) => {
   const t = part?.type;
   return t === "text" || t === "tool-call" || t === "reasoning";
 };
-export const rejectEmptyResponse = (label) => (effect) => FiberRef.get(CurrentEmptyResponseTolerance).pipe(Effect.flatMap((tolerant) => tolerant ? effect : effect.pipe(Effect.filterOrFail((res) => res.content.some(isContentPart), () => emptyError(label, "generateText"))))), retryableLlm = (label) => (effect) => effect.pipe(Effect.timeoutFail({
+export const rejectEmptyResponse = (label) => (effect) => Effect.service(CurrentEmptyResponseTolerance).pipe(Effect.flatMap((tolerant) => tolerant ? effect : effect.pipe(Effect.filterOrFail((res) => res.content.some(isContentPart), () => emptyError(label, "generateText"))))), retryableLlm = (label) => (effect) => effect.pipe(Effect.timeoutOrElse({
   duration: Duration.millis(LLM_REQUEST_TIMEOUT_MS),
-  onTimeout: () => timeoutError(label, "generateText", LLM_REQUEST_TIMEOUT_MS)
+  orElse: () => Effect.fail(timeoutError(label, "generateText", LLM_REQUEST_TIMEOUT_MS))
 }), Effect.retry({
   schedule: fastRetries,
   while: (error) => classifyLlmError(error) === "transient"
@@ -57,5 +51,8 @@ const isContentPartEncoded = (part) => {
 }, isFinishPartEncoded = (part) => part?.type === "finish";
 export const retryableLlmStream = (label, timeoutMs = LLM_REQUEST_TIMEOUT_MS) => (stream) => Stream.unwrap(Effect.gen(function* () {
   const contentSeen = yield* Ref.make(!1);
-  return stream.pipe(Stream.mapEffect((part) => isContentPartEncoded(part) ? Ref.set(contentSeen, !0).pipe(Effect.as(part)) : isFinishPartEncoded(part) ? Ref.get(contentSeen).pipe(Effect.flatMap((seen) => seen ? Effect.succeed(part) : Effect.fail(emptyError(label, "streamText")))) : Effect.succeed(part)), Stream.timeoutFail(() => timeoutError(label, "streamText", timeoutMs), Duration.millis(timeoutMs)), Stream.retry(fastRetries.pipe(Schedule.whileInputEffect((error) => Ref.get(contentSeen).pipe(Effect.map((seen) => !seen && classifyLlmError(error) === "transient"))))), Stream.tapError((error) => classifyLlmError(error) === "transient" ? Effect.logWarning(`${label}: transient stream failure was final: ${String(error)}`) : Effect.void));
+  return stream.pipe(Stream.mapEffect((part) => isContentPartEncoded(part) ? Ref.set(contentSeen, !0).pipe(Effect.as(part)) : isFinishPartEncoded(part) ? Ref.get(contentSeen).pipe(Effect.flatMap((seen) => seen ? Effect.succeed(part) : Effect.fail(emptyError(label, "streamText")))) : Effect.succeed(part)), Stream.timeoutOrElse({
+    duration: Duration.millis(timeoutMs),
+    orElse: () => Stream.fail(timeoutError(label, "streamText", timeoutMs))
+  }), Stream.retry(fastRetries.pipe(Schedule.while(({ input }) => Ref.get(contentSeen).pipe(Effect.map((seen) => !seen && classifyLlmError(input) === "transient"))))), Stream.tapError((error) => classifyLlmError(error) === "transient" ? Effect.logWarning(`${label}: transient stream failure was final: ${String(error)}`) : Effect.void));
 }));

package/dist/llm/router.d.ts

@@ -1,5 +1,5 @@
-import { LanguageModel } from "@effect/ai";
-import { HttpClient } from "@effect/platform";
+import { LanguageModel } from "effect/ai";
+import { HttpClient } from "effect/http";
 import { Effect, Layer, Option, Stream } from "effect";
 import { AuthStore, SettingsStore } from "@xandreed/core";
 import type { ModelSelection } from "@xandreed/core";

package/dist/llm/router.js

@@ -1,7 +1,7 @@
-import { AiError, LanguageModel } from "@effect/ai";
-import { FetchHttpClient, HttpClient } from "@effect/platform";
-import { Clock, Duration, Effect, FiberRef, Layer, Metric, Option, Ref, Stream } from "effect";
-import { AuthStore, CurrentModelCallPolicy, formatModelSelection, parseModelSelection, SettingsStore } from "@xandreed/core";
+import { AiError, LanguageModel } from "effect/ai";
+import { FetchHttpClient, HttpClient } from "effect/http";
+import { Clock, Duration, Effect, Layer, Metric, Option, Ref, Stream } from "effect";
+import { AuthStore, CurrentModelCallPolicy, describeModel, formatModelSelection, HarnessError, parseModelSelection, resolvingModel, SettingsStore } from "@xandreed/core";
 import { buildProvider, prependClaudeCode, withAnthropicCacheBreakpoints } from "./providers.js";
 import {
   classifyLlmError,
@@ -9,7 +9,7 @@ import {
   retryableLlm,
   retryableLlmStream
 } from "./retry.js";
-const configError = (message) => new AiError.UnknownError({ module: "Router", method: "selection", description: message }), llmInputTokens = Metric.counter("llm.usage.input_tokens", {
+const configError = (message) => AiError.make({ module: "Router", method: "selection", reason: new AiError.UnknownError({ description: message }) }), llmInputTokens = Metric.counter("llm.usage.input_tokens", {
   description: "prompt tokens consumed by routed LLM calls",
   incremental: !0
 }), llmOutputTokens = Metric.counter("llm.usage.output_tokens", {
@@ -18,7 +18,15 @@ const configError = (message) => new AiError.UnknownError({ module: "Router", me
 }), llmRequests = Metric.counter("llm.requests", {
   description: "routed LLM calls by final outcome (after retries)",
   incremental: !0
-}), llmDuration = Metric.timerWithBoundaries("llm.request.duration", [100, 250, 500, 1000, 2500, 5000, 1e4, 30000, 60000, 120000, 300000]), byModel = (metric, label) => Metric.tagged(metric, "llm.model", label), tracedContent = (content) => process.env.EFFERENT_TRACE_CONTENT === "1" ? content.slice(0, 500) : "[redacted]", shapeOptions = (selection, shouldPrependClaudeCode, options) => {
+}), llmDuration = Metric.timer("llm.request.duration", {
+  boundaries: [100, 250, 500, 1000, 2500, 5000, 1e4, 30000, 60000, 120000, 300000]
+}), byModel = (metric, label) => Metric.withAttributes(metric, { "llm.model": label }), countRequest = (label, outcome, isFallback) => Metric.update(Metric.withAttributes(byModel(llmRequests, label), {
+  outcome,
+  ...isFallback === void 0 ? {} : { fallback: isFallback ? "true" : "false" }
+}), 1), usageTotals = (usage) => {
+  const u = usage;
+  return { input: u?.inputTokens?.total ?? 0, output: u?.outputTokens?.total ?? 0 };
+}, tracedContent = (content) => process.env.EFFERENT_TRACE_CONTENT === "1" ? content.slice(0, 500) : "[redacted]", shapeOptions = (selection, shouldPrependClaudeCode, options) => {
   const cached = selection.provider === "anthropic" ? withAnthropicCacheBreakpoints(options) : options;
   return shouldPrependClaudeCode ? prependClaudeCode(cached) : cached;
 }, currentSelection = Effect.gen(function* () {
@@ -31,13 +39,20 @@ const configError = (message) => new AiError.UnknownError({ module: "Router", me
     fallback: Option.flatMap(loaded.fallbackModel, parseModelSelection),
     effort: loaded.reasoningEffort
   };
-}), withConfiguredEffort = (effect, effort) => FiberRef.get(CurrentModelCallPolicy).pipe(Effect.flatMap((current) => Option.isSome(current) || Option.isNone(effort) ? effect : effect.pipe(Effect.locally(CurrentModelCallPolicy, Option.some({ effort: effort.value })))));
+}), withConfiguredEffort = (effect, effort) => Effect.service(CurrentModelCallPolicy).pipe(Effect.flatMap((current) => Option.isSome(current) || Option.isNone(effort) ? effect : effect.pipe(Effect.provideService(CurrentModelCallPolicy, Option.some({ effort: effort.value }))))), describeSelection = (primary, fallback, effort) => Effect.service(CurrentModelCallPolicy).pipe(Effect.map((current) => ({
+  provider: primary.provider,
+  model: primary.modelId,
+  settings: {
+    fallback: Option.getOrElse(Option.map(fallback, formatModelSelection), () => null),
+    policy: Option.getOrElse(Option.orElse(current, () => Option.map(effort, (value) => ({ effort: value }))), () => null)
+  }
+})));
 export const generateWith = (selection, options, isFallback = !1) => Effect.gen(function* () {
   const auth = yield* AuthStore, label = formatModelSelection(selection), credential = Option.getOrUndefined(yield* auth.get(selection.provider)), key = Option.getOrUndefined(yield* auth.resolveKey(selection.provider)), built = yield* buildProvider(selection, credential, key);
   return yield* built.svc.generateText(shapeOptions(selection, built.prependClaudeCode, options)).pipe(rejectEmptyResponse(label), retryableLlm(label), Effect.map((res) => stampResponse(res, label)), Effect.tap((res) => Effect.annotateCurrentSpan({
     "llm.finish_reason": String(res.finishReason),
-    "llm.usage.input_tokens": res.usage.inputTokens ?? 0,
-    "llm.usage.output_tokens": res.usage.outputTokens ?? 0,
+    "llm.usage.input_tokens": usageTotals(res.usage).input,
+    "llm.usage.output_tokens": usageTotals(res.usage).output,
     "llm.response_chars": res.text.length,
     "llm.tool_calls": res.content.flatMap((part) => {
       const p = part;
@@ -46,17 +61,14 @@ export const generateWith = (selection, options, isFallback = !1) => Effect.gen(
     "llm.reasoning": tracedContent(res.reasoningText ?? ""),
     "llm.fallback": isFallback
   })), Effect.tap((res) => Effect.all([
-    Metric.incrementBy(byModel(llmInputTokens, label), res.usage.inputTokens ?? 0),
-    Metric.incrementBy(byModel(llmOutputTokens, label), res.usage.outputTokens ?? 0)
-  ], { discard: !0 })), Effect.tapBoth({
-    onFailure: () => Metric.increment(Metric.tagged(Metric.tagged(byModel(llmRequests, label), "outcome", "error"), "fallback", isFallback ? "true" : "false")),
-    onSuccess: () => Metric.increment(Metric.tagged(Metric.tagged(byModel(llmRequests, label), "outcome", "ok"), "fallback", isFallback ? "true" : "false"))
-  }), Metric.trackDuration(byModel(llmDuration, label)), Effect.withSpan("providers.generate", {
+    Metric.update(byModel(llmInputTokens, label), usageTotals(res.usage).input),
+    Metric.update(byModel(llmOutputTokens, label), usageTotals(res.usage).output)
+  ], { discard: !0 })), Effect.tap(() => countRequest(label, "ok", isFallback)), Effect.tapError(() => countRequest(label, "error", isFallback)), Effect.timed, Effect.tap(([duration]) => Metric.update(byModel(llmDuration, label), duration)), Effect.map(([, res]) => res), Effect.withSpan("providers.generate", {
     attributes: { "llm.model": label }
   }));
-}).pipe(Effect.scoped), withFallbackRung = (primary, fallback, call) => call(primary, !1).pipe(Effect.catchAll((error) => Option.match(Option.filter(fallback, (fb) => formatModelSelection(fb) !== formatModelSelection(primary) && classifyLlmError(error) === "transient"), {
+}).pipe(Effect.scoped), withFallbackRung = (primary, fallback, call) => call(primary, !1).pipe(Effect.catch((error) => Option.match(Option.filter(fallback, (fb) => formatModelSelection(fb) !== formatModelSelection(primary) && classifyLlmError(error) === "transient"), {
   onNone: () => Effect.fail(error),
-  onSome: (fb) => Effect.logWarning(`${formatModelSelection(primary)} exhausted retries (${String(error).slice(0, 200)}) \u2014 falling back to ${formatModelSelection(fb)}`).pipe(Effect.zipRight(call(fb, !0)))
+  onSome: (fb) => Effect.logWarning(`${formatModelSelection(primary)} exhausted retries (${String(error).slice(0, 200)}) \u2014 falling back to ${formatModelSelection(fb)}`).pipe(Effect.andThen(call(fb, !0)))
 })));
 const stampModel = (part, label) => {
   if (typeof part !== "object" || part === null)
@@ -90,36 +102,40 @@ export const tapStreamTelemetry = (label) => (stream) => Stream.unwrap(Effect.ge
       return Ref.update(stats, (s) => accumulateStats(s, part)).pipe(Effect.as(part));
     return Ref.get(stats).pipe(Effect.flatMap((s) => Effect.annotateCurrentSpan({
       "llm.finish_reason": String(p.reason),
-      "llm.usage.input_tokens": p.usage?.inputTokens ?? 0,
-      "llm.usage.output_tokens": p.usage?.outputTokens ?? 0,
+      "llm.usage.input_tokens": usageTotals(p.usage).input,
+      "llm.usage.output_tokens": usageTotals(p.usage).output,
       "llm.response_chars": s.textChars,
       "llm.tool_calls": s.toolNames.join(","),
       "llm.reasoning": tracedContent(s.reasoning)
-    })), Effect.zipRight(Effect.all([
-      Metric.incrementBy(byModel(llmInputTokens, label), p.usage?.inputTokens ?? 0),
-      Metric.incrementBy(byModel(llmOutputTokens, label), p.usage?.outputTokens ?? 0)
+    })), Effect.andThen(Effect.all([
+      Metric.update(byModel(llmInputTokens, label), usageTotals(p.usage).input),
+      Metric.update(byModel(llmOutputTokens, label), usageTotals(p.usage).output)
     ], { discard: !0 })), Effect.as(part));
-  }), Stream.onDone(() => Metric.increment(Metric.tagged(byModel(llmRequests, label), "outcome", "ok")).pipe(Effect.zipRight(recordDuration))), Stream.tapErrorCause(() => Metric.increment(Metric.tagged(byModel(llmRequests, label), "outcome", "error")).pipe(Effect.zipRight(recordDuration))));
-})), streamWith = (selection, options) => Stream.unwrapScoped(Effect.gen(function* () {
+  }), Stream.onEnd(countRequest(label, "ok").pipe(Effect.andThen(recordDuration))), Stream.tapCause(() => countRequest(label, "error").pipe(Effect.andThen(recordDuration))));
+})), streamWith = (selection, options) => Stream.unwrap(Effect.gen(function* () {
   const auth = yield* AuthStore, label = formatModelSelection(selection), credential = Option.getOrUndefined(yield* auth.get(selection.provider)), key = Option.getOrUndefined(yield* auth.resolveKey(selection.provider)), built = yield* buildProvider(selection, credential, key);
   return built.svc.streamText(shapeOptions(selection, built.prependClaudeCode, options)).pipe(retryableLlmStream(label), Stream.map((part) => stampModel(part, label)), tapStreamTelemetry(label), Stream.withSpan("providers.generate", {
     attributes: { "llm.model": label }
   }));
-})), LanguageModelLive = Layer.effect(LanguageModel.LanguageModel, Effect.gen(function* () {
-  const context = yield* Effect.context(), http = yield* HttpClient.HttpClient;
-  return {
-    generateText: (options) => currentSelection.pipe(Effect.flatMap(({ effort, fallback, primary }) => withConfiguredEffort(withFallbackRung(primary, fallback, (selection, isFallback) => generateWith(selection, options, isFallback)), effort)), Effect.provide(context), Effect.provideService(HttpClient.HttpClient, http)),
+}));
+const withConfiguredEffortStream = (stream, effort) => Stream.unwrap(Effect.service(CurrentModelCallPolicy).pipe(Effect.map((current) => Option.isSome(current) || Option.isNone(effort) ? stream : stream.pipe(Stream.provideService(CurrentModelCallPolicy, Option.some({ effort: effort.value })))))), selectionModel = (primary, fallback, effort, context, http) => {
+  const service = {
+    [LanguageModel.TypeId]: LanguageModel.TypeId,
+    generateText: (options) => withConfiguredEffort(withFallbackRung(primary, fallback, (selection, isFallback) => generateWith(selection, options, isFallback)), effort).pipe(Effect.provide(context), Effect.provideService(HttpClient.HttpClient, http)),
     generateObject: () => Effect.fail(configError("generateObject is not wired on the new line yet")),
-    streamText: (options) => Stream.unwrapScoped(currentSelection.pipe(Effect.flatMap(({ effort, primary }) => FiberRef.get(CurrentModelCallPolicy).pipe(Effect.flatMap((current) => {
-      const stream = streamWith(primary, options);
-      return Option.isSome(current) || Option.isNone(effort) ? Effect.succeed(stream) : Effect.locallyScoped(CurrentModelCallPolicy, Option.some({ effort: effort.value })).pipe(Effect.as(stream));
-    }))))).pipe(Stream.provideSomeContext(context), Stream.provideService(HttpClient.HttpClient, http))
+    streamText: (options) => withConfiguredEffortStream(streamWith(primary, options), effort).pipe(Stream.provideContext(context), Stream.provideService(HttpClient.HttpClient, http))
   };
+  return describeModel(service, describeSelection(primary, fallback, effort));
+};
+export const LanguageModelLive = Layer.effect(LanguageModel.LanguageModel, Effect.gen(function* () {
+  const context = yield* Effect.context(), http = yield* HttpClient.HttpClient, selected = currentSelection.pipe(Effect.map(({ primary, fallback, effort }) => selectionModel(primary, fallback, effort, context, http)), Effect.provide(context)), service = {
+    [LanguageModel.TypeId]: LanguageModel.TypeId,
+    generateText: (options) => selected.pipe(Effect.flatMap((model) => model.generateText(options))),
+    generateObject: () => Effect.fail(configError("generateObject is not wired on the new line yet")),
+    streamText: (options) => Stream.unwrap(selected.pipe(Effect.map((model) => model.streamText(options))))
+  }, asHarness = (error) => new HarnessError({ code: "request.model", message: String(error) });
+  return resolvingModel(describeModel(service, currentSelection.pipe(Effect.flatMap(({ primary, fallback, effort }) => describeSelection(primary, fallback, effort)), Effect.provide(context), Effect.mapError(asHarness))), selected.pipe(Effect.mapError(asHarness)));
 })).pipe(Layer.provide(FetchHttpClient.layer)), LanguageModelSelectionLive = (primary, fallback) => Layer.effect(LanguageModel.LanguageModel, Effect.gen(function* () {
   const context = yield* Effect.context(), http = yield* HttpClient.HttpClient;
-  return {
-    generateText: (options) => withFallbackRung(primary, fallback, (selection, isFallback) => generateWith(selection, options, isFallback)).pipe(Effect.provide(context), Effect.provideService(HttpClient.HttpClient, http)),
-    generateObject: () => Effect.fail(configError("generateObject is not wired on the new line yet")),
-    streamText: (options) => streamWith(primary, options).pipe(Stream.provideSomeContext(context), Stream.provideService(HttpClient.HttpClient, http))
-  };
+  return selectionModel(primary, fallback, Option.none(), context, http);
 })).pipe(Layer.provide(FetchHttpClient.layer));

package/dist/llm/sse.d.ts

@@ -1,5 +1,5 @@
-import { AiError } from "@effect/ai";
-import type { Response } from "@effect/ai";
+import { AiError } from "effect/ai";
+import type { Response } from "effect/ai";
 import { Stream } from "effect";
 /**
  * The OpenAI-compatible SSE wire → `@effect/ai` `StreamPartEncoded`s, as a
@@ -30,12 +30,17 @@ export interface CompletionUsage {
     };
 }
 /** The vendor cached-token fallback chain, shared with the non-streaming
- *  parser — the gateway fronts upstreams with three cache vocabularies. */
+ *  parser — the gateway fronts upstreams with three cache vocabularies.
+ *  `prompt_tokens` already counts the cached tokens: it is the full input. */
 export declare const usageFromCompletion: (usage: CompletionUsage | undefined) => {
-    inputTokens: number;
-    outputTokens: number;
-    totalTokens: number;
-    cachedInputTokens: number;
+    inputTokens: {
+        total: number;
+        uncached: number;
+        cacheRead: number;
+    };
+    outputTokens: {
+        total: number;
+    };
 };
 export declare const finishReasonFromWire: (raw: string | undefined) => "stop" | "length" | "content-filter" | "tool-calls";
 /** Parse a streaming chat-completions body into encoded stream parts. */

package/dist/llm/sse.js

@@ -1,11 +1,12 @@
-import { AiError } from "@effect/ai";
-import { Effect, Option, Stream } from "effect";
-export const usageFromCompletion = (usage) => ({
-  inputTokens: usage?.prompt_tokens ?? 0,
-  outputTokens: usage?.completion_tokens ?? 0,
-  totalTokens: usage?.total_tokens ?? 0,
-  cachedInputTokens: usage?.prompt_cache_hit_tokens ?? usage?.cached_tokens ?? usage?.prompt_tokens_details?.cached_tokens ?? 0
-}), finishReasonFromWire = (raw) => {
+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;
+  return {
+    inputTokens: { total: input, uncached: Math.max(0, input - cached), cacheRead: cached },
+    outputTokens: { total: usage?.completion_tokens ?? 0 }
+  };
+}, finishReasonFromWire = (raw) => {
   if (raw === "tool_calls")
     return "tool-calls";
   if (raw === "length")
@@ -66,12 +67,14 @@ const initialState = {
     name: call.name.length > 0 ? call.name : fragment.function?.name ?? "",
     args: call.args + (fragment.function?.arguments ?? "")
   } : call);
-}, malformed = (moduleName, description) => new AiError.MalformedOutput({ module: moduleName, method: "streamText", description }), applyChunk = (moduleName, state, chunk) => {
+}, 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(new AiError.UnknownError({
+    return Effect.fail(AiError.make({
       module: moduleName,
       method: "streamText",
-      description: `the stream carried an error chunk: ${JSON.stringify(chunk.error).slice(0, 500)}`
+      reason: new AiError.UnknownError({
+        description: `the stream carried an error chunk: ${JSON.stringify(chunk.error).slice(0, 500)}`
+      })
     }));
   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,
@@ -104,13 +107,12 @@ const initialState = {
 }).pipe(Effect.flatMap((chunk) => applyChunk(moduleName, state, chunk)));
 export const sseStreamParts = (options) => Stream.fromReadableStream({
   evaluate: () => options.body,
-  onError: (cause) => new AiError.UnknownError({
+  onError: (cause) => AiError.make({
     module: options.moduleName,
     method: "streamText",
-    description: `the response body stream failed: ${String(cause)}`,
-    cause
+    reason: new AiError.UnknownError({ description: `the response body stream failed: ${String(cause)}` })
   })
 }).pipe(Stream.decodeText(), Stream.splitLines, Stream.filterMap((line) => {
   const trimmed = line.trim();
-  return trimmed.startsWith("data:") ? Option.some(trimmed.slice(5).trim()) : Option.none();
-}), Stream.concat(Stream.succeed(DONE)), Stream.mapAccumEffect(initialState, (state, payload) => step(options.moduleName, state, payload)), Stream.flattenIterables);
+  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)));

package/dist/llm/utilityLlm.js

@@ -1,7 +1,7 @@
-import { Prompt } from "@effect/ai";
-import { FetchHttpClient, HttpClient } from "@effect/platform";
+import { Prompt } from "effect/ai";
+import { FetchHttpClient, HttpClient } from "effect/http";
 import { Effect, Layer, Option } from "effect";
-import { AuthStore, parseModelSelection, SettingsStore, UtilityError, UtilityLlm } from "@xandreed/core";
+import { AuthStore, extractUsage, parseModelSelection, SettingsStore, UtilityError, UtilityLlm } from "@xandreed/core";
 import { generateWith } from "./router.js";
 export const UtilityLlmLive = Layer.effect(UtilityLlm, Effect.gen(function* () {
   const context = yield* Effect.context(), http = yield* HttpClient.HttpClient, settings = yield* SettingsStore;
@@ -15,19 +15,11 @@ export const UtilityLlmLive = Layer.effect(UtilityLlm, Effect.gen(function* () {
         tools: [],
         toolChoice: "none",
         responseFormat: { type: "text" }
-      }).pipe(Effect.mapError((e) => new UtilityError({ message: String(e) })), Effect.provide(context), Effect.provideService(HttpClient.HttpClient, http)), text = res.content.flatMap((p) => {
+      }).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 = res.usage;
-      return {
-        text,
-        usage: {
-          inputTokens: usage?.inputTokens ?? 0,
-          outputTokens: usage?.outputTokens ?? 0,
-          totalTokens: usage?.totalTokens ?? 0,
-          cacheReadTokens: usage?.cachedInputTokens ?? 0
-        }
-      };
+      }).join(""), usage: extractUsage(res.usage, res.content) };
     })
   };
 })).pipe(Layer.provide(FetchHttpClient.layer));

package/dist/plugin.adapter.d.ts

@@ -1,2 +1,14 @@
-export declare const modelsPlugin: import("@xandreed/core").Plugin;
+import { LanguageModel } from "effect/ai";
+import { AuthStore, ModelCatalog, SessionEnvironment, SettingsError, SettingsStore, UtilityLlm } from "@xandreed/core";
+export declare const modelsPlugin: import("@xandreed/core").TypedPlugin<{
+    readonly model: string;
+    readonly fastModel: string;
+    readonly fallbackModel: string;
+    readonly inheritPrevious: boolean;
+}, {
+    readonly model: string;
+    readonly fastModel: string;
+    readonly fallbackModel: string;
+    readonly inheritPrevious: boolean;
+}, SettingsStore | AuthStore | ModelCatalog | UtilityLlm | LanguageModel.LanguageModel, SettingsError, SessionEnvironment>;
 export default modelsPlugin;

package/dist/plugin.adapter.js

@@ -1,5 +1,5 @@
 import { homedir } from "node:os";
-import { LanguageModel } from "@effect/ai";
+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 { LocalAuthStoreLive } from "./auth/localAuth.js";
@@ -10,12 +10,12 @@ import { LocalSettingsStoreLive } from "./settings/localSettings.js";
 const Config = Schema.Struct({ model: Schema.String, fastModel: Schema.String, fallbackModel: Schema.String, inheritPrevious: Schema.Boolean });
 export const modelsPlugin = definePlugin({
   id: "@xandreed/plugin-models",
-  version: "0.4.0",
+  version: "0.8.0-next.0",
   config: Config,
   defaults: { model: "", fastModel: "", fallbackModel: "", inheritPrevious: !0 },
   requires: [SessionEnvironment],
   provides: [LanguageModel.LanguageModel, UtilityLlm, AuthStore, SettingsStore, ModelCatalog],
-  layer: (config) => Layer.unwrapEffect(Effect.gen(function* () {
+  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" })),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xandreed/plugin-models",
-  "version": "0.4.0",
+  "version": "0.8.0-next.0",
   "type": "module",
   "main": "./dist/index.js",
   "exports": {
@@ -14,13 +14,10 @@
     }
   },
   "dependencies": {
-    "@xandreed/core": "0.4.0",
-    "effect": "3.21.4",
-    "@effect/ai": "0.35.0",
-    "@effect/ai-anthropic": "^0.25.0",
-    "@effect/ai-google": "^0.14.0",
-    "@effect/ai-openai": "^0.39.2",
-    "@effect/platform": "0.96.1",
+    "@xandreed/core": "0.8.0-next.0",
+    "effect": "4.0.0-rc.118",
+    "@effect/ai-anthropic": "4.0.0-rc.118",
+    "@effect/ai-openai": "4.0.0-rc.118",
     "ws": "^8.21.0"
   },
   "private": false,