@kuralle-syrinx/kuralle 2.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Kuralle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,35 @@
+# @kuralle-syrinx/kuralle
+
+The Kuralle adapter for the Syrinx [`Reasoner`](../core/README.md#the-reasoner-seam) seam: **`fromKuralleRuntime(runtime, { sessionId }) → Reasoner`**. Drop it into [`ReasoningBridge`](../aisdk/README.md) to drive the voice pipeline with a Kuralle `Runtime` instead of a raw AI SDK backend — no pipeline change.
+
+## Usage
+
+```ts
+import { createRuntime, defineAgent } from "@kuralle-agents/core";
+import { ReasoningBridge } from "@kuralle-syrinx/aisdk";
+import { fromKuralleRuntime } from "@kuralle-syrinx/kuralle";
+
+const runtime = createRuntime({ agents: [defineAgent({ id: "support", /* ... */ })], /* ... */ });
+session.registerPlugin("bridge", new ReasoningBridge(fromKuralleRuntime(runtime, { sessionId })));
+```
+
+## How it maps
+
+`fromKuralleRuntime` calls `runtime.run({ input: turn.userText, sessionId, ... })` and iterates `events` (an `AsyncIterable<KuralleStreamPart>`), mapping each part → `ReasoningPart`. **`turn.messages` is ignored** — Kuralle owns conversation history via `sessionId`.
+
+| Kuralle part | → |
+|---|---|
+| `text-delta` (`delta`) | `text-delta` |
+| `tool-call` (`toolCallId`, `toolName`, `args`) | `tool-call` |
+| `tool-result` (`toolCallId`, `toolName`, `result`) | `tool-result` |
+| `paused` / `interactive` | terminal `suspended` |
+| `done` | `finish` (`reason: "stop"`, accumulated text) |
+| `error` (`error`) | terminal `error` |
+| anything else | dropped |
+
+`KuralleRuntimeLike` is the minimal structural type the adapter needs (`run` → `events`) — the concrete `@kuralle-agents/core` `Runtime` satisfies it.
+
+## Gotchas
+
+- **`@kuralle-agents/core` is a `peerDependency`** — the consumer instantiates and owns the `Runtime`. The adapter only touches `run`/`events`.
+- **History stays Kuralle-owned** via `sessionId`: the bridge passes only `turn.userText` per turn; do not expect Syrinx message history to reach Kuralle.

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@kuralle-syrinx/kuralle",
+  "version": "2.1.0",
+  "private": false,
+  "type": "module",
+  "license": "MIT",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "dependencies": {
+    "@kuralle-syrinx/core": "2.1.0"
+  },
+  "peerDependencies": {
+    "@kuralle-agents/core": ">=0.8.0"
+  },
+  "devDependencies": {
+    "@kuralle-agents/core": "^0.8.5",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}

package/src/from-kuralle.test.ts

@@ -0,0 +1,297 @@
+// SPDX-License-Identifier: MIT
+
+import { describe, expect, it } from "vitest";
+import type { Reasoner, ReasonerTurn, ReasoningPart } from "@kuralle-syrinx/core";
+import {
+  buildKuralleTurnRunOptions,
+  fromKuralleRuntime,
+  reconcileSpokenPrefix,
+  rewriteLastAssistant,
+  type KuralleMessageLike,
+  type KuralleRuntimeLike,
+  type KuralleSessionStoreLike,
+  type KuralleStoredSession,
+  type KuralleStreamPart,
+} from "./from-kuralle.js";
+
+function baseTurn(): ReasonerTurn {
+  return {
+    userText: "Hi",
+    messages: [{ role: "system", content: "test" }],
+    signal: new AbortController().signal,
+  };
+}
+
+function textDelta(delta: string): KuralleStreamPart {
+  return { type: "text-delta", delta };
+}
+
+function toolCall(toolCallId: string, toolName: string, args: Record<string, unknown>): KuralleStreamPart {
+  return { type: "tool-call", toolCallId, toolName, args };
+}
+
+function toolResult(toolCallId: string, toolName: string, result: unknown): KuralleStreamPart {
+  return { type: "tool-result", toolCallId, toolName, result };
+}
+
+function errorPart(error: string): KuralleStreamPart {
+  return { type: "error", error };
+}
+
+function done(sessionId?: string): KuralleStreamPart {
+  return { type: "done", sessionId };
+}
+
+async function* partsToEvents(parts: KuralleStreamPart[]): AsyncIterable<KuralleStreamPart> {
+  for (const p of parts) yield p;
+}
+
+function fakeRuntime(
+  parts: KuralleStreamPart[],
+  spy?: {
+    runOpts?: {
+      input?: string;
+      sessionId?: string;
+      userId?: string;
+      agentId?: string;
+      abortSignal?: AbortSignal;
+    };
+  },
+): KuralleRuntimeLike {
+  return {
+    run(opts) {
+      if (spy) spy.runOpts = opts;
+      return { events: partsToEvents(parts) };
+    },
+  };
+}
+
+async function collectParts(reasoner: Reasoner, turn: ReasonerTurn): Promise<ReasoningPart[]> {
+  const collected: ReasoningPart[] = [];
+  for await (const part of reasoner.stream(turn)) {
+    collected.push(part);
+  }
+  return collected;
+}
+
+describe("fromKuralleRuntime", () => {
+  it("maps happy path: text deltas and done to finish:stop", async () => {
+    const reasoner = fromKuralleRuntime(
+      fakeRuntime([textDelta("Hi"), textDelta(" there"), done("sess-1")]),
+      { sessionId: "sess-1" },
+    );
+
+    const parts = await collectParts(reasoner, baseTurn());
+
+    expect(parts).toEqual([
+      { type: "text-delta", text: "Hi" },
+      { type: "text-delta", text: " there" },
+      { type: "finish", reason: "stop", text: "Hi there" },
+    ]);
+  });
+
+  it("maps tool-call and tool-result with toolId from toolCallId", async () => {
+    const reasoner = fromKuralleRuntime(
+      fakeRuntime([
+        toolCall("tc-1", "lookup", { id: "123" }),
+        toolResult("tc-1", "lookup", { found: true }),
+        done(),
+      ]),
+      { sessionId: "sess-1" },
+    );
+
+    const parts = await collectParts(reasoner, baseTurn());
+
+    expect(parts).toEqual([
+      {
+        type: "tool-call",
+        toolId: "tc-1",
+        toolName: "lookup",
+        args: { id: "123" },
+      },
+      {
+        type: "tool-result",
+        toolId: "tc-1",
+        toolName: "lookup",
+        result: JSON.stringify({ found: true }),
+      },
+      { type: "finish", reason: "stop", text: "" },
+    ]);
+  });
+
+  it("maps error part to terminal error", async () => {
+    const reasoner = fromKuralleRuntime(fakeRuntime([errorPart("boom")]), { sessionId: "sess-1" });
+
+    const parts = await collectParts(reasoner, baseTurn());
+
+    expect(parts).toHaveLength(1);
+    expect(parts[0]?.type).toBe("error");
+    if (parts[0]?.type === "error") {
+      expect(parts[0].cause.message).toBe("boom");
+      expect(parts[0].recoverable).toBe(false);
+    }
+  });
+
+  it("yields terminal error when stream ends without done", async () => {
+    const reasoner = fromKuralleRuntime(fakeRuntime([textDelta("partial")]), { sessionId: "sess-1" });
+
+    const parts = await collectParts(reasoner, baseTurn());
+
+    expect(parts).toHaveLength(2);
+    expect(parts[0]).toEqual({ type: "text-delta", text: "partial" });
+    expect(parts[1]?.type).toBe("error");
+    if (parts[1]?.type === "error") {
+      expect(parts[1].cause.message).toBe("Kuralle stream ended without a done part");
+      expect(parts[1].recoverable).toBe(false);
+    }
+  });
+
+  it("returns without yielding when turn.signal is already aborted", async () => {
+    const controller = new AbortController();
+    controller.abort();
+    const turn: ReasonerTurn = { ...baseTurn(), signal: controller.signal };
+
+    const reasoner = fromKuralleRuntime(
+      fakeRuntime([textDelta("should not appear"), done()]),
+      { sessionId: "sess-1" },
+    );
+
+    const parts = await collectParts(reasoner, turn);
+
+    expect(parts).toEqual([]);
+  });
+
+  it("passes only userText to run, not turn.messages", async () => {
+    const spy: { runOpts?: { input?: string; sessionId?: string } } = {};
+    const reasoner = fromKuralleRuntime(fakeRuntime([done()], spy), { sessionId: "sess-42" });
+
+    const turn: ReasonerTurn = {
+      userText: "What is my name?",
+      messages: [
+        { role: "system", content: "ignored" },
+        { role: "user", content: "also ignored" },
+      ],
+      signal: new AbortController().signal,
+    };
+    await collectParts(reasoner, turn);
+
+    expect(spy.runOpts?.input).toBe("What is my name?");
+    expect(spy.runOpts?.sessionId).toBe("sess-42");
+  });
+
+  it("flow resume pre-appends user message and omits input", async () => {
+    const sessionId = "sess-flow";
+    const store = createMockSessionStore(sessionId, [{ role: "assistant", content: "What is your name?" }]);
+    const session = (await store.get(sessionId))!;
+    session.durableRuns = {
+      [sessionId]: {
+        runState: {
+          activeFlow: "book-advisor-appointment",
+          messages: [{ role: "assistant", content: "What is your name?" }],
+        },
+        steps: [],
+      },
+    };
+    await store.save(session);
+
+    const runtime: KuralleRuntimeLike = {
+      run: () => ({ events: partsToEvents([done()]) }),
+      getSession: (id) => store.get(id),
+      getSessionStore: () => store,
+    };
+
+    const opts = await buildKuralleTurnRunOptions(runtime, {
+      sessionId,
+      userText: "Priya, CS masters, Friday",
+    });
+
+    expect(opts.input).toBeUndefined();
+    expect(opts.historyDelta).toBeUndefined();
+    const saved = await store.get(sessionId);
+    expect(saved?.messages.at(-1)).toEqual({ role: "user", content: "Priya, CS masters, Friday" });
+    const runMessages = (
+      saved?.durableRuns as Record<string, { runState: { messages: KuralleMessageLike[] } }>
+    )[sessionId]?.runState.messages;
+    expect(runMessages?.at(-1)).toEqual({ role: "user", content: "Priya, CS masters, Friday" });
+  });
+
+  it("rewriteLastAssistant truncates only when spoken prefix is shorter", () => {
+    const messages: KuralleMessageLike[] = [
+      { role: "user", content: "Hi" },
+      { role: "assistant", content: "Hello there friend" },
+    ];
+    expect(rewriteLastAssistant(messages, "Hello")).toEqual([
+      { role: "user", content: "Hi" },
+      { role: "assistant", content: "Hello" },
+    ]);
+    expect(rewriteLastAssistant(messages, "Hello there friend")).toStrictEqual(messages);
+  });
+
+  it("after barge-in abort, reconciles persisted assistant message to spoken prefix", async () => {
+    const fullText = "Hello there friend";
+    const spokenPrefix = "Hello";
+    const sessionId = "sess-barge";
+    const store = createMockSessionStore(sessionId, []);
+
+    await reconcileSpokenPrefix(
+      { run: () => ({ events: partsToEvents([]) }), getSessionStore: () => store },
+      sessionId,
+      spokenPrefix,
+    );
+    let session = await store.get(sessionId);
+    expect(session?.messages).toEqual([]);
+
+    session = (await store.get(sessionId)) ?? { id: sessionId, messages: [] };
+    session.messages = [{ role: "assistant", content: fullText }];
+    await store.save(session);
+
+    await reconcileSpokenPrefix(
+      { run: () => ({ events: partsToEvents([]) }), getSessionStore: () => store },
+      sessionId,
+      spokenPrefix,
+    );
+    session = await store.get(sessionId);
+    expect(session?.messages.at(-1)).toEqual({ role: "assistant", content: spokenPrefix });
+  });
+
+  it("reconcileSpokenPrefix rewrites durable run messages", async () => {
+    const sessionId = "sess-durable";
+    const store = createMockSessionStore(sessionId, []);
+    const session = (await store.get(sessionId))!;
+    session.messages = [{ role: "assistant", content: "full reply text" }];
+    session.durableRuns = {
+      [sessionId]: {
+        runState: { messages: [{ role: "assistant", content: "full reply text" }] },
+        steps: [],
+      },
+    };
+    await store.save(session);
+
+    await reconcileSpokenPrefix(
+      { run: () => ({ events: partsToEvents([]) }), getSessionStore: () => store },
+      sessionId,
+      "full",
+    );
+
+    const saved = await store.get(sessionId);
+    expect(saved?.messages.at(-1)).toEqual({ role: "assistant", content: "full" });
+    const runState = (saved?.durableRuns as Record<string, { runState: { messages: KuralleMessageLike[] } }>)[sessionId]
+      ?.runState;
+    expect(runState?.messages.at(-1)).toEqual({ role: "assistant", content: "full" });
+  });
+});
+
+function createMockSessionStore(sessionId: string, messages: KuralleMessageLike[]): KuralleSessionStoreLike {
+  const sessions = new Map<string, KuralleStoredSession>([
+    [sessionId, { id: sessionId, messages: [...messages] }],
+  ]);
+  return {
+    async get(id) {
+      const session = sessions.get(id);
+      return session ? structuredClone(session) : null;
+    },
+    async save(session) {
+      sessions.set(session.id, structuredClone(session));
+    },
+  };
+}

package/src/from-kuralle.ts

@@ -0,0 +1,323 @@
+// SPDX-License-Identifier: MIT
+
+import type { Reasoner, ReasonerTurn, ReasoningPart } from "@kuralle-syrinx/core";
+import { categorizeLlmError, isRecoverable } from "@kuralle-syrinx/core";
+
+export interface KuralleStreamPart {
+  readonly type: string;
+  readonly delta?: string;
+  readonly toolName?: string;
+  readonly args?: unknown;
+  readonly toolCallId?: string;
+  readonly result?: unknown;
+  readonly error?: string;
+  readonly waitingFor?: string;
+  readonly nodeId?: string;
+  readonly options?: unknown;
+  readonly prompt?: string;
+  readonly sessionId?: string;
+}
+
+export interface KuralleMessageLike {
+  readonly role: string;
+  content: unknown;
+}
+
+export interface KuralleStoredSession {
+  readonly id: string;
+  messages: KuralleMessageLike[];
+  [key: string]: unknown;
+}
+
+export interface KuralleSessionStoreLike {
+  get(id: string): Promise<KuralleStoredSession | null>;
+  save(session: KuralleStoredSession): Promise<void>;
+}
+
+export interface KuralleTurnHandle {
+  readonly events: AsyncIterable<KuralleStreamPart>;
+  then?: PromiseLike<unknown>["then"];
+}
+
+export interface KuralleRunOptions {
+  readonly input?: string;
+  readonly sessionId?: string;
+  readonly userId?: string;
+  readonly agentId?: string;
+  readonly abortSignal?: AbortSignal;
+  readonly historyDelta?: ReadonlyArray<{ readonly role: string; readonly content: string }>;
+}
+
+export interface KuralleRuntimeLike {
+  run(opts: KuralleRunOptions): KuralleTurnHandle;
+  getSession?(sessionId: string): Promise<KuralleStoredSession | null>;
+  getSessionStore?(): KuralleSessionStoreLike;
+}
+
+export interface FromKuralleRuntimeOptions {
+  readonly sessionId: string;
+  readonly userId?: string;
+  readonly agentId?: string;
+}
+
+const DURABLE_RUNS_KEY = "durableRuns";
+
+export function fromKuralleRuntime(runtime: KuralleRuntimeLike, opts: FromKuralleRuntimeOptions): Reasoner {
+  return { stream: (turn) => streamFromKuralle(runtime, turn, opts) };
+}
+
+async function buildKuralleRunOptions(
+  runtime: KuralleRuntimeLike,
+  turn: ReasonerTurn,
+  opts: FromKuralleRuntimeOptions,
+): Promise<KuralleRunOptions> {
+  const base: KuralleRunOptions = {
+    sessionId: opts.sessionId,
+    userId: opts.userId,
+    agentId: opts.agentId,
+    abortSignal: turn.signal,
+  };
+  if (!turn.userText) return base;
+  if (!runtime.getSession) {
+    return { ...base, input: turn.userText };
+  }
+  const session = await runtime.getSession(opts.sessionId);
+  const runState = readActiveRunState(session, opts.sessionId);
+  if (runState?.activeFlow) {
+    const appended = await appendFlowResumeUserMessage(runtime, opts.sessionId, turn.userText);
+    if (appended) return base;
+  }
+  return { ...base, input: turn.userText };
+}
+
+export async function buildKuralleTurnRunOptions(
+  runtime: KuralleRuntimeLike,
+  params: FromKuralleRuntimeOptions & { readonly userText: string; readonly signal?: AbortSignal },
+): Promise<KuralleRunOptions> {
+  const turn: ReasonerTurn = {
+    userText: params.userText,
+    messages: [],
+    signal: params.signal ?? new AbortController().signal,
+  };
+  return buildKuralleRunOptions(runtime, turn, params);
+}
+
+export function runKuralleTurn(
+  runtime: KuralleRuntimeLike,
+  runOpts: KuralleRunOptions,
+): KuralleTurnHandle {
+  return runtime.run(runOpts);
+}
+
+export async function awaitKuralleTurn(handle: KuralleTurnHandle): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    if (typeof handle.then === "function") {
+      handle.then(() => resolve(), reject);
+      return;
+    }
+    resolve();
+  });
+}
+
+function readActiveRunState(
+  session: KuralleStoredSession | null,
+  sessionId: string,
+): { activeFlow?: string } | undefined {
+  if (!session) return undefined;
+  const runs = session[DURABLE_RUNS_KEY];
+  if (!runs || typeof runs !== "object" || Array.isArray(runs)) return undefined;
+  const persisted = (runs as Record<string, unknown>)[sessionId];
+  if (!persisted || typeof persisted !== "object") return undefined;
+  const runState = (persisted as { runState?: { activeFlow?: string } }).runState;
+  return runState;
+}
+
+async function appendFlowResumeUserMessage(
+  runtime: KuralleRuntimeLike,
+  sessionId: string,
+  userText: string,
+): Promise<boolean> {
+  const store = runtime.getSessionStore?.();
+  if (!store) return false;
+
+  const session = await store.get(sessionId);
+  if (!session) return false;
+
+  const userMessage: KuralleMessageLike = { role: "user", content: userText };
+  session.messages = [...session.messages, userMessage];
+
+  const wm = session.workingMemory;
+  if (wm && typeof wm === "object" && !Array.isArray(wm)) {
+    delete (wm as Record<string, unknown>)["__v2_pendingUserInput"];
+  }
+
+  const runs = session[DURABLE_RUNS_KEY];
+  if (runs && typeof runs === "object" && !Array.isArray(runs)) {
+    const persisted = (runs as Record<string, unknown>)[sessionId];
+    if (persisted && typeof persisted === "object") {
+      const runState = (persisted as { runState?: { messages?: KuralleMessageLike[] } }).runState;
+      if (runState) {
+        runState.messages = [...(runState.messages ?? []), userMessage];
+      }
+    }
+  }
+
+  await store.save(session);
+  return true;
+}
+
+export async function* streamFromKuralle(
+  runtime: KuralleRuntimeLike,
+  turn: ReasonerTurn,
+  opts: FromKuralleRuntimeOptions,
+): AsyncGenerator<ReasoningPart> {
+  const runOpts = await buildKuralleRunOptions(runtime, turn, opts);
+  const handle = runtime.run(runOpts);
+
+  let acc = "";
+  let aborted = false;
+  try {
+    for await (const part of handle.events) {
+      if (turn.signal.aborted) {
+        aborted = true;
+        break;
+      }
+      switch (part.type) {
+        case "text-delta": {
+          const t = String(part.delta ?? "");
+          acc += t;
+          yield { type: "text-delta", text: t };
+          if (turn.signal.aborted) {
+            aborted = true;
+          }
+          break;
+        }
+        case "tool-call":
+          yield {
+            type: "tool-call",
+            toolId: String(part.toolCallId ?? ""),
+            toolName: String(part.toolName ?? ""),
+            args: toRecord(part.args),
+          };
+          break;
+        case "tool-result":
+          yield {
+            type: "tool-result",
+            toolId: String(part.toolCallId ?? ""),
+            toolName: String(part.toolName ?? ""),
+            result: stringifyResult(part.result),
+          };
+          break;
+        case "error":
+          yield toErrorPart(new Error(String(part.error ?? "Kuralle error")));
+          return;
+        case "paused":
+          yield {
+            type: "suspended",
+            runId: opts.sessionId,
+            prompt: typeof part.waitingFor === "string" ? part.waitingFor : undefined,
+            payload: part,
+          };
+          return;
+        case "interactive":
+          yield {
+            type: "suspended",
+            runId: opts.sessionId,
+            prompt: typeof part.prompt === "string" ? part.prompt : undefined,
+            payload: part,
+          };
+          return;
+        case "done":
+          yield { type: "finish", reason: "stop", text: acc };
+          return;
+        default:
+          break;
+      }
+      if (aborted) break;
+    }
+  } finally {
+    await awaitKuralleTurn(handle).catch(() => undefined);
+    if (aborted && acc.length > 0) {
+      await reconcileSpokenPrefix(runtime, opts.sessionId, acc);
+    }
+  }
+
+  if (aborted) return;
+
+  yield toErrorPart(new Error("Kuralle stream ended without a done part"));
+}
+
+export async function reconcileSpokenPrefix(
+  runtime: KuralleRuntimeLike,
+  sessionId: string,
+  spokenPrefix: string,
+): Promise<void> {
+  const store = runtime.getSessionStore?.();
+  if (!store) return;
+
+  const session = await store.get(sessionId);
+  if (!session) return;
+
+  let changed = false;
+  const topLevel = rewriteLastAssistant(session.messages, spokenPrefix);
+  if (topLevel !== session.messages) {
+    session.messages = topLevel;
+    changed = true;
+  }
+
+  const runs = session[DURABLE_RUNS_KEY];
+  if (runs && typeof runs === "object" && !Array.isArray(runs)) {
+    for (const persisted of Object.values(runs as Record<string, unknown>)) {
+      if (!persisted || typeof persisted !== "object") continue;
+      const runState = (persisted as { runState?: { messages?: KuralleMessageLike[] } }).runState;
+      if (!runState?.messages) continue;
+      const rewritten = rewriteLastAssistant(runState.messages, spokenPrefix);
+      if (rewritten !== runState.messages) {
+        runState.messages = rewritten;
+        changed = true;
+      }
+    }
+  }
+
+  if (changed) await store.save(session);
+}
+
+export function rewriteLastAssistant(
+  messages: ReadonlyArray<KuralleMessageLike>,
+  spokenPrefix: string,
+): KuralleMessageLike[] {
+  if (messages.length === 0) return [...messages];
+  const last = messages[messages.length - 1];
+  if (!last || last.role !== "assistant") return [...messages];
+  const full = assistantText(last);
+  if (spokenPrefix.length >= full.length) return [...messages];
+  return [...messages.slice(0, -1), { role: "assistant", content: spokenPrefix }];
+}
+
+function assistantText(message: KuralleMessageLike): string {
+  if (typeof message.content === "string") return message.content;
+  if (Array.isArray(message.content)) {
+    return message.content
+      .map((part) => {
+        if (typeof part === "string") return part;
+        if (part && typeof part === "object" && "text" in part) return String(part.text);
+        return "";
+      })
+      .join("");
+  }
+  return String(message.content ?? "");
+}
+
+function toErrorPart(error: unknown): ReasoningPart {
+  const cause = error instanceof Error ? error : new Error(String(error));
+  return { type: "error", cause, recoverable: isRecoverable(categorizeLlmError(cause)) };
+}
+
+function stringifyResult(r: unknown): string {
+  return typeof r === "string" ? r : JSON.stringify(r);
+}
+
+function toRecord(value: unknown): Record<string, unknown> {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
+  return value as Record<string, unknown>;
+}

package/src/index.ts

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+export {
+  fromKuralleRuntime,
+  streamFromKuralle,
+  runKuralleTurn,
+  awaitKuralleTurn,
+  buildKuralleTurnRunOptions,
+  reconcileSpokenPrefix,
+  rewriteLastAssistant,
+  type KuralleRuntimeLike,
+  type KuralleRunOptions,
+  type KuralleStreamPart,
+  type KuralleSessionStoreLike,
+  type KuralleStoredSession,
+  type KuralleMessageLike,
+  type FromKuralleRuntimeOptions,
+} from "./from-kuralle.js";

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "types": ["vitest/globals"],
+    "noEmit": true
+  },
+  "include": ["src/**/*.ts"]
+}