@xandreed/plugin-models 0.13.0 → 0.15.0

package/dist/llm/compat.js

@@ -1,59 +1,113 @@
-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.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(AiError.make({
-      module: moduleName,
-      method,
-      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(AiError.make({
-      module: moduleName,
-      method,
-      reason: new AiError.UnknownError({ description: `CreditsError: ${message || "provider quota exhausted"}` })
-    }));
-  return Option.none();
-}), 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) => ({
+import { AiError, LanguageModel, Prompt, Tool } from "effect/ai";
+import { Cause, Effect, Match, MutableRef, Option, Ref, Schema, Stream } from "effect";
+import { Base64 } from "effect/encoding";
+import { FetchHttpClient, HttpClient, HttpClientError, HttpClientRequest } from "effect/http";
+import { isTurnError, ModelId, ModelSelection, ProviderId, CurrentModelCallPolicy, CurrentPromptCacheKey, describeModel, ImageMediaType, mediaLabel, reasonOf } from "@xandreed/core";
+import { strictJsonSchema, toolParametersSchema } from "@xandreed/core/internal";
+import { finishReasonFromWire, sseStreamParts, toolCallParams, usageFromCompletion } from "./sse.js";
+import { decodeChatCompletion, gatewayErrorOf, isModelRejection, isQuotaExhausted } from "./chat-wire.entity.functions.js";
+import { publicReasoningEffort } from "./modelCatalog.js";
+import { redactCredentials } from "../transport/http-proxy.entity.functions.js";
+import { transportFetch } from "../transport/models-transport.adapter.js";
+import { completeModelAttempt, modelAttemptOf, observeModelAttempt, retainModelAttempt } from "./model-completion.adapter.js";
+import { ProviderUsageBody } from "./model-usage.entity.js";
+import { resilientRequest, withModelRequestCall, withModelRequestStream } from "../transport/resilient-http-client.adapter.js";
+import { classifyAiError } from "./provider-failure.entity.functions.js";
+import { annotateCompatRequest, observeCompatUsage } from "./compat-telemetry.adapter.js";
+const gatewayFailure = (moduleName, status, body, http) => {
+  const error = gatewayErrorOf(body), message = Option.getOrElse(Option.flatMap(error, (found) => Option.fromNullishOr(found.message)), () => "");
+  if (Option.exists(error, isModelRejection))
+    return new AiError.InvalidRequestError({ description: message.length > 0 ? message : "the selected model is not supported" });
+  if (isQuotaExhausted(Option.some(status), error))
+    return new AiError.QuotaExhaustedError({ metadata: { [moduleName]: { ...Option.getOrElse(error, () => ({})) } }, http });
+  return AiError.reasonFromHttpStatus({ status, http, description: body.slice(0, 500) });
+}, aiUnknown = (moduleName, method, error) => {
+  const cause = HttpClientError.isHttpClientError(error) && error.cause !== void 0 ? error.cause : error;
+  return AiError.isAiError(cause) || isTurnError(cause) ? cause : AiError.make({ module: moduleName, method, reason: new AiError.UnknownError({ description: redactCredentials(reasonOf(Cause.die(cause))) }) });
+}, invalidOutput = (moduleName, method, description) => AiError.make({ module: moduleName, method, reason: new AiError.InvalidOutputError({ description }) }), invalidResponse = (moduleName, method, description) => AiError.make({ module: moduleName, method, reason: new AiError.InvalidResponseError({ description }) }), requestInfo = (chatUrl) => ({
   method: "POST",
   url: chatUrl,
   urlParams: [],
   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)
+}), isImageType = Schema.is(ImageMediaType), decodedBytes = (data) => {
+  if (typeof data !== "string")
+    return data.length;
+  const base64 = data.replace(/^data:[^,]*;base64,/i, "").replace(/\s+/g, ""), padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+  return Math.max(0, Math.floor(base64.length * 3 / 4) - padding);
+}, filePartLabel = (part) => {
+  const data = part.data;
+  return isImageType(part.mediaType) && !(data instanceof URL) ? mediaLabel({ mediaType: part.mediaType, bytes: decodedBytes(data), ...part.fileName === void 0 ? {} : { name: part.fileName } }) : `[file omitted: ${[part.mediaType, ...part.fileName === void 0 ? [] : [part.fileName]].join(", ")}]`;
+}, isSendableImage = (part) => isImageType(part.mediaType), imageUrlPart = (part) => {
+  const data = part.data;
+  return { type: "image_url", image_url: { url: data instanceof URL ? data.toString() : data instanceof Uint8Array ? `data:${part.mediaType};base64,${Base64.encode(data)}` : /^(data:|https?:\/\/)/i.test(data) ? data : `data:${part.mediaType};base64,${data}` } };
+}, nonEmpty = (line) => line.length > 0, toolResultText = (part, images) => part.modelOutput === void 0 ? typeof part.result === "string" ? part.result : JSON.stringify(part.result ?? null) : part.modelOutput.flatMap((output) => output.type === "text" ? [output.text] : images && isSendableImage(output) ? [] : [filePartLabel(output)]).filter(nonEmpty).join(`
+`), userText = (message) => {
+  const text = message.content.flatMap((p) => p.type === "text" ? [p.text] : []).join(""), labels = message.content.flatMap((p) => p.type === "file" ? [filePartLabel(p)] : []);
+  return [text, ...labels].filter(nonEmpty).join(`
+`);
+}, contentParts = (content) => typeof content === "string" ? content.length === 0 ? [] : [{ type: "text", text: content }] : Array.isArray(content) ? content : [], USER_CAPTION = "The user's message:", flush = (fold) => fold.pending.length === 0 ? fold.out : [...fold.out, { role: "user", content: fold.pending }];
+export const toChatMessages = (prompt, options = {}) => {
+  const images = options.images ?? !1, userMessage = (message) => {
+    if (!(images && message.content.some((p) => p.type === "file" && isSendableImage(p))))
+      return { role: "user", content: userText(message) };
+    return {
+      role: "user",
+      content: message.content.flatMap((p) => p.type === "text" ? p.text.length === 0 ? [] : [{ type: "text", text: p.text }] : isSendableImage(p) ? [imageUrlPart(p)] : [{ type: "text", text: filePartLabel(p) }])
+    };
+  }, folded = prompt.content.reduce((fold, message) => Match.value(message).pipe(Match.discriminatorsExhaustive("role")({
+    user: (asked) => {
+      const user = userMessage(asked);
+      if (fold.pending.length === 0)
+        return { out: [...fold.out, user], pending: [] };
+      const parts = contentParts(user.content), own = parts.some((part) => typeof part === "object" && part !== null && ("type" in part) && part.type === "image_url");
+      return { out: [...fold.out, { role: "user", content: [...fold.pending, ...own ? [{ type: "text", text: USER_CAPTION }] : [], ...parts] }], pending: [] };
+    },
+    tool: (tool) => {
+      const results = tool.content.flatMap((p) => p.type === "tool-result" && !p.providerExecuted ? [p] : []), sent = results.flatMap((p) => {
+        const parts = images ? (p.modelOutput ?? []).flatMap((output) => output.type === "file" && isSendableImage(output) ? [output] : []) : [];
+        return parts.length === 0 ? [] : [{ type: "text", text: `Images returned by ${p.name} (call ${p.id}):` }, ...parts.map(imageUrlPart)];
+      }), toolMessages = results.map((p) => {
+        const text = toolResultText(p, images), hasImages = images && (p.modelOutput ?? []).some((output) => output.type === "file" && isSendableImage(output));
+        return { role: "tool", tool_call_id: p.id, content: text.length === 0 && hasImages ? "[the images this call returned follow]" : text };
+      });
+      return { out: [...fold.out, ...toolMessages], pending: [...fold.pending, ...sent] };
+    },
+    system: (system) => ({ out: [...flush(fold), { role: "system", content: system.content }], pending: [] }),
+    assistant: (assistant) => {
+      const text = assistant.content.flatMap((p) => p.type === "text" ? [p.text] : []).join(""), toolCalls = assistant.content.flatMap((p) => p.type === "tool-call" && !p.providerExecuted ? [
+        {
+          id: p.id,
+          type: "function",
+          function: { name: p.name, arguments: JSON.stringify(p.params ?? {}) }
+        }
+      ] : []);
+      return {
+        out: [...flush(fold), {
+          role: "assistant",
+          content: text.length > 0 ? text : null,
+          ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+        }],
+        pending: []
+      };
     }
-  ] : []);
-}), toChatTools = (tools) => tools.flatMap((tool) => Tool.isUserDefined(tool) ? [
+  })), { out: [], pending: [] });
+  return flush(folded);
+}, promptWithImageLabels = (prompt) => Prompt.fromMessages(prompt.content.map((message) => Match.value(message).pipe(Match.discriminatorsExhaustive("role")({
+  user: (user) => user.content.some((p) => p.type === "file") ? Prompt.makeMessage("user", { content: [Prompt.makePart("text", { text: userText(user) })], options: user.options }) : user,
+  tool: (tool) => tool.content.some((p) => p.type === "tool-result" && p.modelOutput !== void 0) ? Prompt.makeMessage("tool", {
+    content: tool.content.map((p) => p.type !== "tool-result" || p.modelOutput === void 0 ? p : Prompt.makePart("tool-result", {
+      id: p.id,
+      name: p.name,
+      isFailure: p.isFailure,
+      result: toolResultText(p, !1),
+      providerExecuted: p.providerExecuted,
+      options: p.options
+    })),
+    options: tool.options
+  }) : tool,
+  system: (system) => system,
+  assistant: (assistant) => assistant
+})))), toChatTools = (tools) => tools.flatMap((tool) => Tool.isUserDefined(tool) ? [
   {
     type: "function",
     function: {
@@ -66,10 +120,10 @@ export const toChatMessages = (prompt) => prompt.content.flatMap((message) => {
 const toToolChoice = (choice) => {
   if (choice === "none" || choice === "required")
     return choice;
-  if (typeof choice === "object" && choice !== null && "tool" in choice)
+  if (typeof choice === "object" && "tool" in choice)
     return {
       type: "function",
-      function: { name: choice.tool }
+      function: { name: String(choice.tool) }
     };
   return "auto";
 };
@@ -81,27 +135,24 @@ export const thinkingParams = (model) => {
   if (/qwen/i.test(model))
     return { enable_thinking: !0 };
   return {};
-}, fromChatCompletion = (moduleName, body) => Effect.gen(function* () {
+}, fromChatCompletion = Effect.fnUntraced(function* (moduleName, body, reading = {}) {
   const choice = body.choices?.[0];
   if (choice === void 0)
-    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",
-      id: tc.id ?? "",
-      name: tc.function?.name ?? "",
-      params: JSON.parse(tc.function?.arguments ?? "{}")
-    }),
-    catch: () => invalidOutput(moduleName, "generateText", `tool call ${tc.function?.name ?? "?"} carried unparseable JSON arguments`)
-  }));
+    return yield* Effect.fail(invalidResponse(moduleName, "generateText", "the completion carried no choices"));
+  const message = choice.message ?? {}, reasoning = message.reasoning_content ?? message.reasoning, text = message.content, calls = message.tool_calls ?? [], reason = finishReasonFromWire(Option.fromNullishOr(choice.finish_reason), calls.length > 0), toolCalls = yield* Effect.forEach(calls, (tc) => toolCallParams(tc.function?.arguments ?? "{}", reason, () => invalidOutput(moduleName, "generateText", `tool call ${tc.function?.name ?? "?"} carried unparseable JSON arguments`)).pipe(Effect.map((params) => ({
+    type: "tool-call",
+    id: tc.id ?? "",
+    name: tc.function?.name ?? "",
+    params
+  }))), { concurrency: 1 });
   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)
+      reason,
+      usage: usageFromCompletion(body.usage, reading)
     }
   ];
 });
