@xandreed/plugin-models 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Xand Reed
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

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

package/dist/auth/anthropicOAuth.d.ts

@@ -0,0 +1,50 @@
+import { Effect, Option } from "effect";
+import { AuthError } from "@xandreed/core";
+/**
+ * Anthropic OAuth (Claude Pro/Max subscription) — the full protocol:
+ * authorization-code + PKCE (begin/exchange) and refresh. Constants match
+ * the public Claude Code OAuth client (the client id is not a secret).
+ * These are pure protocol helpers; the loopback callback server and the
+ * browser-open live in the TUI driver.
+ */
+export declare const ANTHROPIC_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+export declare const ANTHROPIC_CALLBACK_PORT = 53692;
+export declare const ANTHROPIC_CALLBACK_PATH = "/callback";
+export declare const ANTHROPIC_REDIRECT_URI = "http://localhost:53692/callback";
+/** Beta flags the subscription path requires (Claude Code identity + oauth). */
+export declare const ANTHROPIC_OAUTH_BETA = "claude-code-20250219,oauth-2025-04-20";
+/** Anthropic rejects OAuth tokens unless the first system block is exactly this. */
+export declare const CLAUDE_CODE_SYSTEM = "You are Claude Code, Anthropic's official CLI for Claude.";
+export interface RefreshedTokens {
+    readonly access: string;
+    readonly refresh: string;
+    /** Absolute expiry, epoch ms (with a 5-minute early-refresh skew baked in). */
+    readonly expires: number;
+}
+/** Refresh an expired (or near-expiry) access token. */
+export declare const refreshAnthropicToken: (refreshToken: string) => Effect.Effect<RefreshedTokens, AuthError>;
+export interface Pkce {
+    readonly verifier: string;
+    readonly challenge: string;
+}
+/** Generate a PKCE verifier + S256 challenge (Web Crypto; Bun-global). */
+export declare const generatePkce: Effect.Effect<Pkce>;
+export interface OAuthBegin {
+    /** The PKCE verifier — ALSO the `state`; the driver must verify the
+     *  redirect echoes it (CSRF) before exchanging. */
+    readonly verifier: string;
+    readonly authorizeUrl: string;
+    readonly callbackPort: number;
+    readonly callbackPath: string;
+}
+/** Start an authorization: PKCE material + the browser URL. */
+export declare const beginAnthropicOAuth: Effect.Effect<OAuthBegin>;
+/** Exchange the authorization code for tokens. */
+export declare const exchangeAnthropicCode: (code: string, verifier: string) => Effect.Effect<RefreshedTokens, AuthError>;
+export interface AuthRedirect {
+    readonly code: Option.Option<string>;
+    readonly state: Option.Option<string>;
+}
+/** Pull `code`/`state` out of a pasted redirect URL, `code#state` pair,
+ *  bare query string, or raw code. Total — garbage is `{none, none}`. */
+export declare const parseAuthorizationInput: (input: string) => AuthRedirect;

package/dist/auth/anthropicOAuth.js

