okengine 0.12.0 → 0.14.1

package/src/kernel/boot-bind/store.test.ts

@@ -3,11 +3,12 @@
  */
 
 import { afterEach, describe, expect, test } from "bun:test";
-import { files } from "../../elements/store.ts";
+import { files, store } from "../../elements/store.ts";
 import {
   bindStore,
   indexDriverFor,
   resetFilesFsWarnForTests,
+  resetKvDurableWarnsForTests,
   resolveFilesDriverId,
   resolveIndexDriverId,
   resolveKvDriverId,
@@ -98,6 +99,154 @@ describe("bindStore driver resolution", () => {
   });
 });
 
+describe("bindStore durable KV routing", () => {
+  const prev = {
+    redis: process.env.REDIS_URL,
+    kv: process.env.OKE_STORE_KV_URL,
+    database: process.env.DATABASE_URL,
+    sql: process.env.OKE_STORE_SQL_URL,
+  };
+
+  afterEach(() => {
+    resetKvDurableWarnsForTests();
+    if (prev.redis === undefined) delete process.env.REDIS_URL;
+    else process.env.REDIS_URL = prev.redis;
+    if (prev.kv === undefined) delete process.env.OKE_STORE_KV_URL;
+    else process.env.OKE_STORE_KV_URL = prev.kv;
+    if (prev.database === undefined) delete process.env.DATABASE_URL;
+    else process.env.DATABASE_URL = prev.database;
+    if (prev.sql === undefined) delete process.env.OKE_STORE_SQL_URL;
+    else process.env.OKE_STORE_SQL_URL = prev.sql;
+  });
+
+  test("pglite + durable in test does not throw or warn", () => {
+    const warnings: string[] = [];
+    const prevWarn = console.warn;
+    console.warn = (...args: unknown[]) => {
+      warnings.push(args.map(String).join(" "));
+    };
+    try {
+      bindStore(
+        { stores: [store.kv("ledger", { durable: true })] },
+        "test",
+        () => Date.now(),
+        false,
+      );
+      expect(warnings.some((w) => w.includes("durable"))).toBe(false);
+    } finally {
+      console.warn = prevWarn;
+    }
+  });
+
+  test("postgres + durable without DATABASE_URL throws outside test", () => {
+    delete process.env.DATABASE_URL;
+    delete process.env.OKE_STORE_SQL_URL;
+    process.env.REDIS_URL = "redis://cache";
+    expect(() =>
+      bindStore(
+        {
+          stores: [store.kv("ledger", { durable: true })],
+          config: {
+            drivers: {
+              store: {
+                sql: { dev: "postgres", test: "pglite", prod: "postgres" },
+                kv: { dev: "redis", test: "memory", prod: "redis" },
+              },
+            },
+          },
+        },
+        "dev",
+        () => Date.now(),
+        false,
+      ),
+    ).toThrow(/DATABASE_URL/);
+  });
+
+  test("redis + cache-shaped KV warns once outside test", () => {
+    process.env.REDIS_URL = "redis://cache";
+    const warnings: string[] = [];
+    const prevWarn = console.warn;
+    console.warn = (...args: unknown[]) => {
+      warnings.push(args.map(String).join(" "));
+    };
+    try {
+      const options = {
+        stores: [store.kv("sessions")],
+        config: {
+          drivers: {
+            store: {
+              sql: { dev: "memory", test: "memory", prod: "memory" },
+              kv: { dev: "redis", test: "memory", prod: "redis" },
+            },
+          },
+        },
+      };
+      bindStore(options, "dev", () => Date.now(), false);
+      bindStore(options, "dev", () => Date.now(), false);
+      expect(warnings.filter((w) => w.includes("cache-shaped"))).toHaveLength(1);
+    } finally {
+      console.warn = prevWarn;
+    }
+  });
+
+  test("non-durable KV keeps REDIS_URL; durable does not", async () => {
+    process.env.REDIS_URL = "redis://cache";
+    const sessions = store.kv("sessions");
+    const ledger = store.kv("ledger", { durable: true });
+    const runtime = bindStore(
+      {
+        stores: [sessions, ledger],
+        config: {
+          drivers: {
+            store: {
+              sql: { test: "pglite" },
+              kv: { test: "memory" },
+            },
+          },
+        },
+      },
+      "test",
+      () => Date.now(),
+      false,
+    );
+    const ctx = { effects: {} };
+    const cache = await runtime.open(sessions, ctx);
+    const durable = await runtime.open(ledger, ctx);
+    expect(cache.driverId).toBe("memory");
+    expect(durable.driverId).toBe("pglite");
+    await runtime.close();
+  });
+
+  test("memory SQL + durable in dev warns that memory cannot honor durability", () => {
+    const warnings: string[] = [];
+    const prevWarn = console.warn;
+    console.warn = (...args: unknown[]) => {
+      warnings.push(args.map(String).join(" "));
+    };
+    try {
+      bindStore(
+        {
+          stores: [store.kv("ledger", { durable: true })],
+          config: {
+            drivers: {
+              store: {
+                sql: { dev: "memory", test: "memory", prod: "memory" },
+                kv: { dev: "memory", test: "memory", prod: "redis" },
+              },
+            },
+          },
+        },
+        "dev",
+        () => Date.now(),
+        false,
+      );
+      expect(warnings.some((w) => w.includes("memory") && w.includes("durable"))).toBe(true);
+    } finally {
+      console.warn = prevWarn;
+    }
+  });
+});
+
 describe("bindStore files fs multi-instance warn", () => {
   afterEach(() => {
     resetFilesFsWarnForTests();

package/src/kernel/boot-bind/store.ts

@@ -34,12 +34,20 @@ import type { BootOptions } from "../boot.ts"; // type-only — no cycle at runt
  * @param docker - Prefer compose URLs when opening postgres/redis
  */
 let filesFsWarned = false;
+let kvCacheShapedWarned = false;
+let kvMemoryDurableWarned = false;
 
 /** Test helper — reset the one-shot `fs` multi-instance warn. */
 export function resetFilesFsWarnForTests(): void {
   filesFsWarned = false;
 }
 
+/** Test helper — reset durable-KV boot warns. */
+export function resetKvDurableWarnsForTests(): void {
+  kvCacheShapedWarned = false;
+  kvMemoryDurableWarned = false;
+}
+
 /**
  * Warn once when `drivers.store.files` is `fs` — per-process (or per-pod)
  * filesystem visibility under horizontal scale.
@@ -54,6 +62,39 @@ function warnFilesFsMultiInstance(): void {
   );
 }
 
+/**
+ * Warn once: default KV namespaces are cache-shaped (no AOF) unless
+ * `{ durable: true }` persists them in SQL (`oke_kv`).
+ */
+function warnKvCacheShaped(names: readonly string[]): void {
+  if (kvCacheShapedWarned) return;
+  kvCacheShapedWarned = true;
+  const listed = names
+    .slice(0, 4)
+    .map((n) => `"${n}"`)
+    .join(", ");
+  const extra = names.length > 4 ? ` (and ${String(names.length - 4)} more)` : "";
+  emitBootWarn(
+    `oke boot: store.kv ${listed}${extra} is cache-shaped — a Redis recreate drops keys ` +
+      "(no AOF). Declare `{ durable: true }` on a separate namespace to persist in " +
+      "your SQL database (`oke_kv`).",
+  );
+}
+
+/**
+ * Warn once: in-process memory SQL cannot honor `{ durable: true }`.
+ */
+function warnKvMemoryDurable(names: readonly string[]): void {
+  if (kvMemoryDurableWarned) return;
+  kvMemoryDurableWarned = true;
+  const listed = names.map((n) => `"${n}"`).join(", ");
+  emitBootWarn(
+    `oke boot: store.kv ${listed} declared { durable: true } but drivers.store.sql is ` +
+      '"memory" — keys are process-local and vanish on restart. Use drivers.store.sql ' +
+      "postgres with DATABASE_URL.",
+  );
+}
+
 export function bindStore(
   options: BootOptions,
   env: ConfigEnv,
@@ -65,9 +106,28 @@ export function bindStore(
   const filesId = resolveFilesDriverId(options, env, docker);
   const indexId = resolveIndexDriverId(options, env, docker);
   if (filesId === "fs") warnFilesFsMultiInstance();
+  const kvDecls = (options.stores ?? []).filter(isKvDecl);
+  const durableKvDecls = kvDecls.filter((d) => d.durable === true);
+  const cacheKvDecls = kvDecls.filter((d) => d.durable !== true);
+  if (durableKvDecls.length > 0 && sqlId === "postgres") {
+    const url = process.env.DATABASE_URL ?? process.env.OKE_STORE_SQL_URL;
+    if (!url) {
+      throw new Error(
+        docker
+          ? "oke boot: durable store.kv needs DATABASE_URL (did `oke dev` write .env.local?)"
+          : "oke boot: durable store.kv needs DATABASE_URL",
+      );
+    }
+  }
   const sqlUrl = sqlUrlFor(sqlId, docker, env);
   const kvUrl = kvUrlFor(kvId, docker);
   const filesRoot = filesRootFor(filesId);
+  if (kvId === "redis" && env !== "test" && cacheKvDecls.length > 0) {
+    warnKvCacheShaped(cacheKvDecls.map((d) => d.name));
+  }
+  if (sqlId === "memory" && env !== "test" && durableKvDecls.length > 0) {
+    warnKvMemoryDurable(durableKvDecls.map((d) => d.name));
+  }
 
   const sqlBindings: Record<string, { name: string; primary: { url: string } }> = {};
   const kvBindings: Record<string, { url?: string }> = {};
@@ -81,7 +141,11 @@ export function bindStore(
         primary: { url: sqlUrl },
       };
     } else if (isKvDecl(decl)) {
-      kvBindings[decl.name] = kvUrl !== undefined ? { url: kvUrl } : {};
+      if (decl.durable === true) {
+        kvBindings[decl.name] = {};
+      } else {
+        kvBindings[decl.name] = kvUrl !== undefined ? { url: kvUrl } : {};
+      }
     } else if (isFilesDecl(decl)) {
       filesBindings[decl.name] = filesRoot !== undefined ? { root: filesRoot } : {};
     } else if (isIndexDecl(decl)) {
@@ -114,6 +178,7 @@ export function bindStore(
     index: indexBindings,
     now,
     domainDdl,
+    sqlUrl,
   });
   for (const decl of options.stores ?? []) {
     store.register?.(decl);

package/src/kernel/boot.ts

@@ -550,7 +550,7 @@ export async function bootApplication(input: BootOptions = {}): Promise<BootResu
   // 6. AI
   let ai = pre.ai;
   if (needs.ai && !ai) {
-    ai = aiBind!.bindAi(options, gate, now, env, docker);
+    ai = aiBind!.bindAi(options, gate, now, env, docker, vault);
   }
 
   // 7. Runs
@@ -607,12 +607,14 @@ export async function bootApplication(input: BootOptions = {}): Promise<BootResu
         clearInterval(schedulerTimer);
         schedulerTimer = undefined;
       }
+      clock?.stopWakes();
     },
     async close() {
       if (schedulerTimer !== undefined) {
         clearInterval(schedulerTimer);
         schedulerTimer = undefined;
       }
+      clock?.stopWakes();
       await signal?.close();
       await vault?.close();
       await runs?.flush();

package/src/kernel/element-registries.ts

@@ -1,7 +1,7 @@
 /**
  * Module-evaluation registries for `store.sql` / `store.files`, `vault.secret`,
  * `vault.env.required`, `signal()`, `channel.<medium>().template()`, and
- * `ai.model` / `.prompt` / `ai.embed` / `ai.agent` — the plain arrays behind
+ * `ai.model` / `.prompt` / `ai.embed` / `ai.agent` / `ai.mcpServer` — the plain arrays behind
  * each declare module's `listX()` / `resetX()` pair (mirrors `on.ts`'s
  * trigger-drain `bindings` array).
  *
@@ -16,6 +16,7 @@
 import type {
   AiAgentDecl,
   AiEmbedDecl,
+  AiMcpServerDecl,
   AiModelDecl,
   AiPromptDecl,
 } from "../elements/ai/declare.ts";
@@ -42,3 +43,5 @@ export const aiPromptRegistry: AiPromptDecl[] = [];
 export const aiEmbedRegistry: AiEmbedDecl[] = [];
 /** `ai.agent` declarations since the last reset. */
 export const aiAgentRegistry: AiAgentDecl[] = [];
+/** `ai.mcpServer` declarations since the last reset. */
+export const aiMcpServerRegistry: AiMcpServerDecl[] = [];

package/src/kernel/fx-dead-letters.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, test } from "bun:test";
+import { memorySignalDriver } from "../drivers/index.ts";
+import { createSignalRuntime, signal, type SignalDecl } from "../elements/signal.ts";
+import { OkeError } from "./errors.ts";
+import { createFx, createFxContext, signalReadRef } from "./fx.ts";
+
+describe("fx.deadLetters", () => {
+  test("returns dead-lettered messages for a declared signal read", async () => {
+    const notify = signal("notify", { delivery: "once", retries: 0, deadLetter: true });
+    const runtime = openRuntime(notify);
+    const bus = await runtime.start();
+    await bus.subscribe("notify", "c1", async () => {
+      throw new Error("smtp-down");
+    });
+    await runtime.emit("notify", { orderId: "ord_1" });
+    await bus.drain();
+
+    const { fx, ledger } = createFxContext({
+      flow: "notifications.failed",
+      effects: { reads: [signalReadRef("notify")] },
+      signalRuntime: runtime,
+    });
+
+    const dead = await fx.deadLetters(notify);
+    expect(dead).toHaveLength(1);
+    expect(dead[0]!.payload).toEqual({ orderId: "ord_1" });
+    expect(dead[0]!.status).toBe("dead");
+    expect(dead[0]!.attempts).toBe(1);
+    expect(dead[0]!.failures[0]!.message).toBe("smtp-down");
+    expect(ledger.entries.map((e) => `${e.kind}:${e.resource}`)).toEqual(["read:signal:notify"]);
+
+    await runtime.close();
+  });
+
+  test("undeclared and cross-signal reads throw OKE1001", async () => {
+    const notify = signal("notify", { delivery: "once", retries: 0, deadLetter: true });
+    const other = signal("other", { delivery: "once", retries: 0, deadLetter: true });
+    const runtime = openRuntime(notify);
+    const fx = createFx({
+      flow: "notifications.failed",
+      effects: { reads: [signalReadRef("notify")] },
+      signalRuntime: runtime,
+    });
+
+    let err: unknown;
+    try {
+      await fx.deadLetters(other);
+    } catch (e) {
+      err = e;
+    }
+    expect(err).toBeInstanceOf(OkeError);
+    const oke = err as OkeError;
+    expect(oke.code).toBe(1001);
+    expect(oke.causeText).toBe(
+      'Flow "notifications.failed" reads "signal:other" without declaring it.',
+    );
+    expect(oke.fix).toBe('Add "signal:other" to this flow\'s effects.reads.');
+
+    await runtime.close();
+  });
+
+  test("throws when no signal runtime is bound", async () => {
+    const fx = createFx({
+      flow: "notifications.failed",
+      effects: { reads: [signalReadRef("notify")] },
+    });
+    await expect(fx.deadLetters("notify")).rejects.toThrow(
+      "fx.deadLetters requires a bound signal runtime",
+    );
+  });
+});
+
+function openRuntime(decl: SignalDecl) {
+  const runtime = createSignalRuntime({ driver: memorySignalDriver });
+  runtime.register(decl);
+  return runtime;
+}

package/src/kernel/fx.test.ts

@@ -361,11 +361,17 @@ describe("fx — wholesale swap", () => {
       async emit(signal) {
         calls.push(`emit:${typeof signal === "string" ? signal : signal.name}`);
       },
+      async deadLetters() {
+        return [];
+      },
       async call() {
         return null;
       },
       clock: {
         now: () => 0,
+        ago: () => 0,
+        fromNow: () => 0,
+        duration: () => 0,
         sleep: async () => undefined,
       },
       vault: {
@@ -451,6 +457,9 @@ describe("fx — wholesale swap", () => {
         withQuery(rows) {
           return { [jsonResultBrand]: true, status: 200, value: [...rows], meta: {} };
         },
+        stream(chunks) {
+          return { [jsonResultBrand]: true, kind: "stream" as const, status: 200 as const, chunks };
+        },
       },
       async step(_name, fn) {
         return fn();
@@ -514,6 +523,19 @@ describe("fx.t — catalogs", () => {
   });
 });
 
+describe("fx.clock — relative instants", () => {
+  test("ago / fromNow / duration use the injected now and duration strings", () => {
+    const fx = createFx({ flow: "sessions.sweepExpired", effects: {}, now: () => 1_000_000 });
+    expect(fx.clock.now()).toBe(1_000_000);
+    expect(fx.clock.duration("30d")).toBe(30 * 86_400_000);
+    expect(fx.clock.ago("30d")).toBe(1_000_000 - 30 * 86_400_000);
+    expect(fx.clock.fromNow("14d")).toBe(1_000_000 + 14 * 86_400_000);
+    expect(fx.clock.duration("nope")).toBe(0);
+    expect(fx.clock.ago("nope")).toBe(1_000_000);
+    expect(fx.clock.fromNow("200ms")).toBe(1_000_200);
+  });
+});
+
 describe("fx.json", () => {
   test("with accepts a page or (data, meta)", () => {
     const fx = createFx({ flow: "x", effects: {} });

package/src/kernel/fx.ts

@@ -9,7 +9,8 @@
  * for deterministic tests (§7.6).
  */
 
-import type { Effects, ResourceRef } from "../manifest/types.ts";
+import type { Effects, ResourceRef, SignalResourceRef } from "../manifest/types.ts";
+import { isMcpToolRef } from "../manifest/mcp-ref.ts";
 import type { QueryPageSpec } from "./list-page.ts";
 import { schemaTableName, sqlTableRef } from "../manifest/sql-resource.ts";
 import type {
@@ -27,8 +28,8 @@ import type {
   SqlStoreHandle,
 } from "../elements/store.ts";
 import type { SqlRow } from "../drivers/types.ts";
-import type { SignalRuntime } from "../elements/signal.ts";
-import type { SignalEmitOptions } from "../drivers/signal-types.ts";
+import type { SignalDecl, SignalRuntime } from "../elements/signal.ts";
+import type { DeadLetter, SignalEmitOptions } from "../drivers/signal-types.ts";
 import type { VaultActor, VaultAdapter, VaultRuntime } from "../elements/vault.ts";
 import type { ChannelRuntime } from "../elements/channel.ts";
 import type { AiRuntime } from "../elements/ai.ts";
@@ -73,6 +74,15 @@ async function loadRunsWindow(): Promise<typeof import("../runs/window.ts")> {
 /** Resource ref Flows declare to read the Runs store via {@link Fx.runs}. */
 export const RUNS_RESOURCE = "runs";
 
+/**
+ * Capability ref for {@link Fx.deadLetters} — `signal:<name>`, never a store facet.
+ *
+ * @param name - Signal name
+ */
+export function signalReadRef(name: string): SignalResourceRef {
+  return `signal:${name}`;
+}
+
 export type { FxRetryOptions, FxThunk } from "./concurrency.ts";
 
 /** Named ref: plain string or `{ name }` element handle (optional pin). */
@@ -140,6 +150,27 @@ export interface FxTenant {
 export interface FxClock {
   /** Current epoch-ms (injectable via {@link CreateFxOptions.now}). */
   now(): number;
+  /**
+   * Instant `duration` before {@link FxClock.now} (`"30d"` → now − 30 days).
+   * Uses the same duration strings as {@link FxClock.sleep} / `every()`.
+   *
+   * @param duration - Duration string (e.g. `"30d"`, `"2h"`)
+   */
+  ago(duration: string): number;
+  /**
+   * Instant `duration` after {@link FxClock.now} (`"14d"` → now + 14 days).
+   * Uses the same duration strings as {@link FxClock.sleep} / `every()`.
+   *
+   * @param duration - Duration string (e.g. `"14d"`, `"15m"`)
+   */
+  fromNow(duration: string): number;
+  /**
+   * Span in milliseconds (`"30d"` → `2_592_000_000`). Compose with a stored
+   * instant: `createdAt + fx.clock.duration("7d")`. Unknown strings are `0`.
+   *
+   * @param duration - Duration string (e.g. `"30d"`, `"200ms"`)
+   */
+  duration(duration: string): number;
   /**
    * Durable sleep — when the flow is `durable`, journals the wake time and
    * survives restart / deploy. Without a journal, resolves immediately
@@ -323,12 +354,36 @@ export interface JsonResult<T = unknown> {
   readonly status: number;
   readonly value?: T;
   readonly meta?: Record<string, unknown>;
+  readonly kind?: undefined;
+}
+
+/** SSE carrier from {@link FxJson.stream}. */
+export interface JsonStreamResult {
+  readonly [jsonResultBrand]: true;
+  readonly kind: "stream";
+  readonly status: 200;
+  readonly chunks: AsyncIterable<string>;
+  /** Set by the kernel to commit journal / Runs after the stream settles. */
+  finalize?: () => Promise<void>;
 }
 
-/** True when `value` is an {@link FxJson} carrier. */
+/** True when `value` is an {@link FxJson} JSON-envelope carrier. */
 export function isJsonResult(value: unknown): value is JsonResult {
   return (
-    typeof value === "object" && value !== null && (value as JsonResult)[jsonResultBrand] === true
+    typeof value === "object" &&
+    value !== null &&
+    (value as JsonResult)[jsonResultBrand] === true &&
+    (value as JsonStreamResult).kind !== "stream"
+  );
+}
+
+/** True when `value` is an SSE stream carrier from {@link FxJson.stream}. */
+export function isJsonStreamResult(value: unknown): value is JsonStreamResult {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    (value as JsonStreamResult)[jsonResultBrand] === true &&
+    (value as JsonStreamResult).kind === "stream"
   );
 }
 
@@ -363,6 +418,11 @@ export interface FxJson {
    * every string field; extra keys auto-eq except `id`.
    */
   withQuery<T>(rows: readonly T[], input: unknown, spec?: QueryPageSpec<T>): JsonResult<T[]>;
+  /**
+   * 200 — `text/event-stream` of JSON `data:` frames, then `data: [DONE]`.
+   * Pass {@link Fx.stream} or any async iterable of token strings.
+   */
+  stream(chunks: AsyncIterable<string>): JsonStreamResult;
 }
 
 /**
@@ -567,6 +627,15 @@ export interface Fx {
    * @param options - Optional emit options (`key` for per-key once ordering)
    */
   emit(signal: NamedRef, payload?: unknown, options?: SignalEmitOptions): Promise<void>;
+  /**
+   * Query dead-lettered messages for one signal (records `read` on `signal:<name>`).
+   *
+   * Requires a bound signal runtime and `effects.reads` including `signal:<name>`.
+   *
+   * @param signal - Signal name or handle
+   */
+  deadLetters<T>(signal: SignalDecl<T>): Promise<readonly DeadLetter<T>[]>;
+  deadLetters(signal: NamedRef): Promise<readonly DeadLetter[]>;
   /**
    * Call another flow (records `call`). Stub returns `undefined`.
    *
@@ -651,7 +720,11 @@ export interface Fx {
    */
   stream(
     model: NamedRef,
-    opts?: { readonly prompt?: string; readonly data?: unknown },
+    opts?: {
+      readonly prompt?: string;
+      readonly data?: unknown;
+      readonly via?: readonly NamedRef[];
+    },
   ): AsyncIterable<string>;
   /** Logger. */
   readonly log: FxLog;
@@ -1336,6 +1409,15 @@ export function createFxContext(options: CreateFxOptions): FxContext {
 
   const clock: FxClock = {
     now,
+    ago(duration: string): number {
+      return now() - parseDurationMs(duration);
+    },
+    fromNow(duration: string): number {
+      return now() + parseDurationMs(duration);
+    },
+    duration(duration: string): number {
+      return parseDurationMs(duration);
+    },
     async sleep(label: string, duration: string): Promise<void> {
       if (journal) {
         await journal.sleep(label, duration, parseDurationMs);
@@ -1591,9 +1673,24 @@ export function createFxContext(options: CreateFxOptions): FxContext {
         }
       });
     },
+    deadLetters(signal: NamedRef) {
+      const name = resolveName(signal);
+      return gated("read", signalReadRef(name), async () => {
+        if (!options.signalRuntime) {
+          throw new Error("fx.deadLetters requires a bound signal runtime");
+        }
+        return options.signalRuntime.deadLetters(name);
+      });
+    },
     call(flow, input) {
       const name = resolveName(flow);
       return gated("call", name, async () => {
+        if (isMcpToolRef(name)) {
+          if (!options.aiRuntime) {
+            throw new Error(`fx.call: AI runtime is not configured for MCP tool "${name}"`);
+          }
+          return options.aiRuntime.callMcp(name, input, currentAbortSignal());
+        }
         if (options.callHandler) {
           return options.callHandler(name, input);
         }
@@ -1785,6 +1882,7 @@ export function createFxContext(options: CreateFxOptions): FxContext {
             prompt: opts?.prompt,
             data: opts?.data,
             signal: local.signal,
+            via: opts?.via?.map(resolveName),
           })) {
             if (local.signal.aborted) break;
             yield text;
@@ -1832,6 +1930,14 @@ export function createFxContext(options: CreateFxOptions): FxContext {
       },
       with: jsonWith,
       withQuery: jsonWithQuery,
+      stream(chunks) {
+        return {
+          [jsonResultBrand]: true,
+          kind: "stream" as const,
+          status: 200 as const,
+          chunks,
+        };
+      },
     },
     async step<T>(name: string, fn: () => T | Promise<T>, opts?: StepOptions<T>): Promise<T> {
       if (journal) {