@@ -115,16 +166,16 @@ const requestSettings = (config, cacheKey, policy) => ({
       onNone: () => ({}),
       onSome: (value) => ({
         ...value.maxOutputTokens === void 0 ? {} : { max_tokens: value.maxOutputTokens },
-        ...config.thinking === "disabled" || config.reasoningEffort !== void 0 ? {} : { reasoning_effort: value.effort }
+        ...config.thinking === "disabled" || config.reasoningEffort !== void 0 ? {} : { reasoning_effort: publicReasoningEffort(value.effort) }
       })
     })
   }
-}), chatRequestBody = (config, options, streaming) => Effect.all({ cacheKey: Effect.service(CurrentPromptCacheKey), policy: Effect.service(CurrentModelCallPolicy) }).pipe(Effect.map(({ cacheKey, policy }) => {
+}), chatRequestBody = (config, options, streaming) => Effect.all({ cacheKey: Effect.service(CurrentPromptCacheKey), policy: Effect.service(CurrentModelCallPolicy) }, { concurrency: 1 }).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),
+    messages: toChatMessages(options.prompt, { images: config.images ?? !1 }),
     stream: streaming,
     ...options.responseFormat.type === "json" ? { response_format: {
       type: "json_schema",
@@ -134,68 +185,84 @@ const requestSettings = (config, cacheKey, policy) => ({
     ...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.andThen(Effect.tryPromise({
-    try: async (signal) => {
-      const response = await (config.fetchImpl ?? fetch)(config.chatUrl, {
-        signal,
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          ...config.apiKey === void 0 || config.apiKey.length === 0 ? {} : { 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);
+})), postChat = (config, method, body, buffered = !1, observeUsage) => {
+  const selected = {}, guarded = Effect.gen(function* () {
+    const client = yield* Effect.service(HttpClient.HttpClient).pipe(Effect.provide(FetchHttpClient.layer)), metadata = yield* Ref.make({ statusText: "" }), fetch = config.fetchImpl ?? (yield* FetchHttpClient.Fetch), trackedFetch = transportFetch({ fetch: (input, init) => fetch(input, init).then((response) => {
+      if (init?.signal?.aborted !== !0)
+        MutableRef.set(metadata.ref, { statusText: response.statusText });
+      return response;
+    }) }), response = yield* resilientRequest(client, HttpClientRequest.post(config.chatUrl).pipe(HttpClientRequest.setHeaders({
+      "content-type": "application/json",
+      ...config.apiKey === void 0 || config.apiKey.length === 0 ? {} : { authorization: `Bearer ${config.apiKey}` }
+    }), HttpClientRequest.bodyJsonUnsafe(body)), { protocol: "compat", settled: buffered, ...config.beforeRequest === void 0 ? {} : { beforeSend: config.beforeRequest(body) } }).pipe(Effect.provideService(FetchHttpClient.Fetch, trackedFetch)), content = buffered ? yield* response.arrayBuffer : yield* Stream.toReadableStreamEffect(response.stream);
+    if (buffered && content instanceof ArrayBuffer) {
+      const body = Schema.decodeUnknownOption(Schema.fromJsonString(ProviderUsageBody))(new TextDecoder().decode(content));
+      yield* Option.match(body, { onNone: () => Effect.void, onSome: (value) => observeModelAttempt(response.modelAttempt.completion, value.usage, !0, config.usage?.reasoning ?? !0).pipe(Effect.andThen(observeUsage?.(value.usage, !0) ?? Effect.void)) });
+      yield* completeModelAttempt(response.modelAttempt.completion, { _tag: "Completed" });
+    }
+    const { statusText } = yield* Ref.get(metadata);
+    return yield* Effect.try({
+      try: () => retainModelAttempt(response, Object.defineProperty(new Response([204, 205, 304].includes(response.status) ? null : content, {
+        status: response.status,
+        statusText,
+        headers: response.headers
+      }), "url", { value: response.url })),
+      catch: (error) => aiUnknown(config.moduleName, method, error)
+    });
+  }).pipe(Effect.catch((error) => isTurnError(error) ? Effect.die(error) : Effect.fail(aiUnknown(config.moduleName, method, error)))).pipe(Effect.tap((response) => Effect.sync(() => {
+    selected.response = response;
+  }))).pipe(Effect.catch((error) => isTurnError(error) ? Effect.die(error) : Effect.fail(error)));
+  return config.aroundRequest === void 0 ? guarded : config.aroundRequest(body, guarded).pipe(Effect.map((returned) => selected.response === void 0 ? returned : retainModelAttempt(selected.response, returned)));
 }, 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 = {};
+  }), headers = {};
   res.headers.forEach((value, headerName) => {
     headers[headerName] = value;
   });
   return yield* Effect.fail(AiError.make({
     module: config.moduleName,
     method,
-    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)
+    reason: gatewayFailure(config.moduleName, res.status, text, {
+      request: requestInfo(config.chatUrl),
+      response: { status: res.status, headers },
+      body: 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: () => invalidOutput(config.moduleName, "generateText", `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(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 } };
-})))));
+export const makeCompatLanguageModel = (config) => {
+  const selection = new ModelSelection({ provider: ProviderId.make(config.moduleName), modelId: ModelId.make(config.model) });
+  return LanguageModel.make({
+    generateText: (options) => withModelRequestCall(options.responseFormat.type === "json" ? "Object" : "Text", selection, Effect.gen(function* () {
+      yield* annotateCompatRequest(options.span, config.moduleName, config.model);
+      const res = yield* postChat(config, "generateText", yield* chatRequestBody(config, options, !1), !0, (usage, final) => observeCompatUsage(options.span, usage, final, config.usage?.reasoning ?? !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* decodeChatCompletion(config.moduleName, text);
+      return yield* fromChatCompletion(config.moduleName, parsed, config.usage);
+    })).pipe(Effect.catch((error) => isTurnError(error) ? Effect.die(error) : Effect.fail(classifyAiError(error, "compat")))),
+    streamText: (options) => withModelRequestStream("Stream", selection, Stream.unwrap(Effect.gen(function* () {
+      yield* annotateCompatRequest(options.span, config.moduleName, config.model);
+      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(invalidResponse(config.moduleName, "streamText", "the streaming response carried no body"));
+      return sseStreamParts({
+        moduleName: config.moduleName,
+        body,
+        attempt: modelAttemptOf(res),
+        ...config.usage === void 0 ? {} : { usage: config.usage },
+        observeUsage: (usage, final) => observeCompatUsage(options.span, usage, final, config.usage?.reasoning ?? !0)
+      });
+    }))).pipe(Stream.catch((error) => isTurnError(error) ? Stream.die(error) : Stream.fail(classifyAiError(error, "compat"))))
+  }).pipe(Effect.map((model) => describeModel(model, Effect.all({ cacheKey: Effect.service(CurrentPromptCacheKey), policy: Effect.service(CurrentModelCallPolicy) }, { concurrency: 1 }).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/model-completion.adapter.d.ts

@@ -0,0 +1,49 @@
+import { Deferred, Effect, Exit, Option, Ref } from "effect";
+import { ModelCallId } from "@xandreed/core";
+import type { ModelCallMethod, ModelCallOutcome, ModelCallPurpose, ModelCallRecorder, ModelSelection, RunId, RunOrdinal, TurnError } from "@xandreed/core";
+import type { ProviderFailureProtocol } from "./provider-failure.entity.js";
+import { ModelCompletionState } from "./model-completion.entity.js";
+import type { ProviderUsageObservation } from "./model-usage.entity.js";
+export interface ModelCompletionCall {
+    readonly callId: ModelCallId;
+    readonly attempts: Ref.Ref<ReadonlyArray<ModelAttempt>>;
+}
+export interface ModelAttempt {
+    readonly callId: ModelCallId;
+    readonly ordinal: number;
+    readonly startedAt: number;
+    readonly protocol: ProviderFailureProtocol;
+    readonly purpose: ModelCallPurpose;
+    readonly method: ModelCallMethod;
+    readonly model: Option.Option<ModelSelection>;
+    readonly runId: Option.Option<RunId>;
+    readonly run: Option.Option<RunOrdinal>;
+    readonly step: Option.Option<number>;
+    readonly recorder: ModelCallRecorder;
+    readonly usage: Ref.Ref<ProviderUsageObservation>;
+    readonly phase: Ref.Ref<ModelCompletionState>;
+    readonly ack: Deferred.Deferred<void, TurnError>;
+}
+export declare const makeCompletionCall: () => Effect.Effect<ModelCompletionCall, never, never>;
+export declare const beginModelAttempt: (call: ModelCompletionCall, ordinal: number, protocol: "anthropic" | "openai" | "compat") => Effect.Effect<ModelAttempt, never, never>;
+export declare const modelAttemptOf: (response: object) => Option.Option<ModelAttempt>;
+export declare const retainModelAttempt: <A extends object>(source: object, target: A) => A;
+export declare const attachModelAttempt: <A extends object>(attempt: ModelAttempt, response: A) => A;
+export declare const observeModelAttempt: (attempt: ModelAttempt, value: unknown, final: boolean, reasoning?: boolean) => Effect.Effect<void>;
+export declare const completeModelAttempt: (attempt: ModelAttempt, outcome: {
+    readonly _tag: "Completed";
+} | {
+    readonly _tag: "Failed";
+    readonly failure: Option.Option<"Unknown" | "ContextOverflow" | "Authentication" | "InvalidRequest" | "RateLimit" | "Quota" | "Transient" | "InvalidResponse" | "Timeout">;
+} | {
+    readonly _tag: "Interrupted";
+}) => Effect.Effect<void, TurnError, never>;
+export declare const modelOutcomeOfExit: <A, E>(exit: Exit.Exit<A, E>) => ModelCallOutcome;
+/** Provider/SDK cleanup settles only attempts that no raw boundary has already claimed. */
+export declare const completePendingAttempts: <A, E>(call: ModelCompletionCall, exit: Exit.Exit<A, E>) => Effect.Effect<void, TurnError, never>;
+export declare const observeResponseUsage: (response: object, value: unknown, final: boolean, reasoning?: boolean) => Effect.Effect<void>;
+export declare const completeResponseAttempt: (response: object, outcome: ModelCallOutcome) => Effect.Effect<void, TurnError>;
+/** The fixed native SDK client surface has AiError only; retain the original recorder failure as a defect. */
+export declare const completeSdkResponseAttempt: (response: object, outcome: ModelCallOutcome) => Effect.Effect<void>;
+/** Rejected/compat JSON can report usage even when no SDK completion is accepted. */
+export declare const observeModelBody: (attempt: ModelAttempt, body: string, final: boolean, reasoning?: boolean) => Effect.Effect<void>;

package/dist/llm/model-completion.adapter.js

@@ -0,0 +1,77 @@
+import { Cause, Clock, Deferred, Effect, Exit, Option, Ref, Schema } from "effect";
+import { CurrentAgentRun, CurrentAgentStep, CurrentModelCallRecorder, ModelCallId, modelFailureOf, recordCompletion } from "@xandreed/core";
+import { randomUuid } from "@xandreed/core/internal";
+import { CurrentModelCallMethod, CurrentModelCallPurpose, CurrentModelCallSelection } from "../ports/model-call-completion.port.js";
+import { ModelCompletionState } from "./model-completion.entity.js";
+import { claimModelCompletion } from "./model-completion.entity.functions.js";
+import { noProviderUsage, ProviderUsageBody } from "./model-usage.entity.js";
+import { modelCallUsageOf, observeProviderUsage, providerUsageCounts } from "./model-usage.entity.functions.js";
+const attempts = new WeakMap;
+export const makeCompletionCall = Effect.fnUntraced(function* () {
+  return { callId: ModelCallId.make(yield* randomUuid), attempts: yield* Ref.make([]) };
+}), beginModelAttempt = Effect.fnUntraced(function* (call, ordinal, protocol) {
+  const run = yield* CurrentAgentRun, attempt = {
+    callId: call.callId,
+    ordinal,
+    protocol,
+    startedAt: yield* Clock.currentTimeMillis,
+    purpose: yield* CurrentModelCallPurpose,
+    method: yield* CurrentModelCallMethod,
+    model: yield* CurrentModelCallSelection,
+    runId: Option.map(run, (value) => value.id),
+    run: Option.map(run, (value) => value.ordinal),
+    step: Option.isSome(run) ? yield* CurrentAgentStep : Option.none(),
+    recorder: yield* CurrentModelCallRecorder,
+    usage: yield* Ref.make(noProviderUsage),
+    phase: yield* Ref.make({ _tag: "Open" }),
+    ack: yield* Deferred.make()
+  };
+  yield* Ref.update(call.attempts, (before) => [...before, attempt]);
+  return attempt;
+}), modelAttemptOf = (response) => Option.fromNullishOr(attempts.get(response)), retainModelAttempt = (source, target) => {
+  Option.match(modelAttemptOf(source), { onNone: () => {
+    return;
+  }, onSome: (attempt) => attempts.set(target, attempt) });
+  return target;
+}, attachModelAttempt = (attempt, response) => {
+  attempts.set(response, attempt);
+  return response;
+}, observeModelAttempt = (attempt, value, final, reasoning = !0) => Option.match(providerUsageCounts(attempt.protocol, value, reasoning), {
+  onNone: () => Effect.void,
+  onSome: (counts) => Ref.update(attempt.usage, (before) => observeProviderUsage(before, counts, final))
+}), completeModelAttempt = Effect.fn("models.record_attempt")(function* (attempt, outcome) {
+  return yield* Effect.uninterruptible(Effect.gen(function* () {
+    if (!(yield* Ref.modify(attempt.phase, claimModelCompletion)))
+      return yield* Deferred.await(attempt.ack);
+    const data = {
+      callId: attempt.callId,
+      attempt: attempt.ordinal,
+      purpose: attempt.purpose,
+      method: attempt.method,
+      model: attempt.model,
+      runId: attempt.runId,
+      run: attempt.run,
+      step: attempt.step,
+      durationMs: Math.max(0, (yield* Clock.currentTimeMillis) - attempt.startedAt),
+      usage: modelCallUsageOf(attempt.protocol, yield* Ref.get(attempt.usage)),
+      outcome
+    }, result = yield* Effect.exit(recordCompletion(data).pipe(Effect.provideService(CurrentModelCallRecorder, attempt.recorder))), phase = Exit.isSuccess(result) ? { _tag: "Recorded" } : { _tag: "RecordFailed" };
+    yield* Ref.set(attempt.phase, phase);
+    yield* Deferred.done(attempt.ack, result);
+    return yield* Exit.match(result, { onSuccess: () => Effect.void, onFailure: Effect.failCause });
+  }));
+}), modelOutcomeOfExit = (exit) => Exit.match(exit, {
+  onSuccess: () => ({ _tag: "Completed" }),
+  onFailure: (cause) => Cause.hasInterrupts(cause) ? { _tag: "Interrupted" } : { _tag: "Failed", failure: modelFailureOf(Cause.squash(cause)) }
+}), completePendingAttempts = Effect.fnUntraced(function* (call, exit) {
+  yield* Effect.forEach(yield* Ref.get(call.attempts), (attempt) => Effect.flatMap(Ref.get(attempt.phase), (state) => ModelCompletionState.match(state, { Open: () => completeModelAttempt(attempt, modelOutcomeOfExit(exit)), Recorded: () => Effect.void, Recording: () => Deferred.await(attempt.ack), RecordFailed: () => Deferred.await(attempt.ack) })), { concurrency: 1, discard: !0 });
+}), observeResponseUsage = (response, value, final, reasoning = !0) => Option.match(modelAttemptOf(response), {
+  onNone: () => Effect.void,
+  onSome: (attempt) => observeModelAttempt(attempt, value, final, reasoning)
+}), completeResponseAttempt = (response, outcome) => Option.match(modelAttemptOf(response), {
+  onNone: () => Effect.void,
+  onSome: (attempt) => completeModelAttempt(attempt, outcome)
+}), completeSdkResponseAttempt = (response, outcome) => completeResponseAttempt(response, outcome).pipe(Effect.catch((error) => Effect.die(error))), observeModelBody = (attempt, body, final, reasoning = !0) => Option.match(Schema.decodeUnknownOption(Schema.fromJsonString(ProviderUsageBody))(body), {
+  onNone: () => Effect.void,
+  onSome: (value) => observeModelAttempt(attempt, value.usage, final, reasoning)
+});

package/dist/llm/model-completion.entity.d.ts

@@ -0,0 +1,4 @@
+import { Schema } from "effect";
+/** The ACK result lives in one Deferred; this phase controls claiming and outer cleanup. */
+export declare const ModelCompletionState: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"Open", {}>, Schema.TaggedStruct<"Recording", {}>, Schema.TaggedStruct<"Recorded", {}>, Schema.TaggedStruct<"RecordFailed", {}>]>;
+export type ModelCompletionState = typeof ModelCompletionState.Type;

package/dist/llm/model-completion.entity.functions.d.ts

@@ -0,0 +1,3 @@
+import { ModelCompletionState } from "./model-completion.entity.js";
+/** Only the first terminal observation owns the durable append and its ACK. */
+export declare const claimModelCompletion: (state: ModelCompletionState) => readonly [boolean, ModelCompletionState];

package/dist/llm/model-completion.entity.functions.js

@@ -0,0 +1,7 @@
+import { ModelCompletionState } from "./model-completion.entity.js";
+export const claimModelCompletion = (state) => ModelCompletionState.match(state, {
+  Open: () => [!0, { _tag: "Recording" }],
+  Recording: () => [!1, state],
+  Recorded: () => [!1, state],
+  RecordFailed: () => [!1, state]
+});

package/dist/llm/model-completion.entity.js

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+export const ModelCompletionState = Schema.Union([
+  Schema.TaggedStruct("Open", {}),
+  Schema.TaggedStruct("Recording", {}),
+  Schema.TaggedStruct("Recorded", {}),
+  Schema.TaggedStruct("RecordFailed", {})
+]).pipe(Schema.toTaggedUnion("_tag"));

package/dist/llm/model-retry-policy.entity.d.ts

@@ -0,0 +1,37 @@
+import { Schema } from "effect";
+/** One logical model request's bounded HTTP retries and pending-read timeouts. @public */
+export declare const ModelRetryPolicy: Schema.Struct<{
+    readonly maxAttempts: Schema.Int;
+    readonly requestTimeoutMs: Schema.Int;
+    readonly bodyIdleTimeoutMs: Schema.Int;
+    readonly totalTimeoutMs: Schema.Int;
+    readonly retryAfterMaxMs: Schema.Int;
+    readonly backoff: Schema.Struct<{
+        readonly initialMs: Schema.Int;
+        readonly maxMs: Schema.Int;
+        readonly jitter: Schema.Number;
+    }>;
+}>;
+export type ModelRetryPolicy = typeof ModelRetryPolicy.Type;
+/** Full defaults; an initial send counts toward maxAttempts. @public */
+export declare const modelRetryDefaults: ModelRetryPolicy;
+export declare const ModelRequestRung: Schema.Literals<readonly ["Primary", "Fallback"]>;
+export type ModelRequestRung = typeof ModelRequestRung.Type;
+/** Private attempt state, shared by one routed call and its distinct fallback. */
+export declare const ModelRequestState: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"Ready", {
+    readonly rung: Schema.Literals<readonly ["Primary", "Fallback"]>;
+    readonly attempts: Schema.Int;
+}>, Schema.TaggedStruct<"Sending", {
+    readonly rung: Schema.Literals<readonly ["Primary", "Fallback"]>;
+    readonly attempts: Schema.Int;
+}>, Schema.TaggedStruct<"Rejected", {
+    readonly rung: Schema.Literals<readonly ["Primary", "Fallback"]>;
+    readonly attempts: Schema.Int;
+    readonly kind: Schema.Literals<readonly ["ContextOverflow", "Authentication", "InvalidRequest", "RateLimit", "Quota", "Transient", "InvalidResponse", "Timeout", "Unknown"]>;
+    readonly replayable: Schema.Boolean;
+    readonly retryAt: Schema.optionalKey<Schema.Int>;
+}>, Schema.TaggedStruct<"Committed", {
+    readonly rung: Schema.Literals<readonly ["Primary", "Fallback"]>;
+    readonly attempts: Schema.Int;
+}>]>;
+export type ModelRequestState = typeof ModelRequestState.Type;

package/dist/llm/model-retry-policy.entity.functions.d.ts

@@ -0,0 +1,16 @@
+import { Option } from "effect";
+import type { ModelFailureKind } from "@xandreed/core";
+import { ModelRequestState } from "./model-retry-policy.entity.js";
+import type { ModelRetryPolicy } from "./model-retry-policy.entity.js";
+/** Parse a `retry-after` value: non-negative seconds (decimals as the provider SDKs read them) or an HTTP date, never arbitrary text. */
+export declare const retryAfterMillis: (value: string, now: number) => Option.Option<number>;
+/** Parse a `retry-after-ms` value: non-negative milliseconds. */
+export declare const retryAfterMsMillis: (value: string) => Option.Option<number>;
+/** A rejected response's server hint: `retry-after-ms` (milliseconds) first, then `retry-after`; none when neither parses. */
+export declare const retryHintMillis: (headers: Readonly<Record<string, unknown>>, now: number) => Option.Option<number>;
+/** One physical-attempt ordinal drives both bounded local delay and the capped server hint (milliseconds). */
+export declare const retryDelayMillis: (policy: ModelRetryPolicy, attempt: number, unit: number, hint: Option.Option<number>) => number;
+export declare const primaryAttemptLimit: (policy: ModelRetryPolicy, reserveFallback: boolean) => number;
+export declare const retryableModelFailure: (kind: ModelFailureKind) => boolean;
+export declare const startAttemptState: (state: ModelRequestState, policy: ModelRetryPolicy, reserveFallback: boolean) => Option.Option<ModelRequestState>;
+export declare const enterFallbackState: (state: ModelRequestState, policy: ModelRetryPolicy, reserveFallback: boolean) => Option.Option<ModelRequestState>;