okengine 0.12.0 → 0.14.1

package/src/docker/recipes/dragonfly.ts

@@ -5,6 +5,7 @@
  * Official image: `docker.dragonflydb.io/dragonflydb/dragonfly`.
  */
 
+import { dragonflyServerCommand } from "../helpers.ts";
 import type { ImageRecipe } from "../types.ts";
 
 /** Dragonfly — Redis protocol on 6379. */
@@ -12,13 +13,9 @@ export const dragonfly: ImageRecipe = {
   id: "dragonfly",
   port: 6379,
   match: (i) => /dragonfly/i.test(i),
-  apply: () => ({
+  apply: (s) => ({
     environment: { HEALTHCHECK_PORT: "6379" },
-    command: [
-      "sh",
-      "-c",
-      'exec dragonfly --requirepass "$$OKE_STORE_KV_PASSWORD" --maxmemory "$${OKE_STORE_KV_MAXMEMORY:-0}"',
-    ],
+    command: ["sh", "-c", dragonflyServerCommand(s)],
     ulimits: { memlock: -1 },
     healthcheck: {
       test: ["CMD", "/usr/local/bin/healthcheck.sh"],

package/src/docker/recipes/redis.ts

@@ -5,7 +5,7 @@
  * `redis://` URL, different binaries. Pin via `images["store.kv"]`.
  */
 
-import { credEnv } from "../helpers.ts";
+import { credEnv, kvServerCommand } from "../helpers.ts";
 import type { ImageRecipe } from "../types.ts";
 
 /** Redis Open Source — Redis protocol on 6379. */
@@ -14,11 +14,7 @@ export const redis: ImageRecipe = {
   port: 6379,
   match: (i) => /(?:^|\/)redis(?:[:@/]|$)/i.test(i) || /keydb/i.test(i),
   apply: (s) => ({
-    command: [
-      "sh",
-      "-c",
-      'exec redis-server --requirepass "$$OKE_STORE_KV_PASSWORD" --maxmemory "$${OKE_STORE_KV_MAXMEMORY:-0}" --maxmemory-policy "$${OKE_STORE_KV_MAXMEMORY_POLICY:-noeviction}"',
-    ],
+    command: ["sh", "-c", kvServerCommand(s, "redis-server")],
     healthcheck: {
       test: ["CMD", "redis-cli", "-a", credEnv(s, "PASSWORD"), "ping"],
       interval: "5s",

package/src/docker/recipes/valkey.ts

@@ -5,7 +5,7 @@
  * `valkey/valkey`.
  */
 
-import { credEnv } from "../helpers.ts";
+import { credEnv, kvServerCommand } from "../helpers.ts";
 import type { ImageRecipe } from "../types.ts";
 
 /** Valkey — Redis protocol on 6379. */
@@ -14,11 +14,7 @@ export const valkey: ImageRecipe = {
   port: 6379,
   match: (i) => /valkey/i.test(i),
   apply: (s) => ({
-    command: [
-      "sh",
-      "-c",
-      'exec valkey-server --requirepass "$$OKE_STORE_KV_PASSWORD" --maxmemory "$${OKE_STORE_KV_MAXMEMORY:-0}" --maxmemory-policy "$${OKE_STORE_KV_MAXMEMORY_POLICY:-noeviction}"',
-    ],
+    command: ["sh", "-c", kvServerCommand(s, "valkey-server")],
     healthcheck: {
       test: ["CMD", "valkey-cli", "-a", credEnv(s, "PASSWORD"), "ping"],
       interval: "5s",

package/src/drivers/ai-anthropic.ts

@@ -29,6 +29,10 @@ 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);
+  }
 
   return {
     driverId: "anthropic",
@@ -50,6 +54,7 @@ export async function openAnthropic(options: AiOpenOptions = {}): Promise<AiMode
           ...(system !== undefined ? { system } : {}),
           messages,
         }),
+        ...(opts.signal !== undefined ? { signal: opts.signal } : {}),
       });
       const raw = (await res.json().catch(() => ({}))) as AnthropicMessagesResponse;
       if (!res.ok) {

package/src/drivers/ai-ollama.ts

@@ -156,10 +156,7 @@ export async function openOllama(options: AiOpenOptions = {}): Promise<AiModelCl
         const msg = raw.error ?? `ollama HTTP ${res.status}`;
         throw new OllamaUnavailableError(`ollama: ${msg}`);
       }
-      if (!res.body) {
-        throw new OllamaUnavailableError("ollama: stream response has no body");
-      }
-      yield* readOllamaNdjson(res.body, opts.signal);
+      yield* readOllamaNdjson(res, opts.signal);
     },
     async embed(opts: AiEmbedOptions): Promise<AiEmbedResult> {
       const resolvedModel = resolveOllamaModel(options, opts.model);
@@ -265,45 +262,45 @@ function parseOllamaToolCalls(
 }
 
 /**
- * Parse Ollama NDJSON stream lines.
+ * Parse Ollama NDJSON stream lines via {@link Bun.JSONL.parseChunk}.
  *
- * @param body - Response body
+ * @param res - Streaming response
  * @param signal - Optional abort
  */
 async function* readOllamaNdjson(
-  body: ReadableStream<Uint8Array>,
+  res: Response,
   signal?: AbortSignal,
 ): AsyncGenerator<AiStreamChunk> {
-  const reader = body.getReader();
+  const reader = res.body?.getReader();
+  if (!reader) {
+    throw new OllamaUnavailableError("ollama: stream response has no body");
+  }
   const decoder = new TextDecoder();
-  let buffer = "";
+  let pending = "";
   try {
     while (true) {
-      if (signal?.aborted) {
-        throw abortAsError(signal.reason);
-      }
+      if (signal?.aborted) throw abortAsError(signal.reason);
       const { done, value } = await reader.read();
       if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed) continue;
-        try {
-          const chunk = JSON.parse(trimmed) as OllamaChatResponse;
-          const delta = chunk.message?.content;
-          if (typeof delta === "string" && delta.length > 0) {
-            yield { text: delta };
-          }
-          if (chunk.done) {
-            yield { text: "", done: true };
-            return;
-          }
-        } catch {
-          // ignore malformed lines
+      pending += decoder.decode(value, { stream: true });
+      const parsed = bunJsonl().parseChunk(pending);
+      pending = pending.slice(parsed.read);
+      for (const row of parsed.values) {
+        const chunk = row as OllamaChatResponse;
+        const delta = chunk.message?.content;
+        if (typeof delta === "string" && delta.length > 0) {
+          yield { text: delta };
+        }
+        if (chunk.done) {
+          yield { text: "", done: true };
+          return;
         }
       }
+      if (parsed.error) {
+        const nl = pending.indexOf("\n");
+        if (nl === -1) continue;
+        pending = pending.slice(nl + 1);
+      }
     }
     yield { text: "", done: true };
   } finally {
@@ -311,6 +308,28 @@ async function* readOllamaNdjson(
   }
 }
 
+interface BunJsonlParse {
+  readonly values: readonly unknown[];
+  readonly read: number;
+  readonly done: boolean;
+  readonly error: unknown;
+}
+
+function bunJsonl(): {
+  parse(text: string): unknown[];
+  parseChunk(text: string): BunJsonlParse;
+} {
+  const jsonl = (
+    Bun as typeof Bun & {
+      JSONL?: { parse: (t: string) => unknown[]; parseChunk: (t: string) => BunJsonlParse };
+    }
+  ).JSONL;
+  if (!jsonl) {
+    throw new Error("ollama: Bun.JSONL is required (Bun >= 1.4.0)");
+  }
+  return jsonl;
+}
+
 /**
  * Probe Ollama — fail loud before the first completion.
  *

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

@@ -89,6 +89,7 @@ export async function openOpenaiCompatible(options: AiOpenOptions = {}): Promise
   const model = options.model ?? "gpt-4o-mini";
   const fetchFn = options.fetch ?? globalThis.fetch;
   const extraHeaders = options.headers;
+  preconnectFetch(fetchFn, baseUrl);
 
   return {
     driverId: "openai-compatible",
@@ -162,10 +163,7 @@ export async function openOpenaiCompatible(options: AiOpenOptions = {}): Promise
         const msg = raw.error?.message ?? `openai-compatible HTTP ${res.status}`;
         throwHttp(`openai-compatible: ${msg}`, res.status);
       }
-      if (!res.body) {
-        throw new Error("openai-compatible: stream response has no body");
-      }
-      yield* readOpenaiSse(res.body, opts.signal);
+      yield* readOpenaiSse(res, opts.signal);
     },
     async embed(opts: AiEmbedOptions): Promise<AiEmbedResult> {
       const resolvedModel = opts.model ?? model;
@@ -262,57 +260,70 @@ function parseToolCalls(
 /**
  * Parse OpenAI SSE chat.completion.chunk stream.
  *
- * @param body - Response body
+ * @param res - Streaming response
  * @param signal - Optional abort
  */
-async function* readOpenaiSse(
-  body: ReadableStream<Uint8Array>,
-  signal?: AbortSignal,
-): AsyncGenerator<AiStreamChunk> {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
+async function* readOpenaiSse(res: Response, signal?: AbortSignal): AsyncGenerator<AiStreamChunk> {
   let buffer = "";
-  try {
-    while (true) {
-      if (signal?.aborted) {
-        throw abortAsError(signal.reason);
+  for await (const piece of responseTextStream(res)) {
+    if (signal?.aborted) throw abortAsError(signal.reason);
+    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 === "[DONE]") {
+        yield { text: "", done: true };
+        return;
       }
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      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 === "[DONE]") {
+      try {
+        const chunk = JSON.parse(data) as {
+          choices?: readonly {
+            delta?: { content?: string | null };
+            finish_reason?: string | null;
+          }[];
+        };
+        const delta = chunk.choices?.[0]?.delta?.content;
+        if (typeof delta === "string" && delta.length > 0) {
+          yield { text: delta };
+        }
+        if (chunk.choices?.[0]?.finish_reason) {
           yield { text: "", done: true };
           return;
         }
-        try {
-          const chunk = JSON.parse(data) as {
-            choices?: readonly {
-              delta?: { content?: string | null };
-              finish_reason?: string | null;
-            }[];
-          };
-          const delta = chunk.choices?.[0]?.delta?.content;
-          if (typeof delta === "string" && delta.length > 0) {
-            yield { text: delta };
-          }
-          if (chunk.choices?.[0]?.finish_reason) {
-            yield { text: "", done: true };
-            return;
-          }
-        } catch {
-          // ignore malformed SSE lines
-        }
+      } catch {
+        // ignore malformed SSE lines
       }
     }
-    yield { text: "", done: true };
-  } finally {
-    reader.releaseLock();
+  }
+  yield { text: "", done: true };
+}
+
+/**
+ * UTF-8 text chunks from a Response (`textStream` on Bun ≥1.4).
+ *
+ * @param res - HTTP response
+ */
+function responseTextStream(res: Response): AsyncIterable<string> {
+  const stream = (res as Response & { textStream?: () => AsyncIterable<string> }).textStream;
+  if (typeof stream !== "function") {
+    throw new Error("openai-compatible: Response.textStream is required (Bun >= 1.4.0)");
+  }
+  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);
   }
 }
 

package/src/drivers/ai-providers.test.ts

@@ -43,12 +43,14 @@ describe("anthropic driver", () => {
       model: "claude-test",
       fetch: fetchFn,
     });
+    const ac = new AbortController();
     const result = await client.complete({
       messages: [
         { role: "system", content: "be brief" },
         { role: "user", content: "hi" },
       ],
       maxTokens: 64,
+      signal: ac.signal,
     });
 
     expect(result.driverId).toBe("anthropic");
@@ -62,6 +64,7 @@ describe("anthropic driver", () => {
     };
     expect(body.system).toBe("be brief");
     expect(body.messages).toEqual([{ role: "user", content: "hi" } as { role: string }]);
+    expect(calls[0]!.init?.signal).toBe(ac.signal);
   });
 
   test("HTTP error surfaces provider message", async () => {

package/src/drivers/bun-native-completeness.test.ts

@@ -1,8 +1,8 @@
 /**
  * Bun native-client completeness — gaps closed vs platform limitations.
  *
- * Checked against Bun 1.3.14 (runtime + bun-types). Do not invent custom
- * protocol clients where Bun still lacks an API.
+ * Checked against Bun 1.4 (runtime). Do not invent custom protocol clients
+ * where Bun still lacks an API.
  */
 
 import { describe, expect, test } from "bun:test";
@@ -46,7 +46,7 @@ export function bunNativeCompletenessReport(): readonly BunNativeGapRow[] {
       status: hasTypedEval ? "closed" : "bun_limitation",
       note: hasTypedEval
         ? "typed eval bound"
-        : "Bun 1.3.14 has no typed eval — driver uses send(EVAL)",
+        : "Bun.RedisClient.eval unavailable — would keep send(EVAL)",
     },
     {
       surface: "redis signal",
@@ -63,7 +63,7 @@ export function bunNativeCompletenessReport(): readonly BunNativeGapRow[] {
       status: hasTypedXadd ? "closed" : "bun_limitation",
       note: hasTypedXadd
         ? "typed stream helpers bound"
-        : "Bun 1.3.14 has no typed xadd — Streams use send (native, not a custom client)",
+        : "Bun.RedisClient.xadd unavailable — Streams would keep send",
     },
     {
       surface: "redis signal",
@@ -95,23 +95,21 @@ export function bunNativeCompletenessReport(): readonly BunNativeGapRow[] {
 }
 
 describe("Bun native client completeness", () => {
-  test("report table is exact and matches runtime Bun 1.3.x", () => {
+  test("report table is exact and matches runtime Bun 1.4", () => {
     const rows = bunNativeCompletenessReport();
     expect(rows.length).toBe(8);
 
     const closed = rows.filter((r) => r.status === "closed").map((r) => r.capability);
     const limited = rows.filter((r) => r.status === "bun_limitation").map((r) => r.capability);
 
-    // Closed on Bun 1.3.14
     expect(closed).toContain("SCAN (typed)");
+    expect(closed).toContain("EVAL (typed)");
     expect(closed).toContain("native Bun bind (publish/subscribe)");
+    expect(closed).toContain("XADD / XREADGROUP (typed)");
     expect(closed).toContain("send escape hatch");
     expect(closed).toContain("Bun.SQL.unsafe query/exec");
     expect(closed).toContain("Bun.S3Client file/list");
 
-    // Genuine Bun platform limitations (do not invent workarounds)
-    expect(limited).toContain("EVAL (typed)");
-    expect(limited).toContain("XADD / XREADGROUP (typed)");
     expect(limited).toContain("LISTEN / NOTIFY on Bun.SQL");
   });
 

package/src/drivers/redis.ts

@@ -140,11 +140,19 @@ function ttlToSeconds(ttl: string): number {
   }
 }
 
+/** Bun 1.4 typed methods — `@types/bun` may lag the runtime. */
+interface BunRedisEval {
+  eval(script: string, numkeys: number, ...keysAndArgs: string[]): Promise<unknown>;
+}
+
+function typedRedis(redis: Bun.RedisClient): Bun.RedisClient & BunRedisEval {
+  return redis as Bun.RedisClient & BunRedisEval;
+}
+
 /**
  * Bind {@link Bun.RedisClient} / {@link Bun.redis} to {@link KvClientLike}.
  *
- * Uses typed `scan` (Bun ≥1.3). `EVAL` still goes through `send` — Bun 1.3.14
- * has no typed `eval` yet (platform limitation, not an OKE stub).
+ * Uses typed `scan` / `eval` (Bun ≥1.4). `send` remains the escape hatch.
  *
  * @param url - Optional Redis URL
  */
@@ -174,8 +182,7 @@ export function createBunRedisClient(url?: string): KvClientLike {
       return redis.scan(cursor);
     },
     async eval(script, numkeys, ...keysAndArgs) {
-      // Bun 1.3.14: no typed eval — raw send remains the native path.
-      return redis.send("EVAL", [script, String(numkeys), ...keysAndArgs]);
+      return typedRedis(redis).eval(script, numkeys, ...keysAndArgs);
     },
     send: (command, args) => redis.send(command, args),
   };

package/src/drivers/signal-redis.ts

@@ -7,7 +7,7 @@
  * exactly-once / fan-out physics stay correct under `drain()`.
  *
  * Production bind: {@link createBunSignalRedisClient} (typed `publish` /
- * `subscribe`; Streams via `send` — Bun 1.3.14 has no typed `xadd` yet).
+ * `subscribe` / `xadd` / `xreadgroup` / `xack` / `xgroup` on Bun ≥1.4).
  */
 
 import { createSignalEngine } from "./signal-engine.ts";
@@ -18,12 +18,23 @@ import type {
   SignalRedisClientLike,
 } from "./signal-types.ts";
 
+/** Bun 1.4 typed stream methods — `@types/bun` may lag the runtime. */
+interface BunRedisStreams {
+  xadd(key: string, ...args: (string | number)[]): Promise<unknown>;
+  xreadgroup(...args: (string | number)[]): Promise<unknown>;
+  xack(key: string, group: string, id: string): Promise<unknown>;
+  xgroup(subcommand: string, ...args: (string | number)[]): Promise<unknown>;
+}
+
+function typedStreams(redis: Bun.RedisClient): Bun.RedisClient & BunRedisStreams {
+  return redis as Bun.RedisClient & BunRedisStreams;
+}
+
 /**
  * Bind {@link Bun.RedisClient} to {@link SignalRedisClientLike}.
  *
- * Streams (`XADD` / `XGROUP` / `XREADGROUP` / `XACK`) use `send` because
- * Bun 1.3.14 still lacks typed stream helpers — that is a Bun limitation.
- * Pub/sub uses typed `publish` / `subscribe` (gap closed vs earlier fake-only).
+ * Streams use typed `xadd` / `xgroup` / `xreadgroup` / `xack` (Bun ≥1.4).
+ * Pub/sub uses typed `publish` / `subscribe`.
  *
  * @param url - Optional Redis URL
  */
@@ -41,37 +52,36 @@ export function createBunSignalRedisClient(url?: string): SignalRedisClientLike
 
   return {
     async xadd(key, id, fields) {
-      const args: string[] = [key, id];
+      const pairs: string[] = [];
       for (const [k, v] of Object.entries(fields)) {
-        args.push(k, v);
+        pairs.push(k, v);
       }
-      return String(await redis.send("XADD", args));
+      return String(await typedStreams(redis).xadd(key, id, ...pairs));
     },
     async xgroupCreate(key, group, id, opts) {
-      const args = ["CREATE", key, group, id];
-      if (opts?.mkstream) args.push("MKSTREAM");
+      const extra = opts?.mkstream ? (["MKSTREAM"] as const) : [];
       try {
-        await redis.send("XGROUP", args);
+        await typedStreams(redis).xgroup("CREATE", key, group, id, ...extra);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         if (!/BUSYGROUP/i.test(msg)) throw err;
       }
     },
     async xreadgroup(group, consumer, key, count) {
-      const reply = await redis.send("XREADGROUP", [
+      const reply = await typedStreams(redis).xreadgroup(
         "GROUP",
         group,
         consumer,
         "COUNT",
-        String(count),
+        count,
         "STREAMS",
         key,
         ">",
-      ]);
+      );
       return parseXreadgroupReply(reply);
     },
     async xack(key, group, id) {
-      return Number(await redis.send("XACK", [key, group, id]));
+      return Number(await typedStreams(redis).xack(key, group, id));
     },
     async publish(channel, message) {
       return redis.publish(channel, message);

package/src/drivers/signal-types.ts

@@ -69,8 +69,9 @@ export interface SignalMessage {
 }
 
 /** Dead-letter entry with full attempt history. */
-export interface DeadLetter extends SignalMessage {
+export interface DeadLetter<T = unknown> extends Omit<SignalMessage, "payload" | "status"> {
   readonly status: "dead";
+  readonly payload: T;
 }
 
 /** Per-subscriber lag / errors (broadcast physics). */

package/src/drivers/types.ts

@@ -83,7 +83,7 @@ export interface SqlDriver {
 /** Key-value namespace handle. */
 export interface KvNamespace {
   /** Protocol driver id. */
-  readonly driverId: "memory" | "redis";
+  readonly driverId: "memory" | "redis" | "postgres" | "pglite";
   /**
    * Read a key.
    *