okengine 0.13.0 → 0.15.2

package/src/console/ui-next/src/features/units/detail/effects-summary.tsx

@@ -6,6 +6,7 @@ import { HugeiconsIcon } from "@hugeicons/react";
 import type { JSX } from "react";
 import type { Effects } from "../../../../../../manifest/types.ts";
 import { SectionHead } from "@/components/explorer/section-head.tsx";
+import { mcpCallChipLabel } from "@/features/flows/traces/effect-summary.ts";
 import {
   effectBarColor,
   effectKindIcon,
@@ -38,17 +39,24 @@ export function EffectsSummary({ effects }: EffectsSummaryProps): JSX.Element |
       <ul className="flex flex-wrap gap-1.5">
         {chips.map((c) => {
           const color = effectBarColor(c.kind);
-          const Icon = effectKindIcon(c.kind);
+          const Icon = effectKindIcon(c.kind, c.ref);
+          const mcpLabel = c.kind === "call" ? mcpCallChipLabel(c.ref) : null;
           return (
             <li
               key={`${c.kind}:${c.ref}`}
               className="inline-flex items-center gap-1 rounded-md border px-1.5 py-0.5 font-mono text-[10px]"
               style={{ borderColor: `${color}55`, color }}
-              title={`${EFFECT_KIND_LABEL[c.kind]} ${c.ref}`}
+              title={mcpLabel ?? `${EFFECT_KIND_LABEL[c.kind]} ${c.ref}`}
             >
               <HugeiconsIcon icon={Icon} className="size-3" />
-              <span className="text-muted-foreground">{EFFECT_KIND_LABEL[c.kind]}</span>
-              <span className="text-foreground/90">{c.ref}</span>
+              {mcpLabel ? (
+                <span className="text-foreground/90">{mcpLabel}</span>
+              ) : (
+                <>
+                  <span className="text-muted-foreground">{EFFECT_KIND_LABEL[c.kind]}</span>
+                  <span className="text-foreground/90">{c.ref}</span>
+                </>
+              )}
             </li>
           );
         })}

package/src/console/ui-next/src/features/units/lib/contract-input.test.ts

@@ -3,7 +3,7 @@
  */
 
 import { describe, expect, test } from "bun:test";
-import { splitContractInput } from "./contract-input.ts";
+import { pickSeedFields, splitCallApiInput, splitContractInput } from "./contract-input.ts";
 import { fieldsFromSchema } from "./fields-from-schema.ts";
 
 const LIST_IN = fieldsFromSchema({
@@ -45,3 +45,208 @@ describe("splitContractInput", () => {
     expect(split.fields.map((f) => f.name)).toEqual(["title"]);
   });
 });
+
+describe("splitCallApiInput", () => {
+  const idOnly = fieldsFromSchema({
+    type: "object",
+    required: ["id"],
+    properties: { id: { type: "string", minLength: 1 } },
+  });
+  const list = LIST_IN;
+  const nestedList = fieldsFromSchema({
+    type: "object",
+    required: ["id"],
+    properties: {
+      id: { type: "string", minLength: 1 },
+      q: { type: "string" },
+      limit: { type: "integer" },
+    },
+  });
+  const create = fieldsFromSchema({
+    type: "object",
+    required: ["title"],
+    properties: { title: { type: "string" }, spaceKey: { type: "string" } },
+  });
+  const assign = fieldsFromSchema({
+    type: "object",
+    required: ["id", "assigneeEmail"],
+    properties: { id: { type: "string" }, assigneeEmail: { type: "string" } },
+  });
+  const patch = fieldsFromSchema({
+    type: "object",
+    required: ["id"],
+    properties: {
+      id: { type: "string" },
+      title: { type: "string" },
+      status: { type: "string" },
+    },
+  });
+  const putDraft = fieldsFromSchema({
+    type: "object",
+    required: ["id", "title"],
+    properties: { id: { type: "string" }, title: { type: "string" }, body: { type: "string" } },
+  });
+  const search = fieldsFromSchema({
+    type: "object",
+    required: ["q"],
+    properties: { q: { type: "string" }, limit: { type: "integer" } },
+  });
+
+  const cases: readonly {
+    readonly name: string;
+    readonly method: string;
+    readonly pathParams: readonly string[];
+    readonly fields: ReturnType<typeof fieldsFromSchema>;
+    readonly path: readonly string[];
+    readonly query: readonly string[];
+    readonly body: readonly string[];
+  }[] = [
+    {
+      name: "GET tasks.get",
+      method: "GET",
+      pathParams: ["id"],
+      fields: idOnly,
+      path: ["id"],
+      query: [],
+      body: [],
+    },
+    {
+      name: "GET tasks.list",
+      method: "GET",
+      pathParams: [],
+      fields: list,
+      path: [],
+      query: ["q", "teamKey", "limit", "offset", "cursor", "orderBy", "order"],
+      body: [],
+    },
+    {
+      name: "GET comments.list /tasks/:id/comments",
+      method: "GET",
+      pathParams: ["id"],
+      fields: nestedList,
+      path: ["id"],
+      query: ["q", "limit"],
+      body: [],
+    },
+    {
+      name: "HEAD main.health",
+      method: "HEAD",
+      pathParams: [],
+      fields: [],
+      path: [],
+      query: [],
+      body: [],
+    },
+    {
+      name: "DELETE tasks.delete",
+      method: "DELETE",
+      pathParams: ["id"],
+      fields: idOnly,
+      path: ["id"],
+      query: [],
+      body: [],
+    },
+    {
+      name: "POST tasks.create",
+      method: "POST",
+      pathParams: [],
+      fields: create,
+      path: [],
+      query: [],
+      body: ["title", "spaceKey"],
+    },
+    {
+      name: "POST tasks.assign /tasks/:id/assign",
+      method: "POST",
+      pathParams: ["id"],
+      fields: assign,
+      path: ["id"],
+      query: [],
+      body: ["assigneeEmail"],
+    },
+    {
+      name: "POST tasks.archive path-only",
+      method: "POST",
+      pathParams: ["id"],
+      fields: idOnly,
+      path: ["id"],
+      query: [],
+      body: [],
+    },
+    {
+      name: "PATCH tasks.update",
+      method: "PATCH",
+      pathParams: ["id"],
+      fields: patch,
+      path: ["id"],
+      query: [],
+      body: ["title", "status"],
+    },
+    {
+      name: "PUT drafts.save",
+      method: "PUT",
+      pathParams: ["id"],
+      fields: putDraft,
+      path: ["id"],
+      query: [],
+      body: ["title", "body"],
+    },
+    {
+      name: "QUERY search.query",
+      method: "QUERY",
+      pathParams: [],
+      fields: search,
+      path: [],
+      query: [],
+      body: ["q", "limit"],
+    },
+    {
+      name: "OPTIONS leftover stays body",
+      method: "OPTIONS",
+      pathParams: [],
+      fields: search,
+      path: [],
+      query: [],
+      body: ["q", "limit"],
+    },
+  ];
+
+  for (const row of cases) {
+    test(row.name, () => {
+      const split = splitCallApiInput(row.fields, {
+        http: true,
+        method: row.method,
+        pathParams: row.pathParams,
+      });
+      expect(split.path).toEqual([...row.path]);
+      expect(split.query.map((f) => f.name)).toEqual([...row.query]);
+      expect(split.body.map((f) => f.name)).toEqual([...row.body]);
+    });
+  }
+
+  test("non-HTTP keeps the full input as body", () => {
+    const split = splitCallApiInput(idOnly);
+    expect(split.path).toEqual([]);
+    expect(split.query).toEqual([]);
+    expect(split.body.map((f) => f.name)).toEqual(["id"]);
+  });
+
+  test("Signal / CDC / Call-only never grow Path params from an id field", () => {
+    for (const kind of ["signal", "cdc", "internal"] as const) {
+      const split = splitCallApiInput(idOnly, { http: false, method: kind });
+      expect(split.path).toEqual([]);
+      expect(split.query).toEqual([]);
+      expect(split.body.map((f) => f.name)).toEqual(["id"]);
+    }
+  });
+});
+
+describe("pickSeedFields", () => {
+  test("keeps only named section keys", () => {
+    const title = fieldsFromSchema({
+      type: "object",
+      properties: { title: { type: "string" } },
+    });
+    expect(pickSeedFields({ id: "x", title: "n" }, title)).toEqual({ title: "n" });
+  });
+});

package/src/console/ui-next/src/features/units/lib/contract-input.ts

@@ -2,6 +2,7 @@
  * Split flow input into query/path parameters vs body / filter fields.
  */
 
+import { httpMethodHasBody } from "@/features/flows/traces/http-method.ts";
 import type { FormField } from "./fields-from-schema.ts";
 
 /** List / page / sort keys — query parameters, not resource fields. */
@@ -66,3 +67,57 @@ function pathParamField(name: string): FormField {
     required: true,
   };
 }
