okengine 0.21.1 → 0.23.0

package/src/docker/images-config.test.ts

@@ -71,21 +71,21 @@ describe("ImagesConfig nesting — recipe coverage", () => {
         image: "rustfs/rustfs:1.0.0",
       },
       {
-        images: { store: { index: "getmeili/meilisearch:v1.53" } },
+        images: { store: { index: "getmeili/meilisearch:v1.54" } },
         role: "store.index",
-        image: "getmeili/meilisearch:v1.53",
+        image: "getmeili/meilisearch:v1.54",
       },
       // channel.email
       {
-        images: { channel: { email: "axllent/mailpit:v1.31.1" } },
+        images: { channel: { email: "axllent/mailpit:v1.31.2" } },
         role: "channel.email",
-        image: "axllent/mailpit:v1.31.1",
+        image: "axllent/mailpit:v1.31.2",
       },
       // ai role: no compose recipes (BYO OKE_AI_URL) — not covered here
       {
-        images: { pgdog: "ghcr.io/pgdogdev/pgdog:v0.1.57" },
+        images: { pgdog: "ghcr.io/pgdogdev/pgdog:v0.1.59" },
         role: "pgdog",
-        image: "ghcr.io/pgdogdev/pgdog:v0.1.57",
+        image: "ghcr.io/pgdogdev/pgdog:v0.1.59",
       },
       { images: { proxy: "caddy:2-alpine" }, role: "proxy", image: "caddy:2-alpine" },
       { images: { proxy: "traefik:v3.1" }, role: "proxy", image: "traefik:v3.1" },
@@ -108,11 +108,11 @@ describe("ImagesConfig nesting — compose output parity", () => {
   test("nested config derives byte-identical output to its flat-shape equivalent", () => {
     const flatImages: Readonly<Record<string, string>> = {
       "store.sql": "postgres:18-alpine",
-      pgdog: "ghcr.io/pgdogdev/pgdog:v0.1.57",
+      pgdog: "ghcr.io/pgdogdev/pgdog:v0.1.59",
       "store.kv": "redis:8-alpine",
       "store.files": "rustfs/rustfs:1.0.0",
-      "store.index": "getmeili/meilisearch:v1.53",
-      "channel.email": "axllent/mailpit:v1.31.1",
+      "store.index": "getmeili/meilisearch:v1.54",
+      "channel.email": "axllent/mailpit:v1.31.2",
     };
 
     const nestedImages: ImagesConfig = {
@@ -120,10 +120,10 @@ describe("ImagesConfig nesting — compose output parity", () => {
         sql: "postgres:18-alpine",
         kv: "redis:8-alpine",
         files: "rustfs/rustfs:1.0.0",
-        index: "getmeili/meilisearch:v1.53",
+        index: "getmeili/meilisearch:v1.54",
       },
-      channel: { email: "axllent/mailpit:v1.31.1" },
-      pgdog: "ghcr.io/pgdogdev/pgdog:v0.1.57",
+      channel: { email: "axllent/mailpit:v1.31.2" },
+      pgdog: "ghcr.io/pgdogdev/pgdog:v0.1.59",
     };
 
     // Same nested→flat set, written in a different field order — proves the

package/src/docker/recipes/dragonfly.ts

@@ -1,7 +1,8 @@
 /**
- * Dragonfly image recipe — Redis-wire-compatible, multi-threaded alternative.
+ * Dragonfly image recipe — default `store.kv` pin.
  *
- * Peer of Redis / Valkey via `images["store.kv"]` (driver id stays `redis`).
+ * Redis-wire-compatible and multi-threaded. Peer of Redis / Valkey via
+ * `images["store.kv"]` (driver id stays `redis`).
  * Official image: `docker.dragonflydb.io/dragonflydb/dragonfly`.
  */
 

package/src/docker/recipes/redis.ts

@@ -1,5 +1,5 @@
 /**
- * Redis image recipe — default `store.kv` pin (`redis:*`).
+ * Redis image recipe — opt-in `store.kv` pin (`redis:*`).
  *
  * Valkey and Dragonfly are separate recipes — same `redis` driver /
  * `redis://` URL, different binaries. Pin via `images["store.kv"]`.

package/src/docker/stack-id.test.ts

@@ -163,7 +163,7 @@ describe("deriveInfrastructure instanceId", () => {
     const n = instancePortOffset(id);
     const result = deriveInfrastructure({
       images: {
-        "channel.email": "axllent/mailpit:v1.31.1",
+        "channel.email": "axllent/mailpit:v1.31.2",
         "store.files": "rustfs/rustfs:1.0.0",
       },
       app: `dev-${id}`,

package/src/drivers/ai-anthropic.ts

@@ -11,8 +11,11 @@ import type {
   AiDriver,
   AiModelClient,
   AiOpenOptions,
+  AiStreamChunk,
+  AiToolCall,
 } from "./ai-types.ts";
 import { hostFromUrl } from "./external.ts";
+import { preconnectFetch } from "./ai-preconnect.ts";
 
 const DEFAULT_BASE = "https://api.anthropic.com";
 const ANTHROPIC_VERSION = "2023-06-01";
@@ -30,10 +33,7 @@ export async function openAnthropic(options: AiOpenOptions = {}): Promise<AiMode
   const model = options.model ?? "claude-sonnet-4-20250514";
   const baseUrl = (options.baseUrl ?? DEFAULT_BASE).replace(/\/$/, "");
   const fetchFn = options.fetch ?? globalThis.fetch;
-  const preconnect = (fetchFn as { preconnect?: (href: string) => void }).preconnect;
-  if (typeof preconnect === "function") {
-    preconnect(baseUrl);
-  }
+  preconnectFetch(fetchFn, baseUrl);
   const host = hostFromUrl(baseUrl);
   const external = host
     ? {
@@ -48,21 +48,10 @@ export async function openAnthropic(options: AiOpenOptions = {}): Promise<AiMode
     model,
     async complete(opts: AiCompleteOptions): Promise<AiCompleteResult> {
       const resolvedModel = opts.model ?? model;
-      const { system, messages } = splitSystem(opts.messages);
       const res = await fetchFn(`${baseUrl}/v1/messages`, {
         method: "POST",
-        headers: {
-          "content-type": "application/json",
-          "x-api-key": apiKey,
-          "anthropic-version": ANTHROPIC_VERSION,
-        },
-        body: JSON.stringify({
-          model: resolvedModel,
-          max_tokens: opts.maxTokens ?? 1024,
-          ...(opts.temperature !== undefined ? { temperature: opts.temperature } : {}),
-          ...(system !== undefined ? { system } : {}),
-          messages,
-        }),
+        headers: anthropicHeaders(apiKey),
+        body: JSON.stringify(anthropicBody(resolvedModel, opts)),
         ...(opts.signal !== undefined ? { signal: opts.signal } : {}),
       });
       const raw = (await res.json().catch(() => ({}))) as AnthropicMessagesResponse;
@@ -71,11 +60,13 @@ export async function openAnthropic(options: AiOpenOptions = {}): Promise<AiMode
         throw new Error(`anthropic: ${msg}`);
       }
       const text = textFromContent(raw.content);
+      const toolCalls = toolCallsFromContent(raw.content);
       return {
         text,
         raw,
         model: raw.model ?? resolvedModel,
         driverId: "anthropic",
+        ...(toolCalls !== undefined ? { toolCalls } : {}),
         usage: {
           inputTokens: raw.usage?.input_tokens,
           outputTokens: raw.usage?.output_tokens,
@@ -83,6 +74,21 @@ export async function openAnthropic(options: AiOpenOptions = {}): Promise<AiMode
         ...(external !== undefined ? { external } : {}),
       };
     },
+    async *stream(opts: AiCompleteOptions): AsyncIterable<AiStreamChunk> {
+      const resolvedModel = opts.model ?? model;
+      const res = await fetchFn(`${baseUrl}/v1/messages`, {
+        method: "POST",
+        headers: anthropicHeaders(apiKey),
+        body: JSON.stringify({ ...anthropicBody(resolvedModel, opts), stream: true }),
+        ...(opts.signal !== undefined ? { signal: opts.signal } : {}),
+      });
+      if (!res.ok) {
+        const raw = (await res.json().catch(() => ({}))) as AnthropicMessagesResponse;
+        const msg = raw.error?.message ?? `anthropic HTTP ${res.status}`;
+        throw new Error(`anthropic: ${msg}`);
+      }
+      yield* readAnthropicSse(res, opts.signal);
+    },
   };
 }
 
@@ -92,9 +98,17 @@ export const anthropicAiDriver: AiDriver = {
   open: openAnthropic,
 };
 
+interface AnthropicBlock {
+  readonly type?: string;
+  readonly text?: string;
+  readonly id?: string;
+  readonly name?: string;
+  readonly input?: unknown;
+}
+
 interface AnthropicMessagesResponse {
   readonly model?: string;
-  readonly content?: readonly { readonly type?: string; readonly text?: string }[];
+  readonly content?: readonly AnthropicBlock[];
   readonly usage?: {
     readonly input_tokens?: number;
     readonly output_tokens?: number;
@@ -102,19 +116,70 @@ interface AnthropicMessagesResponse {
   readonly error?: { readonly message?: string };
 }
 
+function anthropicHeaders(apiKey: string): Record<string, string> {
+  return {
+    "content-type": "application/json",
+    "x-api-key": apiKey,
+    "anthropic-version": ANTHROPIC_VERSION,
+  };
+}
+
+function anthropicBody(model: string, opts: AiCompleteOptions): Record<string, unknown> {
+  const { system, messages } = splitSystem(opts.messages);
+  return {
+    model,
+    max_tokens: opts.maxTokens ?? 1024,
+    ...(opts.temperature !== undefined ? { temperature: opts.temperature } : {}),
+    ...(system !== undefined ? { system } : {}),
+    messages,
+    ...(opts.tools !== undefined && opts.tools.length > 0
+      ? {
+          tools: opts.tools.map((tool) => ({
+            name: tool.name,
+            ...(tool.description !== undefined ? { description: tool.description } : {}),
+            input_schema: tool.parameters ?? { type: "object", properties: {} },
+          })),
+        }
+      : {}),
+  };
+}
+
 function splitSystem(messages: AiCompleteOptions["messages"]): {
   system?: string;
-  messages: Array<{ role: "user" | "assistant"; content: string }>;
+  messages: Array<{ role: "user" | "assistant"; content: unknown }>;
 } {
   const systemParts: string[] = [];
-  const out: Array<{ role: "user" | "assistant"; content: string }> = [];
+  const out: Array<{ role: "user" | "assistant"; content: unknown }> = [];
   for (const m of messages) {
     if (m.role === "system") {
       systemParts.push(m.content);
       continue;
     }
     if (m.role === "tool") {
-      out.push({ role: "user", content: m.content });
+      out.push({
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: m.toolCallId ?? "",
+            content: m.content,
+          },
+        ],
+      });
+      continue;
+    }
+    if (m.role === "assistant" && m.toolCalls && m.toolCalls.length > 0) {
+      const blocks: unknown[] = [];
+      if (m.content) blocks.push({ type: "text", text: m.content });
+      for (const call of m.toolCalls) {
+        blocks.push({
+          type: "tool_use",
+          id: call.id,
+          name: call.name,
+          input: call.arguments ?? {},
+        });
+      }
+      out.push({ role: "assistant", content: blocks });
       continue;
     }
     out.push({ role: m.role, content: m.content });
@@ -132,3 +197,129 @@ function textFromContent(content: AnthropicMessagesResponse["content"]): string
     .map((b) => b.text!)
     .join("");
 }
+
+function toolCallsFromContent(
+  content: AnthropicMessagesResponse["content"],
+): readonly AiToolCall[] | undefined {
+  const calls = (content ?? []).filter((block) => block.type === "tool_use" && block.name);
+  if (calls.length === 0) return undefined;
+  return calls.map((block, index) => ({
+    id: block.id ?? `toolu_${index}`,
+    name: block.name ?? "",
+    arguments: block.input ?? {},
+  }));
+}
+
+/**
+ * Parse Anthropic Messages SSE into text and tool-call chunks.
+ *
+ * @param res - Streaming response
+ * @param signal - Optional abort
+ */
+async function* readAnthropicSse(
+  res: Response,
+  signal?: AbortSignal,
+): AsyncGenerator<AiStreamChunk> {
+  const stream = (res as Response & { textStream?: () => AsyncIterable<string> }).textStream;
+  if (typeof stream !== "function") {
+    throw new Error("anthropic: Response.textStream is required (Bun >= 1.4.2)");
+  }
+  let buffer = "";
+  let inputTokens: number | undefined;
+  let outputTokens: number | undefined;
+  let stopped = false;
+  for await (const piece of stream.call(res)) {
+    if (signal?.aborted) {
+      const err = new Error("This operation was aborted");
+      err.name = "AbortError";
+      throw err;
+    }
+    buffer += piece;
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("data:")) continue;
+      const data = trimmed.slice(5).trim();
+      if (!data || data === "[DONE]") continue;
+      let event: {
+        type?: string;
+        index?: number;
+        content_block?: AnthropicBlock;
+        delta?: {
+          type?: string;
+          text?: string;
+          partial_json?: string;
+          stop_reason?: string;
+        };
+        message?: { usage?: { input_tokens?: number; output_tokens?: number } };
+        usage?: { output_tokens?: number; input_tokens?: number };
+      };
+      try {
+        event = JSON.parse(data) as typeof event;
+      } catch {
+        continue;
+      }
+      if (event.type === "error") {
+        const message =
+          typeof (event as { error?: { message?: string } }).error?.message === "string"
+            ? (event as { error?: { message?: string } }).error?.message
+            : "anthropic stream error";
+        throw new Error(`anthropic: ${message}`);
+      }
+      if (event.type === "message_stop") {
+        stopped = true;
+        continue;
+      }
+      if (event.type === "message_start") {
+        inputTokens = event.message?.usage?.input_tokens ?? inputTokens;
+        continue;
+      }
+      if (event.type === "content_block_start" && event.content_block?.type === "tool_use") {
+        yield {
+          text: "",
+          toolCall: {
+            index: event.index ?? 0,
+            ...(event.content_block.id !== undefined ? { id: event.content_block.id } : {}),
+            ...(event.content_block.name !== undefined ? { name: event.content_block.name } : {}),
+            argumentsDelta: "",
+          },
+        };
+        continue;
+      }
+      if (event.type === "content_block_delta" && event.delta?.type === "text_delta") {
+        if (event.delta.text) yield { text: event.delta.text };
+        continue;
+      }
+      if (event.type === "content_block_delta" && event.delta?.type === "input_json_delta") {
+        yield {
+          text: "",
+          toolCall: {
+            index: event.index ?? 0,
+            ...(event.delta.partial_json !== undefined
+              ? { argumentsDelta: event.delta.partial_json }
+              : {}),
+          },
+        };
+        continue;
+      }
+      if (event.type === "message_delta") {
+        outputTokens = event.usage?.output_tokens ?? outputTokens;
+        inputTokens = event.usage?.input_tokens ?? inputTokens;
+      }
+    }
+  }
+  if (!stopped) throw new Error("anthropic: stream ended without message_stop");
+  yield {
+    text: "",
+    done: true,
+    ...(inputTokens !== undefined || outputTokens !== undefined
+      ? {
+          usage: {
+            ...(inputTokens !== undefined ? { inputTokens } : {}),
+            ...(outputTokens !== undefined ? { outputTokens } : {}),
+          },
+        }
+      : {}),
+  };
+}

package/src/drivers/ai-mock.ts

@@ -97,6 +97,39 @@ export const mockAiDriver: AiDriver = {
             break;
           }
         }
+        if (
+          payload &&
+          typeof payload === "object" &&
+          payload !== null &&
+          "__toolCalls" in payload
+        ) {
+          const script = payload as { __toolCalls: readonly AiToolCall[]; text?: string };
+          const text = script.text ?? "";
+          const size = Math.max(1, Math.ceil(text.length / 2) || 1);
+          for (let i = 0; i < text.length; i += size) {
+            yield { text: text.slice(i, i + size) };
+          }
+          for (const [index, tc] of script.__toolCalls.entries()) {
+            const args =
+              typeof tc.arguments === "string" ? tc.arguments : JSON.stringify(tc.arguments ?? {});
+            yield {
+              text: "",
+              toolCall: { index, id: tc.id, name: tc.name, argumentsDelta: "" },
+            };
+            const mid = Math.max(1, Math.ceil(args.length / 2));
+            yield { text: "", toolCall: { index, argumentsDelta: args.slice(0, mid) } };
+            if (mid < args.length) {
+              yield { text: "", toolCall: { index, argumentsDelta: args.slice(mid) } };
+            }
+          }
+          yield {
+            text: "",
+            done: true,
+            raw: payload,
+            usage: { inputTokens: last.length, outputTokens: text.length, cost: 0 },
+          };
+          return;
+        }
         const text = typeof payload === "string" ? payload : JSON.stringify(payload);
         const size = Math.max(1, Math.ceil(text.length / 3));
         for (let i = 0; i < text.length; i += size) {
@@ -107,7 +140,7 @@ export const mockAiDriver: AiDriver = {
           }
           yield { text: text.slice(i, i + size) };
         }
-        yield { text: "", done: true };
+        yield { text: "", done: true, raw: payload };
       },
       async embed(opts: AiEmbedOptions): Promise<AiEmbedResult> {
         const inputs = Array.isArray(opts.input) ? opts.input : [opts.input];

package/src/drivers/ai-openai-compatible.ts

@@ -20,6 +20,7 @@ import type {
 } from "./ai-types.ts";
 import type { DriverExternal } from "./external.ts";
 import { hostFromUrl } from "./external.ts";
+import { preconnectFetch } from "./ai-preconnect.ts";
 
 /** Default OpenAI cloud base — apiKey is required for this origin. */
 export const OPENAI_COMPAT_DEFAULT_BASE = "https://api.openai.com/v1";
@@ -151,9 +152,23 @@ export async function openOpenaiCompatible(options: AiOpenOptions = {}): Promise
         model: resolvedModel,
         messages: opts.messages.map(serializeMessage),
         stream: true,
+        stream_options: { include_usage: true },
       };
       if (opts.temperature !== undefined) body.temperature = opts.temperature;
       if (opts.maxTokens !== undefined) body.max_tokens = opts.maxTokens;
+      if (opts.responseFormat !== undefined) {
+        body.response_format = wireOpenaiResponseFormat(opts.responseFormat);
+      }
+      if (opts.tools !== undefined && opts.tools.length > 0) {
+        body.tools = opts.tools.map((t) => ({
+          type: "function",
+          function: {
+            name: t.name,
+            ...(t.description !== undefined ? { description: t.description } : {}),
+            ...(t.parameters !== undefined ? { parameters: t.parameters } : {}),
+          },
+        }));
+      }
 
       const res = await fetchFn(`${baseUrl}/chat/completions`, {
         method: "POST",
@@ -166,7 +181,7 @@ export async function openOpenaiCompatible(options: AiOpenOptions = {}): Promise
         const msg = raw.error?.message ?? `openai-compatible HTTP ${res.status}`;
         throwHttp(`openai-compatible: ${msg}`, res.status);
       }
-      yield* readOpenaiSse(res, opts.signal);
+      yield* readOpenaiSse(res, opts.signal, externalBase);
     },
     async embed(opts: AiEmbedOptions): Promise<AiEmbedResult> {
       const resolvedModel = opts.model ?? model;
@@ -290,8 +305,13 @@ function parseToolCalls(
  * @param res - Streaming response
  * @param signal - Optional abort
  */
-async function* readOpenaiSse(res: Response, signal?: AbortSignal): AsyncGenerator<AiStreamChunk> {
+async function* readOpenaiSse(
+  res: Response,
+  signal?: AbortSignal,
+  external?: AiStreamChunk["external"],
+): AsyncGenerator<AiStreamChunk> {
   let buffer = "";
+  let closed = false;
   for await (const piece of responseTextStream(res)) {
     if (signal?.aborted) throw abortAsError(signal.reason);
     buffer += piece;
@@ -302,30 +322,64 @@ async function* readOpenaiSse(res: Response, signal?: AbortSignal): AsyncGenerat
       if (!trimmed.startsWith("data:")) continue;
       const data = trimmed.slice(5).trim();
       if (data === "[DONE]") {
-        yield { text: "", done: true };
+        yield { text: "", done: true, ...(external !== undefined ? { external } : {}) };
         return;
       }
       try {
         const chunk = JSON.parse(data) as {
           choices?: readonly {
-            delta?: { content?: string | null };
+            delta?: {
+              content?: string | null;
+              tool_calls?: readonly {
+                index?: number;
+                id?: string;
+                function?: { name?: string; arguments?: string };
+              }[];
+            };
             finish_reason?: string | null;
           }[];
+          usage?: { prompt_tokens?: number; completion_tokens?: number };
         };
-        const delta = chunk.choices?.[0]?.delta?.content;
-        if (typeof delta === "string" && delta.length > 0) {
-          yield { text: delta };
+        if (chunk.choices?.[0]?.finish_reason) closed = true;
+        const delta = chunk.choices?.[0]?.delta;
+        const content = delta?.content;
+        if (typeof content === "string" && content.length > 0) {
+          yield { text: content };
+        }
+        for (const call of delta?.tool_calls ?? []) {
+          const args = call.function?.arguments;
+          yield {
+            text: "",
+            toolCall: {
+              index: call.index ?? 0,
+              ...(call.id !== undefined ? { id: call.id } : {}),
+              ...(call.function?.name !== undefined ? { name: call.function.name } : {}),
+              ...(typeof args === "string" ? { argumentsDelta: args } : {}),
+            },
+          };
         }
-        if (chunk.choices?.[0]?.finish_reason) {
-          yield { text: "", done: true };
-          return;
+        if (chunk.usage) {
+          yield {
+            text: "",
+            usage: {
+              ...(chunk.usage.prompt_tokens !== undefined
+                ? { inputTokens: chunk.usage.prompt_tokens }
+                : {}),
+              ...(chunk.usage.completion_tokens !== undefined
+                ? { outputTokens: chunk.usage.completion_tokens }
+                : {}),
+            },
+          };
         }
-      } catch {
-        // ignore malformed SSE lines
+      } catch (err) {
+        if (err instanceof Error && err.message.startsWith("openai-compatible:")) throw err;
       }
     }
   }
-  yield { text: "", done: true };
+  if (!closed) {
+    throw new Error("openai-compatible: stream ended without [DONE] or finish_reason");
+  }
+  yield { text: "", done: true, ...(external !== undefined ? { external } : {}) };
 }
 
 /**
@@ -341,19 +395,6 @@ function responseTextStream(res: Response): AsyncIterable<string> {
   return stream.call(res);
 }
 
-/**
- * Warm DNS+TCP+TLS for a cloud origin. No-op when `fetch` is a test stub.
- *
- * @param fetchFn - Fetch implementation
- * @param url - Provider base URL
- */
-function preconnectFetch(fetchFn: typeof fetch, url: string): void {
-  const preconnect = (fetchFn as { preconnect?: (href: string) => void }).preconnect;
-  if (typeof preconnect === "function") {
-    preconnect(url);
-  }
-}
-
 function abortAsError(reason?: unknown): Error {
   if (reason instanceof Error) return reason;
   const err = new Error(reason !== undefined ? String(reason) : "This operation was aborted");

package/src/drivers/ai-preconnect.ts

@@ -0,0 +1,18 @@
+/**
+ * Best-effort `fetch.preconnect` for AI HTTP drivers.
+ *
+ * Bun throws `Invalid port` when the URL uses an implicit 80/443. A failed
+ * preconnect must not fail the request and must not log.
+ *
+ * @param fetchFn - Injected or global fetch
+ * @param url - Origin or base URL to warm
+ */
+export function preconnectFetch(fetchFn: typeof fetch, url: string): void {
+  const preconnect = (fetchFn as { preconnect?: (href: string) => void }).preconnect;
+  if (typeof preconnect !== "function") return;
+  try {
+    preconnect(url);
+  } catch {
+    // Bun rejects default ports. The request still runs.
+  }
+}