@@ -0,0 +1,90 @@
+import { Effect, Option } from "effect";
+import { AuthError } from "@xandreed/core";
+export const ANTHROPIC_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+const AUTHORIZE_URL = "https://claude.ai/oauth/authorize", TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+export const ANTHROPIC_CALLBACK_PORT = 53692, ANTHROPIC_CALLBACK_PATH = "/callback", ANTHROPIC_REDIRECT_URI = `http://localhost:${ANTHROPIC_CALLBACK_PORT}${ANTHROPIC_CALLBACK_PATH}`;
+const SCOPES = "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload";
+export const ANTHROPIC_OAUTH_BETA = "claude-code-20250219,oauth-2025-04-20", CLAUDE_CODE_SYSTEM = "You are Claude Code, Anthropic's official CLI for Claude.";
+const oauthError = (stage) => (detail) => new AuthError({
+  provider: "anthropic",
+  message: `OAuth ${stage} failed: ${detail}`
+}), postToken = (body, stage) => {
+  const fail = oauthError(stage);
+  return Effect.tryPromise({
+    try: async () => {
+      const res = await fetch(TOKEN_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "application/json" },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(30000)
+      });
+      return { ok: res.ok, status: res.status, text: await res.text() };
+    },
+    catch: (e) => fail(String(e))
+  }).pipe(Effect.filterOrFail((res) => res.ok, (res) => fail(`status ${res.status}: ${res.text.slice(0, 200)}`)), Effect.flatMap((res) => Effect.try({
+    try: () => JSON.parse(res.text),
+    catch: () => fail("the token response was not JSON")
+  })), Effect.map((data) => ({
+    access: data.access_token,
+    refresh: data.refresh_token,
+    expires: Date.now() + data.expires_in * 1000 - 300000
+  })));
+};
+export const refreshAnthropicToken = (refreshToken) => postToken({
+  grant_type: "refresh_token",
+  client_id: ANTHROPIC_CLIENT_ID,
+  refresh_token: refreshToken
+}, "token refresh");
+const base64url = (bytes) => btoa(Array.from(bytes, (b) => String.fromCharCode(b)).join("")).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+export const generatePkce = Effect.promise(async () => {
+  const verifierBytes = new Uint8Array(32);
+  crypto.getRandomValues(verifierBytes);
+  const verifier = base64url(verifierBytes), digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
+  return { verifier, challenge: base64url(new Uint8Array(digest)) };
+}), beginAnthropicOAuth = Effect.map(generatePkce, (pkce) => ({
+  verifier: pkce.verifier,
+  authorizeUrl: `${AUTHORIZE_URL}?${new URLSearchParams({
+    code: "true",
+    client_id: ANTHROPIC_CLIENT_ID,
+    response_type: "code",
+    redirect_uri: ANTHROPIC_REDIRECT_URI,
+    scope: SCOPES,
+    code_challenge: pkce.challenge,
+    code_challenge_method: "S256",
+    state: pkce.verifier
+  }).toString()}`,
+  callbackPort: ANTHROPIC_CALLBACK_PORT,
+  callbackPath: ANTHROPIC_CALLBACK_PATH
+})), exchangeAnthropicCode = (code, verifier) => postToken({
+  grant_type: "authorization_code",
+  client_id: ANTHROPIC_CLIENT_ID,
+  code,
+  redirect_uri: ANTHROPIC_REDIRECT_URI,
+  code_verifier: verifier,
+  state: verifier
+}, "code exchange");
+const fromNullableTrimmed = (value) => Option.filter(Option.fromNullable(value), (v) => v.trim().length > 0);
+export const parseAuthorizationInput = (input) => {
+  const value = input.trim();
+  if (value.length === 0)
+    return { code: Option.none(), state: Option.none() };
+  if (URL.canParse(value)) {
+    const url = new URL(value);
+    return {
+      code: fromNullableTrimmed(url.searchParams.get("code")),
+      state: fromNullableTrimmed(url.searchParams.get("state"))
+    };
+  }
+  if (value.includes("#")) {
+    const [code, state] = value.split("#", 2);
+    return { code: fromNullableTrimmed(code), state: fromNullableTrimmed(state) };
+  }
+  if (value.includes("code=")) {
+    const params = new URLSearchParams(value);
+    return {
+      code: fromNullableTrimmed(params.get("code")),
+      state: fromNullableTrimmed(params.get("state"))
+    };
+  }
+  return { code: Option.some(value), state: Option.none() };
+};

package/dist/auth/anthropicOAuth.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/auth/localAuth.d.ts

@@ -0,0 +1,8 @@
+import { Layer } from "effect";
+import { AuthStore } from "@xandreed/core";
+export declare const authPaths: (cwd: string, home: string, directory?: string) => ReadonlyArray<string>;
+/**
+ * `LocalAuthStoreLive(cwd, home)` — read-through: every call re-reads disk,
+ * so a credential added mid-session applies on the next request.
+ */
+export declare const LocalAuthStoreLive: (cwd: string, home: string, directory?: string, fallbackDirectory?: string) => Layer.Layer<AuthStore, never, never>;

