@xandreed/plugin-models 0.3.0

package/dist/llm/compat.js

@@ -0,0 +1,215 @@
+import { AiError, LanguageModel, Tool } from "@effect/ai";
+import { Effect, Either, FiberRef, JSONSchema, Option, Stream } from "effect";
+import { CurrentModelCallPolicy, CurrentPromptCacheKey } 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 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({
+      module: moduleName,
+      method,
+      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({
+      module: moduleName,
+      method,
+      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) => ({
+  method: "POST",
+  url: chatUrl,
+  urlParams: [],
+  hash: Option.none(),
+  headers: { "content-type": "application/json" }
+});
+export const toChatMessages = (prompt) => prompt.content.flatMap((message) => {
+  if (message.role === "system")
+    return [{ role: "system", content: message.content }];
+  if (message.role === "user")
+    return [{ role: "user", content: message.content.flatMap((p) => p.type === "text" ? [p.text] : []).join("") }];
+  if (message.role === "assistant") {
+    const text = message.content.flatMap((p) => p.type === "text" ? [p.text] : []).join(""), toolCalls = message.content.flatMap((p) => p.type === "tool-call" ? [
+      {
+        id: p.id,
+        type: "function",
+        function: { name: p.name, arguments: JSON.stringify(p.params ?? {}) }
+      }
+    ] : []);
+    return [
+      {
+        role: "assistant",
+        content: text.length > 0 ? text : null,
+        ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+      }
+    ];
+  }
+  return message.content.flatMap((p) => p.type === "tool-result" ? [
+    {
+      role: "tool",
+      tool_call_id: p.id,
+      content: typeof p.result === "string" ? p.result : JSON.stringify(p.result ?? null)
+    }
+  ] : []);
+}), toChatTools = (tools) => tools.flatMap((tool) => Tool.isUserDefined(tool) ? [
+  {
+    type: "function",
+    function: {
+      name: tool.name,
+      description: Tool.getDescription(tool),
+      parameters: Tool.getJsonSchema(tool)
+    }
+  }
+] : []);
+const toToolChoice = (choice) => {
+  if (choice === "none" || choice === "required")
+    return choice;
+  if (typeof choice === "object" && choice !== null && "tool" in choice)
+    return {
+      type: "function",
+      function: { name: choice.tool }
+    };
+  return "auto";
+};
+export const thinkingParams = (model) => {
+  if (/kimi-k2[\w.]*-code/i.test(model))
+    return { thinking: { type: "enabled" }, reasoning_effort: "high" };
+  if (/kimi-k2|deepseek/i.test(model))
+    return { thinking: { type: "enabled" } };
+  if (/qwen/i.test(model))
+    return { enable_thinking: !0 };
+  return {};
+}, 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"
+    }));
+  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",
+      id: tc.id ?? "",
+      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`
+    })
+  }));
+  return [
+    ...reasoning !== null && reasoning !== void 0 && reasoning.length > 0 ? [{ type: "reasoning", text: reasoning }] : [],
+    ...text !== null && text !== void 0 && text.length > 0 ? [{ type: "text", text }] : [],
+    ...toolCalls,
+    {
+      type: "finish",
+      reason: toolCalls.length > 0 ? "tool-calls" : finishReasonFromWire(choice.finish_reason),
+      usage: usageFromCompletion(body.usage)
+    }
+  ];
+});
+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 })
+    }),
+    ...config.thinking === void 0 ? thinkingParams(config.model) : { thinking: { type: config.thinking } },
+    ...config.reasoningEffort === void 0 ? {} : { reasoning: { effort: config.reasoningEffort } },
+    ...Option.match(policy, {
+      onNone: () => ({}),
+      onSome: (value) => ({
+        ...value.maxOutputTokens === void 0 ? {} : { max_tokens: value.maxOutputTokens },
+        ...config.thinking === "disabled" || config.reasoningEffort !== void 0 ? {} : { reasoning_effort: value.effort }
+      })
+    }),
+    ...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({
+    try: async (signal) => {
+      const response = await (config.fetchImpl ?? fetch)(config.chatUrl, {
+        signal,
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${config.apiKey}`
+        },
+        body: JSON.stringify(body)
+      });
+      return buffered ? new Response(await response.arrayBuffer(), { status: response.status, statusText: response.statusText, headers: response.headers }) : response;
+    },
+    catch: (e) => aiUnknown(config.moduleName, method, e)
+  })));
+  return config.aroundRequest === void 0 ? request : config.aroundRequest(body, request);
+}, failStatus = (config, method, res) => Effect.gen(function* () {
+  const text = yield* Effect.tryPromise({
+    try: () => res.text(),
+    catch: (e) => aiUnknown(config.moduleName, method, e)
+  }), semantic = semanticGatewayError(config.moduleName, method, text);
+  if (Option.isSome(semantic))
+    return yield* Effect.fail(semantic.value);
+  const headers = {};
+  res.headers.forEach((value, headerName) => {
+    headers[headerName] = value;
+  });
+  return yield* Effect.fail(new AiError.HttpResponseError({
+    module: config.moduleName,
+    method,
+    reason: "StatusCode",
+    request: requestInfo(config.chatUrl),
+    response: { status: res.status, headers },
+    description: text.slice(0, 500)
+  }));
+});
+export const makeCompatLanguageModel = (config) => LanguageModel.make({
+  generateText: (options) => Effect.gen(function* () {
+    const res = yield* postChat(config, "generateText", yield* chatRequestBody(config, options, !1), !0);
+    if (!res.ok)
+      return yield* failStatus(config, "generateText", res);
+    const text = yield* Effect.tryPromise({
+      try: () => res.text(),
+      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)}`
+      })
+    });
+    return yield* fromChatCompletion(config.moduleName, parsed);
+  }),
+  streamText: (options) => Stream.unwrap(Effect.gen(function* () {
+    const res = yield* postChat(config, "streamText", yield* chatRequestBody(config, options, !0));
+    if (!res.ok)
+      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 sseStreamParts({ moduleName: config.moduleName, body });
+  }))
+});

package/dist/llm/compat.test.d.ts

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

package/dist/llm/modelCatalog.d.ts

@@ -0,0 +1,10 @@
+import { Layer } from "effect";
+import { AuthStore, ModelCatalog } from "@xandreed/core";
+import type { Credential, ModelCatalogEntryType } from "@xandreed/core";
+export declare const configuredModelCatalog: (credentials: ReadonlyMap<string, Credential>) => ReadonlyArray<ModelCatalogEntryType>;
+export type ReasoningEffort = "none" | "low" | "medium" | "high" | "xhigh" | "max";
+/** The reasoning controls accepted by each routed model. `none` on the
+ * gpt-5.6 subscription dialect is live-probed (2026-07-16: accepted,
+ * reasoning_tokens 0; `minimal` rejected). */
+export declare const reasoningEffortsFor: (selection: string) => ReadonlyArray<ReasoningEffort>;
+export declare const ConfiguredModelCatalogLive: Layer.Layer<ModelCatalog, never, AuthStore>;

package/dist/llm/modelCatalog.js

@@ -0,0 +1,58 @@
+import { Effect, Layer } from "effect";
+import { AuthStore, ModelCatalog } from "@xandreed/core";
+const OPENCODE_MODELS = [
+  "glm-5.2",
+  "glm-5.1",
+  "kimi-k2.7-code",
+  "kimi-k2.6",
+  "mimo-v2.5-pro",
+  "mimo-v2.5",
+  "qwen3.7-max",
+  "qwen3.7-plus",
+  "qwen3.6-plus",
+  "minimax-m3",
+  "minimax-m2.7",
+  "deepseek-v4-pro",
+  "deepseek-v4-flash"
+], MODELS = {
+  opencode: OPENCODE_MODELS,
+  "openai-codex": [
+    "gpt-5.3-codex-spark",
+    "gpt-5.4",
+    "gpt-5.4-mini",
+    "gpt-5.5",
+    "gpt-5.6-luna",
+    "gpt-5.6-sol",
+    "gpt-5.6-terra"
+  ],
+  openai: [
+    "gpt-5",
+    "gpt-5.1",
+    "gpt-5.2",
+    "gpt-5.4",
+    "gpt-5.4-mini",
+    "gpt-5.4-nano",
+    "gpt-5.5",
+    "gpt-5.6-luna",
+    "gpt-5.6-sol",
+    "gpt-5.6-terra"
+  ],
+  anthropic: ["claude-fable-5", "claude-haiku-4-5", "claude-opus-4-8", "claude-sonnet-5"],
+  google: ["gemini-3-flash", "gemini-3.1-pro", "gemini-3.5-flash"]
+};
+export const configuredModelCatalog = (credentials) => [...credentials].flatMap(([provider, credential]) => (MODELS[provider] ?? []).map((model) => ({
+  selection: `${provider}:${model}`,
+  label: provider === "openai-codex" ? `OpenAI subscription \xB7 ${model}` : provider === "openai" ? `OpenAI API key \xB7 ${model}` : void 0,
+  provider,
+  credential: credential.type
+}))), reasoningEffortsFor = (selection) => {
+  if (/^openai-codex:gpt-5\.6-(luna|sol|terra)$/.test(selection))
+    return ["none", "low", "medium", "high", "xhigh", "max"];
+  if (/^openai-codex:gpt-5/.test(selection))
+    return ["low", "medium", "high", "xhigh"];
+  if (/^openai:gpt-5/.test(selection))
+    return ["low", "medium", "high"];
+  return [];
+}, ConfiguredModelCatalogLive = Layer.effect(ModelCatalog, Effect.map(AuthStore, (auth) => ({
+  list: auth.all.pipe(Effect.orElseSucceed(() => new Map), Effect.map(configuredModelCatalog))
+})));

package/dist/llm/modelCatalog.test.d.ts

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

package/dist/llm/openAiCodex.d.ts

@@ -0,0 +1,18 @@
+import { LanguageModel } from "@effect/ai";
+import { HttpClient } from "@effect/platform";
+import { Effect, Redacted, Stream } 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. */
+export declare const toOpenAiCodexRequestBody: (body: unknown, reasoningEffort?: "none" | "low" | "medium" | "high" | "xhigh" | "max") => Json;
+export declare const mapOpenAiCodexError: (model: string, error: unknown) => unknown;
+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>;
+export {};

package/dist/llm/openAiCodex.js

@@ -0,0 +1,99 @@
+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 { 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) => {
+  const value = record(message);
+  if (value.role !== "developer" && value.role !== "system")
+    return [];
+  const content = value.content;
+  if (typeof content === "string")
+    return [content];
+  if (!Array.isArray(content))
+    return [];
+  return content.flatMap((part) => {
+    const item = record(part);
+    return typeof item.text === "string" ? [item.text] : [];
+  });
+};
+export const toOpenAiCodexRequestBody = (body, reasoningEffort) => {
+  const value = record(body), input = Array.isArray(value.input) ? value.input : [], instructions = input.flatMap(instructionText).join(`
+
+`), conversationalInput = input.filter((message) => instructionText(message).length === 0), configuredText = record(value.text);
+  return {
+    ...Object.fromEntries(Object.entries(value).filter(([key]) => key !== "max_output_tokens")),
+    store: !1,
+    stream: !0,
+    instructions: instructions.length > 0 ? instructions : "You are a helpful assistant.",
+    input: conversationalInput,
+    text: { verbosity: configuredText.verbosity ?? "low" },
+    include: ["reasoning.encrypted_content"],
+    tool_choice: value.tool_choice ?? "auto",
+    parallel_tool_calls: value.parallel_tool_calls ?? !0,
+    ...reasoningEffort === void 0 ? {} : { reasoning: { ...record(value.reasoning), effort: reasoningEffort, summary: "auto" } }
+  };
+};
+const transformRequest = (accountId, reasoningEffort) => (request) => {
+  const withHeaders = request.pipe(HttpClientRequest.setHeaders({
+    "chatgpt-account-id": accountId,
+    originator: "pi",
+    "OpenAI-Beta": "responses=experimental",
+    accept: "text/event-stream"
+  }));
+  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)))), {
+    onNone: () => withHeaders,
+    onSome: (decoded) => HttpClientRequest.bodyUnsafeJson(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({
+  module: "OpenAiCodex",
+  method: "responses",
+  description: `model ${model} is not available to the configured ChatGPT subscription account`,
+  cause: error
+}) : responseStatus(error) === 200 ? new AiError.MalformedOutput({
+  module: "OpenAiCodex",
+  method: "responses",
+  description: `the ${model} subscription stream returned a rejected or incompatible event`,
+  cause: error
+}) : error, makeOpenAiCodexLanguageModel = (args) => Effect.all({
+  cacheKey: FiberRef.get(CurrentPromptCacheKey),
+  policy: FiberRef.get(CurrentModelCallPolicy)
+}).pipe(Effect.flatMap(({ cacheKey, policy }) => OpenAiClient.make({
+  apiKey: args.accessToken,
+  apiUrl: OPENAI_CODEX_API_URL,
+  transformClient: () => OpenAiCodexWebSocketHttpClient.pipe(HttpClient.mapRequest((request) => transformRequest(args.accountId, Option.getOrUndefined(Option.map(policy, (value) => value.effort)))(request.pipe(HttpClientRequest.prependUrl(OPENAI_CODEX_API_URL), HttpClientRequest.bearerToken(args.accessToken)))))
+}).pipe(Effect.flatMap((client) => OpenAiLanguageModel.make({
+  model: args.model,
+  config: {
+    strict: !1,
+    store: !1,
+    prompt_cache_key: Option.getOrElse(cacheKey, () => "efferent"),
+    text: { verbosity: "low" },
+    ...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,
+          summary: "auto"
+        }
+      })
+    })
+  }
+}).pipe(Effect.provideService(OpenAiClient.OpenAiClient, client))), Effect.map((streaming) => {
+  const streamText = (options) => streaming.streamText(options).pipe(Stream.mapError((error) => mapOpenAiCodexError(args.model, error)));
+  return {
+    ...streaming,
+    streamText,
+    generateText: (options) => foldStreamParts(streamText(options), () => Effect.void).pipe(Effect.map((turn) => new LanguageModel.GenerateTextResponse(turn.content)))
+  };
+}))));

package/dist/llm/openAiCodexWebSocket.d.ts

@@ -0,0 +1,14 @@
+import { HttpClient } from "@effect/platform";
+/** 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. */
+export declare const openAiCodexUuidV7: (now?: number) => string;
+/** Codex currently names the WebSocket terminal event `response.done`; the
+ * public Responses stream consumed by @effect/ai names it `response.completed`. */
+export declare const normalizeOpenAiCodexWebSocketEvent: (value: unknown) => unknown;
+export declare const isOpenAiCodexControlEvent: (type: unknown) => boolean;
+/** Adapt the ChatGPT Codex WebSocket protocol to an SSE-shaped HttpClient
+ * response. OpenAiLanguageModel remains the sole protocol decoder, so text,
+ * reasoning, tool calls, tool results, usage, and errors keep their standard
+ * Effect representations instead of being reimplemented here. */
+export declare const OpenAiCodexWebSocketHttpClient: HttpClient.HttpClient;

package/dist/llm/openAiCodexWebSocket.js

@@ -0,0 +1,126 @@
+import {
+  HttpClient,
+  HttpClientError,
+  HttpClientRequest,
+  HttpClientResponse
+} from "@effect/platform";
+import { Effect, Either } from "effect";
+import { release } from "node:os";
+import WebSocket from "ws";
+const WEBSOCKET_BETA = "responses_websockets=2026-02-06", sessionIds = new Map, decodeBody = (request) => {
+  if (request.body._tag !== "Uint8Array")
+    return {};
+  const text = new TextDecoder().decode(request.body.body), parsed = JSON.parse(text);
+  return typeof parsed === "object" && parsed !== null ? parsed : {};
+}, websocketUrl = (url) => {
+  const next = new URL(url);
+  next.protocol = next.protocol === "http:" ? "ws:" : "wss:";
+  return next.toString();
+};
+export const openAiCodexUuidV7 = (now = Date.now()) => {
+  const bytes = globalThis.crypto.getRandomValues(new Uint8Array(16)), timestamp = BigInt(now);
+  bytes[0] = Number(timestamp >> 40n & 0xffn);
+  bytes[1] = Number(timestamp >> 32n & 0xffn);
+  bytes[2] = Number(timestamp >> 24n & 0xffn);
+  bytes[3] = Number(timestamp >> 16n & 0xffn);
+  bytes[4] = Number(timestamp >> 8n & 0xffn);
+  bytes[5] = Number(timestamp & 0xffn);
+  bytes[6] = bytes[6] & 15 | 112;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+};
+const sessionIdFor = (cacheKey) => {
+  const key = typeof cacheKey === "string" && cacheKey.length > 0 ? cacheKey : globalThis.crypto.randomUUID(), existing = sessionIds.get(key);
+  if (existing !== void 0)
+    return existing;
+  const created = openAiCodexUuidV7();
+  sessionIds.set(key, created);
+  return created;
+}, eventText = (data) => {
+  if (typeof data === "string")
+    return data;
+  if (data instanceof ArrayBuffer)
+    return new TextDecoder().decode(new Uint8Array(data));
+  if (ArrayBuffer.isView(data))
+    return new TextDecoder().decode(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+  return;
+};
+export const normalizeOpenAiCodexWebSocketEvent = (value) => {
+  if (typeof value !== "object" || value === null)
+    return value;
+  const event = value;
+  return event.type === "response.done" ? { ...event, type: "response.completed" } : event;
+}, isOpenAiCodexControlEvent = (type) => typeof type === "string" && (type.startsWith("codex.") || type === "responsesapi.websocket_timing"), OpenAiCodexWebSocketHttpClient = HttpClient.make((request, url, signal) => Effect.tryPromise({
+  try: () => new Promise((resolve, reject) => {
+    const body = decodeBody(request), safeRequest = request.pipe(HttpClientRequest.setHeader("authorization", "[redacted]"), HttpClientRequest.setHeader("chatgpt-account-id", "[redacted]")), headers = Object.fromEntries(["authorization", "chatgpt-account-id", "originator"].flatMap((key) => {
+      const value = request.headers[key];
+      return value === void 0 ? [] : [[key, value]];
+    }));
+    headers["openai-beta"] = WEBSOCKET_BETA;
+    headers["user-agent"] = `pi (${process.platform} ${release()}; ${process.arch})`;
+    const requestId = sessionIdFor(body.prompt_cache_key);
+    body.prompt_cache_key = requestId;
+    headers["session-id"] = requestId;
+    headers["x-client-request-id"] = requestId;
+    const socket = new WebSocket(websocketUrl(url), { headers }), state = { settled: !1 }, stream = new ReadableStream({
+      start: (value) => {
+        state.controller = value;
+      },
+      cancel: () => socket.close(1000, "cancelled")
+    }), fail = (cause) => {
+      if (!state.settled) {
+        state.settled = !0;
+        reject(cause);
+      } else
+        state.controller?.error(cause);
+      socket.close(1011, "transport error");
+    }, abort = () => fail(Error("OpenAI subscription request aborted"));
+    signal.addEventListener("abort", abort, { once: !0 });
+    socket.addEventListener("open", () => {
+      Either.match(Either.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 });
+    });
+    socket.addEventListener("message", (event) => {
+      Either.match(Either.try(() => {
+        const text = eventText(event.data);
+        if (text === void 0)
+          return;
+        const parsed = normalizeOpenAiCodexWebSocketEvent(JSON.parse(text)), type = parsed.type;
+        if (isOpenAiCodexControlEvent(type))
+          return;
+        if (type === "error") {
+          fail(Error(JSON.stringify(parsed)));
+          return;
+        }
+        state.controller?.enqueue(new TextEncoder().encode(`data: ${JSON.stringify(parsed)}
+
+`));
+        if (type === "response.completed" || type === "response.incomplete" || type === "response.failed") {
+          state.controller?.close();
+          signal.removeEventListener("abort", abort);
+          socket.close(1000, "done");
+        }
+      }), { onLeft: fail, onRight: () => {
+        return;
+      } });
+    });
+    socket.addEventListener("error", (event) => fail(event.error ?? Error(event.message || "WebSocket handshake failed")));
+    socket.addEventListener("close", (event) => {
+      if (event.code !== 1000)
+        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
+  })
+}));

package/dist/llm/providers.d.ts

@@ -0,0 +1,37 @@
+import { LanguageModel } from "@effect/ai";
+import { HttpClient } from "@effect/platform";
+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
+ * 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
+ * (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";
+/** Pure protocol routing decision; provider details stay inside this adapter. */
+export declare const usesOpenCodeResponses: (modelId: string) => boolean;
+export interface BuiltProvider {
+    readonly svc: LanguageModel.Service;
+    /** Anthropic subscription auth requires the Claude Code system block first. */
+    readonly prependClaudeCode: boolean;
+}
+/** Prepend the Claude Code system block (subscription-auth requirement). */
+export declare const prependClaudeCode: (options: unknown) => unknown;
+/**
+ * Anthropic prompt caching is OPT-IN per request: stamp ephemeral
+ * `cache_control` breakpoints on the last system message + the last two
+ * non-system messages. Marker placement is not part of Anthropic's content
+ * hash, so the markers moving forward each turn never invalidates earlier
+ * prefixes. Messages already carrying an explicit `cacheControl` are left
+ * alone.
+ */
+export declare const withAnthropicCacheBreakpoints: (options: unknown) => unknown;
+export declare const buildProvider: (selection: ModelSelection, credential: Credential | undefined, key: Redacted.Redacted<string> | undefined) => Effect.Effect<BuiltProvider, AuthError, HttpClient.HttpClient | Scope.Scope>;