+
+/** Call API request sections — path vs query vs JSON body. */
+export type CallApiInputSplit = {
+  readonly path: readonly string[];
+  readonly query: readonly FormField[];
+  readonly body: readonly FormField[];
+};
+
+/**
+ * Partition `flow.in` the way the typed client puts fields on the wire.
+ *
+ * Path tokens never appear in query or body. `GET` / `HEAD` / `DELETE`
+ * leftover fields are query. Other HTTP verbs and non-HTTP triggers keep a
+ * JSON body (minus path tokens).
+ *
+ * @param input - `flow.in` fields
+ * @param options - Route tokens + HTTP method
+ */
+export function splitCallApiInput(
+  input: readonly FormField[],
+  options: {
+    readonly pathParams?: readonly string[];
+    readonly method?: string | null;
+    readonly http?: boolean;
+  } = {},
+): CallApiInputSplit {
+  const pathParams = options.pathParams ?? [];
+  const pathSet = new Set(pathParams);
+  if (options.http !== true) {
+    return { path: [], query: [], body: input };
+  }
+  const leftover = input.filter((field) => !pathSet.has(field.name));
+  if (!httpMethodHasBody(options.method)) {
+    return { path: pathParams, query: leftover, body: [] };
+  }
+  return { path: pathParams, query: [], body: leftover };
+}
+
+/**
+ * Keep schema seed keys that belong to a Call API section.
+ *
+ * @param seed - Full `flow.in` seed
+ * @param fields - Section fields
+ */
+export function pickSeedFields(
+  seed: Record<string, unknown>,
+  fields: readonly FormField[],
+): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const field of fields) {
+    if (Object.hasOwn(seed, field.name)) out[field.name] = seed[field.name];
+  }
+  return out;
+}