package/dist/auth/localAuth.js

@@ -0,0 +1,90 @@
+import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { Effect, Layer, Option, Redacted } from "effect";
+import { asJsonRecord, AuthError, AuthStore, parseJsonWarn } from "@xandreed/core";
+import { refreshAnthropicToken } from "./anthropicOAuth.js";
+import { refreshOpenAiCodexToken } from "./openAiCodexOAuth.js";
+const decodeCredential = (value) => {
+  if (typeof value === "string")
+    return Option.some({ type: "api_key", key: value });
+  if (typeof value !== "object" || value === null)
+    return Option.none();
+  const v = value;
+  if (v.type === "api_key" && typeof v.key === "string")
+    return Option.some({ type: "api_key", key: v.key });
+  if (v.type === "oauth" && typeof v.access === "string" && typeof v.refresh === "string" && typeof v.expires === "number")
+    return Option.some({
+      type: "oauth",
+      access: v.access,
+      refresh: v.refresh,
+      expires: v.expires,
+      ...typeof v.accountId === "string" ? { accountId: v.accountId } : {},
+      ...typeof v.installationId === "string" ? { installationId: v.installationId } : {}
+    });
+  if (v.type === "local")
+    return Option.some({
+      type: "local",
+      ...typeof v.baseUrl === "string" ? { baseUrl: v.baseUrl } : {}
+    });
+  return Option.none();
+}, readAuthFile = (path) => Effect.tryPromise({ try: () => readFile(path, "utf-8"), catch: () => "missing" }).pipe(Effect.flatMap((text) => parseJsonWarn(text, path)), Effect.map((parsed) => {
+  const record = asJsonRecord(parsed), entries = new Map(Object.entries(record).flatMap(([provider, raw]) => Option.match(decodeCredential(raw), {
+    onNone: () => [],
+    onSome: (cred) => [[provider, cred]]
+  })));
+  return { path, entries };
+}), Effect.orElseSucceed(() => ({ path, entries: new Map }))), writeAuthFile = (path, entries) => Effect.tryPromise({
+  try: async () => {
+    await mkdir(dirname(path), { recursive: !0 });
+    const tmp = `${path}.tmp-${process.pid}`;
+    await writeFile(tmp, JSON.stringify(Object.fromEntries(entries), null, 2), "utf-8");
+    await chmod(tmp, 384);
+    await rename(tmp, path);
+  },
+  catch: (e) => new AuthError({ provider: "*", message: `auth.json write failed: ${String(e)}` })
+}), REFRESH_SKEW_MS = 60000;
+export const authPaths = (cwd, home, directory = ".efferent") => [
+  join(home, directory, "auth.json"),
+  join(cwd, directory, "auth.json")
+], LocalAuthStoreLive = (cwd, home, directory = ".efferent", fallbackDirectory) => {
+  const paths = [...fallbackDirectory === void 0 ? [] : authPaths(cwd, home, fallbackDirectory), ...authPaths(cwd, home, directory)];
+  return Layer.succeed(AuthStore, {
+    all: Effect.gen(function* () {
+      const files = yield* Effect.forEach(paths, readAuthFile);
+      return new Map(files.flatMap((f) => [...f.entries]));
+    }),
+    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));
+    }),
+    resolveKey: (provider) => Effect.gen(function* () {
+      const holder = [...yield* Effect.forEach(paths, readAuthFile)].reverse().find((f) => f.entries.has(provider)), cred = holder?.entries.get(provider);
+      if (cred === void 0)
+        return Option.none();
+      if (cred.type === "api_key")
+        return Option.some(Redacted.make(cred.key));
+      if (cred.type === "local")
+        return Option.none();
+      if (cred.expires > Date.now() + REFRESH_SKEW_MS)
+        return Option.some(Redacted.make(cred.access));
+      if (provider !== "anthropic" && provider !== "openai-codex")
+        return yield* Effect.fail(new AuthError({
+          provider,
+          message: `the ${provider} OAuth token expired and its refresh flow isn't wired on the new line \u2014 re-login or use an API key`
+        }));
+      const fresh = yield* provider === "anthropic" ? refreshAnthropicToken(cred.refresh) : refreshOpenAiCodexToken(cred.refresh), updated = { ...cred, ...fresh }, target = holder !== void 0 && authPaths(cwd, home, directory).includes(holder.path) ? holder : yield* readAuthFile(authPaths(cwd, home, directory)[0] ?? "");
+      yield* writeAuthFile(target.path, new Map([...target.entries, [provider, updated]]));
+      return Option.some(Redacted.make(fresh.access));
+    }),
+    set: (provider, credential) => Effect.gen(function* () {
+      const globalPath = authPaths(cwd, home, directory)[0] ?? "", file = yield* readAuthFile(globalPath);
+      yield* writeAuthFile(globalPath, new Map([...file.entries, [provider, credential]]));
+    }),
+    remove: (provider) => Effect.forEach(paths, (path) => Effect.gen(function* () {
+      const file = yield* readAuthFile(path);
+      if (!file.entries.has(provider))
+        return;
+      yield* writeAuthFile(path, new Map([...file.entries].filter(([p]) => p !== provider)));
+    })).pipe(Effect.asVoid)
+  });
+};

package/dist/auth/localAuth.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/auth/openAiCodexOAuth.d.ts

@@ -0,0 +1,25 @@
+import { Effect, Option } from "effect";
+import { AuthError } from "@xandreed/core";
+/** ChatGPT Plus/Pro OAuth protocol used by the OpenAI Codex subscription. */
+export declare const OPENAI_CODEX_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+export declare const OPENAI_CODEX_CALLBACK_PORT = 1455;
+export declare const OPENAI_CODEX_CALLBACK_PATH = "/auth/callback";
+export declare const OPENAI_CODEX_REDIRECT_URI = "http://localhost:1455/auth/callback";
+export interface OpenAiCodexTokens {
+    readonly access: string;
+    readonly refresh: string;
+    readonly expires: number;
+    readonly accountId?: string;
+}
+export interface OpenAiCodexOAuthBegin {
+    readonly verifier: string;
+    readonly state: string;
+    readonly authorizeUrl: string;
+    readonly callbackPort: number;
+    readonly callbackPath: string;
+}
+/** Extract the subscription account lane without exposing the token. */
+export declare const openAiCodexAccountId: (accessToken: string) => Option.Option<string>;
+export declare const beginOpenAiCodexOAuth: Effect.Effect<OpenAiCodexOAuthBegin>;
+export declare const exchangeOpenAiCodexCode: (code: string, verifier: string) => Effect.Effect<OpenAiCodexTokens, AuthError>;
+export declare const refreshOpenAiCodexToken: (refreshToken: string) => Effect.Effect<OpenAiCodexTokens, AuthError>;

package/dist/auth/openAiCodexOAuth.js