package/src/console/ui-next/src/features/vault/lib/types.ts

@@ -110,5 +110,5 @@ export interface VaultRotateMasterResult {
   readonly kekVersion: number;
   readonly remaining: number;
   readonly masterKey: string | null;
-  readonly at: number;
+  readonly at: string;
 }

package/src/docker/compose-health.test.ts

@@ -16,6 +16,12 @@ describe("compose-health", () => {
     expect(composeRowToStatus({ State: "stopped" })).toBe("error");
     expect(composeRowToStatus({ Status: "Exited (0) 3 seconds ago" })).toBe("error");
     expect(composeRowToStatus({ State: "running" })).toBe("ready");
+    expect(composeRowToStatus({ State: "restarting" })).toBe("pending");
+    expect(composeRowToStatus({ State: "running", Status: "Up Less than a second" })).toBe(
+      "pending",
+    );
+    expect(composeRowToStatus({ State: "running", Status: "Up 2 seconds" })).toBe("pending");
+    expect(composeRowToStatus({ State: "running", Status: "Up 2 minutes" })).toBe("ready");
     expect(composeRowToStatus({ Status: "Up 2 seconds (health: starting)" })).toBe("pending");
   });
 
@@ -60,6 +66,27 @@ describe("compose-health", () => {
     expect(updates).toEqual(["store-sql:pending", "store-sql:ready"]);
   });
 