@@ -0,0 +1,58 @@
+import { Effect, Either, Option } from "effect";
+import { AuthError } from "@xandreed/core";
+import { generatePkce } from "./anthropicOAuth.js";
+export const OPENAI_CODEX_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+const AUTHORIZE_URL = "https://auth.openai.com/oauth/authorize", TOKEN_URL = "https://auth.openai.com/oauth/token";
+export const OPENAI_CODEX_CALLBACK_PORT = 1455, OPENAI_CODEX_CALLBACK_PATH = "/auth/callback", OPENAI_CODEX_REDIRECT_URI = `http://localhost:${OPENAI_CODEX_CALLBACK_PORT}${OPENAI_CODEX_CALLBACK_PATH}`;
+const SCOPE = "openid profile email offline_access", ACCOUNT_CLAIM = "https://api.openai.com/auth", oauthError = (stage, detail) => new AuthError({ provider: "openai-codex", message: `OAuth ${stage} failed: ${detail}` }), base64UrlJson = (segment) => {
+  const normalized = segment.replace(/-/g, "+").replace(/_/g, "/"), padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "=");
+  return JSON.parse(atob(padded));
+};
+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) => {
+    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);
+  }));
+};
+const postToken = (body, stage) => Effect.tryPromise({
+  try: async () => {
+    const response = await fetch(TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams(body),
+      signal: AbortSignal.timeout(30000)
+    });
+    return { ok: response.ok, status: response.status, text: await response.text() };
+  },
+  catch: (error) => oauthError(stage, String(error))
+}).pipe(Effect.filterOrFail((response) => response.ok, (response) => oauthError(stage, `status ${response.status}: ${response.text.slice(0, 200)}`)), Effect.flatMap((response) => Effect.try({
+  try: () => JSON.parse(response.text),
+  catch: () => oauthError(stage, "the token response was not JSON")
+})), Effect.filterOrFail((token) => typeof token.access_token === "string" && typeof token.refresh_token === "string" && typeof token.expires_in === "number", () => oauthError(stage, "the token response omitted required fields")), Effect.map((token) => ({
+  access: token.access_token,
+  refresh: token.refresh_token,
+  expires: Date.now() + token.expires_in * 1000,
+  ...Option.match(openAiCodexAccountId(token.access_token), { onNone: () => ({}), onSome: (accountId) => ({ accountId }) })
+})));
+export const beginOpenAiCodexOAuth = Effect.gen(function* () {
+  const pkce = yield* generatePkce, stateBytes = new Uint8Array(16);
+  crypto.getRandomValues(stateBytes);
+  const state = Array.from(stateBytes, (byte) => byte.toString(16).padStart(2, "0")).join(""), url = new URL(AUTHORIZE_URL);
+  Object.entries({
+    response_type: "code",
+    client_id: OPENAI_CODEX_CLIENT_ID,
+    redirect_uri: OPENAI_CODEX_REDIRECT_URI,
+    scope: SCOPE,
+    code_challenge: pkce.challenge,
+    code_challenge_method: "S256",
+    state,
+    id_token_add_organizations: "true",
+    codex_cli_simplified_flow: "true",
+    originator: "pi"
+  }).forEach(([key, value]) => url.searchParams.set(key, value));
+  return { verifier: pkce.verifier, state, authorizeUrl: url.toString(), callbackPort: OPENAI_CODEX_CALLBACK_PORT, callbackPath: OPENAI_CODEX_CALLBACK_PATH };
+}), exchangeOpenAiCodexCode = (code, verifier) => postToken({ grant_type: "authorization_code", client_id: OPENAI_CODEX_CLIENT_ID, code, code_verifier: verifier, redirect_uri: OPENAI_CODEX_REDIRECT_URI }, "code exchange"), refreshOpenAiCodexToken = (refreshToken) => postToken({ grant_type: "refresh_token", refresh_token: refreshToken, client_id: OPENAI_CODEX_CLIENT_ID }, "token refresh");

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export { ANTHROPIC_OAUTH_BETA, beginAnthropicOAuth, CLAUDE_CODE_SYSTEM, exchangeAnthropicCode, generatePkce, parseAuthorizationInput, refreshAnthropicToken, } from "./auth/anthropicOAuth.js";
+export type { AuthRedirect, OAuthBegin, Pkce, RefreshedTokens } from "./auth/anthropicOAuth.js";
+export { beginOpenAiCodexOAuth, exchangeOpenAiCodexCode, OPENAI_CODEX_CALLBACK_PATH, OPENAI_CODEX_CALLBACK_PORT, OPENAI_CODEX_CLIENT_ID, OPENAI_CODEX_REDIRECT_URI, openAiCodexAccountId, refreshOpenAiCodexToken, } from "./auth/openAiCodexOAuth.js";
+export type { OpenAiCodexOAuthBegin, OpenAiCodexTokens } from "./auth/openAiCodexOAuth.js";
+export { authPaths, LocalAuthStoreLive } from "./auth/localAuth.js";
+export { LocalSettingsStoreLive } from "./settings/localSettings.js";
+export { roleModelView } from "./settings/roleView.js";
+export { fromChatCompletion, makeCompatLanguageModel, toChatMessages, toChatTools, } from "./llm/compat.js";
+export type { CompatConfig } from "./llm/compat.js";
+export { makeOpenAiCodexLanguageModel, OPENAI_CODEX_API_URL, toOpenAiCodexRequestBody } from "./llm/openAiCodex.js";
+export { normalizeOpenAiCodexWebSocketEvent, openAiCodexUuidV7, OpenAiCodexWebSocketHttpClient } from "./llm/openAiCodexWebSocket.js";
+export { buildProvider, OPENCODE_CHAT_URL, OPENCODE_RESPONSES_API_URL, prependClaudeCode, usesOpenCodeResponses, withAnthropicCacheBreakpoints, } from "./llm/providers.js";
+export { classifyLlmError, LLM_REQUEST_TIMEOUT_MS, MAX_HONORED_RETRY_AFTER_MS, rejectEmptyResponse, retryableLlm, } from "./llm/retry.js";
+export type { ErrorClass } from "./llm/retry.js";
+export { generateWith, LanguageModelLive, LanguageModelSelectionLive } from "./llm/router.js";
+export { configuredModelCatalog, ConfiguredModelCatalogLive, reasoningEffortsFor, } from "./llm/modelCatalog.js";
+export type { ReasoningEffort } from "./llm/modelCatalog.js";
+export { UtilityLlmLive } from "./llm/utilityLlm.js";
+export { modelsPlugin, default } from "./plugin.adapter.js";

package/dist/index.js

@@ -0,0 +1,53 @@
+export {
+  ANTHROPIC_OAUTH_BETA,
+  beginAnthropicOAuth,
+  CLAUDE_CODE_SYSTEM,
+  exchangeAnthropicCode,
+  generatePkce,
+  parseAuthorizationInput,
+  refreshAnthropicToken
+} from "./auth/anthropicOAuth.js";
+export {
+  beginOpenAiCodexOAuth,
+  exchangeOpenAiCodexCode,
+  OPENAI_CODEX_CALLBACK_PATH,
+  OPENAI_CODEX_CALLBACK_PORT,
+  OPENAI_CODEX_CLIENT_ID,
+  OPENAI_CODEX_REDIRECT_URI,
+  openAiCodexAccountId,
+  refreshOpenAiCodexToken
+} from "./auth/openAiCodexOAuth.js";
+export { authPaths, LocalAuthStoreLive } from "./auth/localAuth.js";
+export { LocalSettingsStoreLive } from "./settings/localSettings.js";
+export { roleModelView } from "./settings/roleView.js";
+export {
+  fromChatCompletion,
+  makeCompatLanguageModel,
+  toChatMessages,
+  toChatTools
+} from "./llm/compat.js";
+export { makeOpenAiCodexLanguageModel, OPENAI_CODEX_API_URL, toOpenAiCodexRequestBody } from "./llm/openAiCodex.js";
+export { normalizeOpenAiCodexWebSocketEvent, openAiCodexUuidV7, OpenAiCodexWebSocketHttpClient } from "./llm/openAiCodexWebSocket.js";
+export {
+  buildProvider,
+  OPENCODE_CHAT_URL,
+  OPENCODE_RESPONSES_API_URL,
+  prependClaudeCode,
+  usesOpenCodeResponses,
+  withAnthropicCacheBreakpoints
+} from "./llm/providers.js";
+export {
+  classifyLlmError,
+  LLM_REQUEST_TIMEOUT_MS,
+  MAX_HONORED_RETRY_AFTER_MS,
+  rejectEmptyResponse,
+  retryableLlm
+} from "./llm/retry.js";
+export { generateWith, LanguageModelLive, LanguageModelSelectionLive } from "./llm/router.js";
+export {
+  configuredModelCatalog,
+  ConfiguredModelCatalogLive,
+  reasoningEffortsFor
+} from "./llm/modelCatalog.js";
+export { UtilityLlmLive } from "./llm/utilityLlm.js";
+export { modelsPlugin, default } from "./plugin.adapter.js";

package/dist/llm/compat.d.ts