+  test("watchComposeHealth waits through compose restarting", async () => {
+    let calls = 0;
+    const map = await watchComposeHealth({
+      files: ["compose.yml"],
+      cwd: "/tmp",
+      env: {},
+      intervalMs: 1,
+      timeoutMs: 5_000,
+      sleep: async () => {},
+      run: async () => {
+        calls += 1;
+        if (calls === 1) {
+          return JSON.stringify([{ Service: "store-sql", State: "restarting" }]);
+        }
+        return JSON.stringify([{ Service: "store-sql", Health: "healthy", State: "running" }]);
+      },
+    });
+    expect(calls).toBe(2);
+    expect(map.get("store-sql")).toBe("ready");
+  });
+
   test("readComposeHealth / watch use ps -a", async () => {
     let seen: readonly string[] = [];
     await watchComposeHealth({

package/src/docker/compose-health.ts

@@ -20,22 +20,27 @@ export type ComposePsRow = {
 export function composeRowToStatus(row: ComposePsRow): DevStatus {
   const health = (row.Health ?? "").trim().toLowerCase();
   const state = (row.State ?? "").trim().toLowerCase();
+  const statusText = (row.Status ?? "").toLowerCase();
   if (health === "healthy") return "ready";
   if (health === "unhealthy") return "error";
   if (health === "starting") return "pending";
-  if (state === "running" || state === "up") return "ready";
+  if (state === "restarting") return "pending";
+  if (state === "running" || state === "up") {
+    // Right after `compose restart`, State is "running" before Health is
+    // "starting". Treat a fresh Up without (healthy) as still coming up.
+    if (isFreshComposeUp(statusText) && !statusText.includes("(healthy)")) return "pending";
+    return "ready";
+  }
   if (
     state === "exited" ||
     state === "dead" ||
     state === "stopped" ||
-    state === "restarting" ||
     state === "removing" ||
     state === "oomkilled"
   ) {
     return "error";
   }
   // Status text for stopped containers (`Exited (0) 2 seconds ago`).
-  const statusText = (row.Status ?? "").toLowerCase();
   if (statusText.startsWith("exited") || statusText.startsWith("dead")) return "error";
   if (state === "created" || state === "paused" || state.length === 0) return "pending";
   // Status text like "Up 3 seconds (healthy)"
@@ -48,6 +53,17 @@ export function composeRowToStatus(row: ComposePsRow): DevStatus {
   return "pending";
 }
 
+/**
+ * True when compose `Status` is a just-started container (health not reported yet).
+ *
+ * @param statusText - Lowercased `Status` from `docker compose ps`
+ */
+function isFreshComposeUp(statusText: string): boolean {
+  if (statusText.includes("less than a second")) return true;
+  const seconds = /up\s+(\d+)\s+seconds?/i.exec(statusText);
+  return seconds !== null && Number(seconds[1]) < 8;
+}
+
 /**
  * Parse NDJSON or a JSON array from `docker compose ps --format json`.
  *

package/src/docker/docker.test.ts

@@ -392,11 +392,13 @@ describe("image recipes", () => {
     expect(pgdogToml).toContain('host = "0.0.0.0"');
     expect(pgdogToml).toContain("port = 6432");
     expect(pgdogToml).toContain('pooler_mode = "transaction"');
+    expect(pgdogToml).toContain("default_pool_size = 20");
     expect(pgdogToml).toContain("[[databases]]");
     expect(pgdogToml).toContain('name = "oke"');
     expect(pgdogToml).toContain('host = "store-sql"');
     expect(pgdogToml).toContain("port = 5432");
     expect(pgdogToml).toContain('database_name = "oke"');
+    expect(pgdogToml).toContain("pool_size = 20");
 
     const usersToml = buildPgDogUsersToml({
       user: "oke",
@@ -936,6 +938,7 @@ describe("deriveInfrastructure", () => {
 
     const pgdogToml = result.files.find((f) => f.path === "pgdog/pgdog.toml")!.content;
     expect(pgdogToml).toContain('pooler_mode = "transaction"');
+    expect(pgdogToml).toContain("pool_size = 20");
     expect(pgdogToml).toContain('host = "store-sql"');
     expect(pgdogToml).not.toContain(fixedCreds["store.sql"].password);
 
@@ -957,7 +960,7 @@ describe("deriveInfrastructure", () => {
   test("Dockerfile CMD is oke start", () => {
     const df = emitDockerfile();
     expect(df).toContain('CMD ["oke", "start"]');
-    expect(df).toContain("oven/bun:1.3");
+    expect(df).toContain("oven/bun:1.4");
   });
 
   test("writeDerivedFiles never writes compose.override.yml", async () => {

package/src/docker/dockerfile.ts

@@ -19,7 +19,7 @@ export interface DockerfileOptions {
  */
 export function emitDockerfile(options: DockerfileOptions = {}): string {
   const port = options.appPort ?? APP_PORT;
-  const base = options.baseImage ?? "oven/bun:1.3";
+  const base = options.baseImage ?? "oven/bun:1.4";
   return `# generated by oke docker — do not edit
 FROM ${base} AS deps
 WORKDIR /app

package/src/docker/recipes/pgdog.ts

@@ -35,12 +35,14 @@ export function buildPgDogToml(opts: {
     'host = "0.0.0.0"',
     "port = 6432",
     'pooler_mode = "transaction"',
+    "default_pool_size = 20",
     "",
     "[[databases]]",
     `name = ${tomlString(db)}`,
     `host = ${tomlString(host)}`,
     `port = ${port}`,
     `database_name = ${tomlString(db)}`,
+    "pool_size = 20",
     "",
   ].join("\n");
 }

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.
  *