@@ -0,0 +1,77 @@
+import { AiError, LanguageModel, Tool } from "@effect/ai";
+import type { Prompt } from "@effect/ai";
+import { Effect } from "effect";
+import type { CompletionUsage } from "./sse.js";
+/**
+ * A generic OpenAI-compatible `/chat/completions` `LanguageModel` over raw
+ * `fetch`. The official `@effect/ai-openai` client targets api.openai.com;
+ * gateways like OpenCode's speak the same protocol at a different base URL
+ * with a Bearer key, so this client is parameterized by `chatUrl` + `apiKey`.
+ *
+ * `generateText` consumes whole turns (`stream: false`); `streamText` runs
+ * the same request with `stream: true` through the pure SSE state machine in
+ * `sse.ts`. Errors BEFORE any stream part surface with the same taxonomy as
+ * `generateText` — that boundary is what the retry gate (router) keys on.
+ */
+type Json = Record<string, unknown>;
+export interface CompatConfig {
+    /** Module name for `AiError` provenance (e.g. "OpenCode"). */
+    readonly moduleName: string;
+    /** Full chat-completions endpoint. */
+    readonly chatUrl: string;
+    /** Bearer key (already resolved from the AuthStore). */
+    readonly apiKey: string;
+    /** Provider-native model id. */
+    readonly model: string;
+    /** Host-selected thinking mode. Omit to retain family defaults. */
+    readonly thinking?: "enabled" | "disabled";
+    /** Gateway reasoning vocabulary, independent of provider-native thinking. */
+    readonly reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+    readonly temperature?: number;
+    /** Injectable for tests; defaults to global fetch. */
+    readonly fetchImpl?: typeof fetch;
+    /** Host-owned admission (e.g. reserve a worst-case cost) before every call. */
+    readonly beforeRequest?: (body: Readonly<Record<string, unknown>>) => Effect.Effect<void, AiError.AiError>;
+    /** Per-call accounting/resource boundary. Non-streaming responses are fully
+     * buffered inside request so interruption also aborts body consumption. */
+    readonly aroundRequest?: (body: Readonly<Record<string, unknown>>, request: Effect.Effect<Response, AiError.AiError>) => Effect.Effect<Response, AiError.AiError>;
+}
+/** Decoded `Prompt` messages → chat-completions message objects. */
+export declare const toChatMessages: (prompt: Prompt.Prompt) => ReadonlyArray<Json>;
+/** User-defined tools → chat-completions function declarations (empty when
+ *  the request carries none — the caller omits the `tools` key entirely). */
+export declare const toChatTools: (tools: ReadonlyArray<Tool.Any>) => ReadonlyArray<Json>;
+/**
+ * FORCE thinking on the families that think adaptively. Live forensics
+ * (2026-07-09): kimi-k2.7-code skipped thinking on 24 turns of one forge run
+ * and emitted degenerate skeleton tool calls (write_file with an EMPTY body,
+ * 24 output tokens, finish "tool-calls") on exactly those turns — the
+ * no-think ↔ empty-call correlation was 24/24. Deepseek-style families take
+ * `thinking: {type: "enabled"}`; qwen takes `enable_thinking`. Disabling is
+ * never sent (kimi-k2.7+ rejects it outright); unknown families get nothing.
+ */
+export declare const thinkingParams: (model: string) => Record<string, unknown>;
+interface ChatCompletion {
+    readonly choices?: ReadonlyArray<{
+        readonly finish_reason?: string;
+        readonly message?: {
+            readonly content?: string | null;
+            /** DeepSeek-native vocabulary (kimi-k2.7-code, deepseek serve this). */
+            readonly reasoning_content?: string | null;
+            /** OpenRouter-style vocabulary (kimi-k2.6 via Moonshot serves this). */
+            readonly reasoning?: string | null;
+            readonly tool_calls?: ReadonlyArray<{
+                readonly id?: string;
+                readonly function?: {
+                    readonly name?: string;
+                    readonly arguments?: string;
+                };
+            }>;
+        };
+    }>;
+    readonly usage?: CompletionUsage;
+}
+/** 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 {};