@lunora/agent 0.0.0 → 1.0.0-alpha.1

package/dist/packem_shared/normalizeEntityName-CyEEWFkR.mjs

@@ -0,0 +1,3 @@
+import '@lunora/server';
+import '@lunora/values';
+export { b as graphComponent, g as graphTables, n as normalizeEntityName } from './graph-component-aoUwO-f0.mjs';

package/dist/packem_shared/runAgentLoop-Dhg4ZNvw.mjs

@@ -0,0 +1,493 @@
+import { resolveAgentModel } from './createAgentGenerate-BQv9YJ01.mjs';
+import { f as firstGraphSource, m as memoryStepName, a as firstEpisodicSource, r as resolveInjectedSources } from './memory-D4FPcBsX.mjs';
+import { buildModelMessages } from './buildModelMessages-BWFigaoo.mjs';
+import { agentBindingName } from '../naming.mjs';
+import { toFunctionReference } from './AGENT_MODULE-Dnt_-AAT.mjs';
+
+const DEFAULT_MAX_TURNS = 8;
+const stringifyOutput = (output) => output === void 0 ? "null" : JSON.stringify(output);
+const normalizeStopWhen = (stopWhen) => {
+  if (stopWhen === void 0) {
+    return [];
+  }
+  if (Array.isArray(stopWhen)) {
+    return stopWhen;
+  }
+  return [stopWhen];
+};
+const isStopConditionMet = async (conditions, steps) => {
+  const results = await Promise.all(conditions.map(async (condition) => condition({ steps })));
+  return results.some(Boolean);
+};
+const sumTokens = (a, b) => a === void 0 && b === void 0 ? void 0 : (a ?? 0) + (b ?? 0);
+const addUsage = (base, next) => {
+  if (next === void 0) {
+    return base;
+  }
+  if (base === void 0) {
+    return { ...next };
+  }
+  const result = {};
+  const inputTokens = sumTokens(base.inputTokens, next.inputTokens);
+  const outputTokens = sumTokens(base.outputTokens, next.outputTokens);
+  const totalTokens = sumTokens(base.totalTokens, next.totalTokens);
+  if (inputTokens !== void 0) {
+    result.inputTokens = inputTokens;
+  }
+  if (outputTokens !== void 0) {
+    result.outputTokens = outputTokens;
+  }
+  if (totalTokens !== void 0) {
+    result.totalTokens = totalTokens;
+  }
+  return result;
+};
+const resolveNeedsApproval = async (tool, input, context) => {
+  const { needsApproval } = tool;
+  if (needsApproval === void 0 || needsApproval === false) {
+    return false;
+  }
+  if (needsApproval === true) {
+    return true;
+  }
+  return needsApproval(input, context);
+};
+const awaitApproval = async (turnContext, call) => {
+  const { instanceId, patchThread, persist, step } = turnContext;
+  await persist({
+    content: `Awaiting approval to run tool "${call.name}".`,
+    messageKey: `${instanceId}:approval:${call.id}`,
+    role: "tool",
+    status: "awaiting_approval",
+    toolCallId: call.id,
+    toolName: call.name
+  });
+  await patchThread({ status: "awaiting_input" });
+  const event = await step.waitForEvent(`approval:${call.id}`, { type: "agent-approval" });
+  await patchThread({ status: "running" });
+  return { decision: event.payload.decision, ...event.payload.note === void 0 ? {} : { note: event.payload.note } };
+};
+const runToolCall = async (turnContext, call) => {
+  const { env, getState, instanceId, onTokenDelta, persist, run, setState, step, threadKey, tools } = turnContext;
+  const stepName = `tool:${call.name}:${call.id}`;
+  const tool = tools[call.name];
+  const messageKey = `${instanceId}:tool:${call.id}`;
+  if (!tool) {
+    await persist({ content: `Error: unknown tool "${call.name}"`, messageKey, role: "tool", stepName, toolCallId: call.id, toolName: call.name });
+    return;
+  }
+  const reportProgress = (data) => {
+    onTokenDelta?.({ data, kind: "progress", threadKey, toolCallId: call.id });
+  };
+  const toolContext = { env, getState, idempotencyKey: stepName, reportProgress, run, setState, threadKey, toolCallId: call.id };
+  let status;
+  if (await resolveNeedsApproval(tool, call.input, toolContext)) {
+    const { decision, note } = await awaitApproval(turnContext, call);
+    if (decision === "reject") {
+      const reason = note === void 0 ? "" : ` Reason: ${note}`;
+      await persist({
+        content: `Tool "${call.name}" was rejected by the user and not run.${reason}`,
+        messageKey,
+        role: "tool",
+        status: "rejected",
+        stepName,
+        toolCallId: call.id,
+        toolName: call.name
+      });
+      return;
+    }
+    status = "approved";
+  }
+  const output = await step.do(stepName, () => Promise.resolve(tool.execute(call.input, toolContext)));
+  await persist({
+    content: typeof output === "string" ? output : stringifyOutput(output),
+    messageKey,
+    role: "tool",
+    stepName,
+    ...status === void 0 ? {} : { status },
+    toolCallId: call.id,
+    toolName: call.name
+  });
+};
+const applyPrepareStepResult = (base, overrides, env) => {
+  if (!overrides) {
+    return base;
+  }
+  let { messages } = base;
+  if (overrides.messages !== void 0) {
+    messages = overrides.messages;
+  }
+  if (overrides.system !== void 0) {
+    messages = [{ content: overrides.system, role: "system" }, ...messages];
+  }
+  return {
+    activeTools: overrides.activeTools ?? base.activeTools,
+    messages,
+    model: overrides.model === void 0 ? base.model : resolveAgentModel(overrides.model, env),
+    toolChoice: overrides.toolChoice ?? base.toolChoice
+  };
+};
+const splitForCompaction = (history, compaction) => {
+  if (compaction === void 0 || history.length <= compaction.maxMessages) {
+    return void 0;
+  }
+  const keepRecent = Math.max(1, compaction.keepRecent ?? Math.ceil(compaction.maxMessages / 2));
+  if (history.length <= keepRecent) {
+    return void 0;
+  }
+  let cut = history.length - keepRecent;
+  while (cut > 0 && history[cut]?.role === "tool") {
+    cut -= 1;
+  }
+  if (cut <= 0) {
+    return void 0;
+  }
+  return { older: history.slice(0, cut), recent: history.slice(cut) };
+};
+const compactHistory = async (turnContext, history) => {
+  const { agent, compact, env } = turnContext;
+  const split = splitForCompaction(history, agent.compaction);
+  if (split === void 0 || compact === void 0) {
+    return { history, summary: void 0 };
+  }
+  try {
+    const summary = await compact({ env, messages: buildModelMessages({ history: split.older }), model: agent.compaction?.model ?? agent.model });
+    return summary.length > 0 ? { history: split.recent, summary } : { history, summary: void 0 };
+  } catch {
+    return { history, summary: void 0 };
+  }
+};
+const generateTurn = async (turnContext, turn, steps) => {
+  const { agent, env, generate, instructions, listMessages, memoryContext, onTokenDelta, run, step, streamGenerate, threadKey } = turnContext;
+  return step.do(`llm:turn:${String(turn)}`, async () => {
+    const rawHistory = await run(listMessages, { key: threadKey });
+    const { history, summary } = await compactHistory(turnContext, rawHistory);
+    let prepared = {
+      activeTools: agent.activeTools,
+      messages: buildModelMessages({ history, instructions, memoryContext, summary }),
+      model: void 0,
+      toolChoice: agent.toolChoice
+    };
+    if (agent.prepareStep) {
+      prepared = applyPrepareStepResult(prepared, await agent.prepareStep({ messages: prepared.messages, stepNumber: turn, steps }), env);
+    }
+    const request = {
+      messages: prepared.messages,
+      ...prepared.activeTools === void 0 ? {} : { activeTools: prepared.activeTools },
+      ...prepared.model === void 0 ? {} : { model: prepared.model },
+      ...prepared.toolChoice === void 0 ? {} : { toolChoice: prepared.toolChoice }
+    };
+    if (streamGenerate && onTokenDelta) {
+      return streamGenerate(request, (text) => {
+        onTokenDelta({ text, threadKey, turn });
+      });
+    }
+    return generate(request);
+  });
+};
+const notifyStepFinish = async (turnContext, info) => {
+  const { agent, step } = turnContext;
+  if (!agent.onStepFinish) {
+    return;
+  }
+  await step.do(`agent:step-finish:${String(info.turn)}`, async () => {
+    await agent.onStepFinish?.(info);
+    return true;
+  });
+};
+const toStepInfo = (decision) => {
+  return {
+    text: decision.text,
+    toolCalls: decision.toolCalls.map((call) => {
+      return { input: call.input, toolCallId: call.id, toolName: call.name };
+    }),
+    ...decision.usage === void 0 ? {} : { usage: decision.usage }
+  };
+};
+const readRetrievedContext = (retrieved) => {
+  const context = retrieved?.context;
+  return typeof context === "string" && context.length > 0 ? context : void 0;
+};
+const graphTraverseBounds = (graph) => {
+  const bounds = {};
+  if (graph?.depth !== void 0) {
+    bounds.depth = graph.depth;
+  }
+  if (graph?.fanOut !== void 0) {
+    bounds.fanOut = graph.fanOut;
+  }
+  if (graph?.maxNodes !== void 0) {
+    bounds.maxNodes = graph.maxNodes;
+  }
+  if (graph?.maxSeeds !== void 0) {
+    bounds.maxSeeds = graph.maxSeeds;
+  }
+  return bounds;
+};
+const dispatchSemanticMemory = async (source, input, step, run) => {
+  if (source.source === void 0) {
+    return void 0;
+  }
+  const memorySource = toFunctionReference(source.source);
+  const { topK } = source;
+  const stepName = memoryStepName("memory:retrieve", source.key);
+  const retrieved = await step.do(stepName, async () => run(memorySource, { query: input, ...topK === void 0 ? {} : { topK } }));
+  return readRetrievedContext(retrieved);
+};
+const dispatchGraphMemory = async (source, input, owner, graphTraverse, step, run) => {
+  if (owner === void 0) {
+    return void 0;
+  }
+  const stepName = memoryStepName("memory:traverse", source.key);
+  const retrieved = await step.do(stepName, async () => run(graphTraverse, { owner, query: input, ...graphTraverseBounds(source.graph) }));
+  return readRetrievedContext(retrieved);
+};
+const dispatchEpisodicMemory = async (source, owner, episodeRecall, step, run) => {
+  if (owner === void 0) {
+    return void 0;
+  }
+  const stepName = memoryStepName("memory:recall", source.key);
+  const recallArgs = { owner, ...source.episodic?.recall === void 0 ? {} : { limit: source.episodic.recall } };
+  const retrieved = await step.do(stepName, async () => run(episodeRecall, recallArgs));
+  return readRetrievedContext(retrieved);
+};
+const dispatchInjectedSource = async (source, deps) => {
+  if (source.kind === "episodic") {
+    return dispatchEpisodicMemory(source, deps.owner, deps.episodeRecall, deps.step, deps.run);
+  }
+  if (source.kind === "graph") {
+    return dispatchGraphMemory(source, deps.input, deps.owner, deps.graphTraverse, deps.step, deps.run);
+  }
+  return dispatchSemanticMemory(source, deps.input, deps.step, deps.run);
+};
+const dedupeEpisodicSources = (sources) => {
+  let seenEpisodic = false;
+  return sources.filter((source) => {
+    if (source.kind !== "episodic") {
+      return true;
+    }
+    if (seenEpisodic) {
+      return false;
+    }
+    seenEpisodic = true;
+    return true;
+  });
+};
+const retrieveMemoryContext = async (agent, input, owner, paths, step, run) => {
+  const sources = dedupeEpisodicSources(resolveInjectedSources(agent));
+  if (sources.length === 0) {
+    return void 0;
+  }
+  const graphTraverse = toFunctionReference(paths.graphTraverse);
+  const episodeRecall = toFunctionReference(paths.episodeRecall);
+  const contexts = [];
+  for (const source of sources) {
+    const context = await dispatchInjectedSource(source, { episodeRecall, graphTraverse, input, owner, run, step });
+    if (context !== void 0) {
+      contexts.push(context);
+    }
+  }
+  return contexts.length > 0 ? contexts.join("\n\n") : void 0;
+};
+const extractGraphMemoryAtRunEnd = async (options) => {
+  const { agent, env, extractGraph, finalText, input, instanceId, owner, paths, run, step } = options;
+  if (extractGraph === void 0 || owner === void 0 || finalText === void 0 || finalText.length === 0) {
+    return;
+  }
+  const source = firstGraphSource(agent);
+  if (source === void 0) {
+    return;
+  }
+  try {
+    const graphInput = { assistantText: finalText, env, model: source.graph?.extractionModel ?? agent.model, userInput: input };
+    const extracted = await step.do(memoryStepName("memory:extract", source.key), async () => extractGraph(graphInput));
+    await run(toFunctionReference(paths.graphUpsert), { ...extracted, messageKey: `${instanceId}:${memoryStepName("extract", source.key)}`, owner });
+  } catch {
+  }
+};
+const extractEpisodeAtRunEnd = async (options) => {
+  const { agent, env, extractEpisode, finalText, input, instanceId, owner, paths, run, step, threadKey } = options;
+  if (extractEpisode === void 0 || owner === void 0 || finalText === void 0 || finalText.length === 0) {
+    return;
+  }
+  const source = firstEpisodicSource(agent);
+  if (source === void 0) {
+    return;
+  }
+  try {
+    const episodeInput = { assistantText: finalText, env, model: source.episodic?.extractionModel ?? agent.model, userInput: input };
+    const { summary } = await step.do(memoryStepName("memory:episode", source.key), async () => extractEpisode(episodeInput));
+    await run(toFunctionReference(paths.episodeUpsert), {
+      messageKey: `${instanceId}:${memoryStepName("episode", source.key)}`,
+      owner,
+      summary,
+      threadKey
+    });
+  } catch {
+  }
+};
+const terminatePriorInstance = async (env, exportName, priorInstanceId) => {
+  const binding = env[agentBindingName(exportName)];
+  if (!binding || typeof binding.get !== "function") {
+    return;
+  }
+  try {
+    const instance = await binding.get(priorInstanceId);
+    await instance.terminate();
+  } catch {
+  }
+};
+const handleTurn = async (turnContext, turn, decision, steps, stopConditions) => {
+  const { instanceId, persist } = turnContext;
+  const stepUsage = decision.usage === void 0 ? {} : { usage: decision.usage };
+  if (decision.toolCalls.length === 0) {
+    const content = decision.output !== void 0 && decision.text.length === 0 ? stringifyOutput(decision.output) : decision.text;
+    await persist({ content, messageKey: `${instanceId}:assistant:${String(turn)}`, role: "assistant" });
+    await notifyStepFinish(turnContext, { text: decision.text, toolCalls: [], turn, ...stepUsage });
+    return {
+      final: {
+        stopped: "final",
+        text: decision.text,
+        turns: turn + 1,
+        ...decision.output === void 0 ? {} : { output: decision.output }
+      }
+    };
+  }
+  await persist({ content: decision.text, messageKey: `${instanceId}:assistant:${String(turn)}`, role: "assistant", toolCalls: decision.toolCalls });
+  for (const call of decision.toolCalls) {
+    await runToolCall(turnContext, call);
+  }
+  await notifyStepFinish(turnContext, { text: decision.text, toolCalls: decision.toolCalls, turn, ...stepUsage });
+  steps.push(toStepInfo(decision));
+  if (stopConditions.length > 0 && await isStopConditionMet(stopConditions, steps)) {
+    return "stopCondition";
+  }
+  return void 0;
+};
+const runTurns = async (turnContext, maxTurns, stopConditions, usageBox) => {
+  const steps = [];
+  let final;
+  let stoppedByCondition = false;
+  let turnsRun = 0;
+  for (let turn = 0; turn < maxTurns; turn += 1) {
+    const decision = await generateTurn(turnContext, turn, steps);
+    usageBox.value = addUsage(usageBox.value, decision.usage);
+    turnsRun = turn + 1;
+    const outcome = await handleTurn(turnContext, turn, decision, steps, stopConditions);
+    if (outcome === "stopCondition") {
+      stoppedByCondition = true;
+      break;
+    }
+    if (outcome !== void 0) {
+      final = outcome.final;
+      break;
+    }
+  }
+  return { final, stoppedByCondition, turnsRun };
+};
+const runAgentLoop = async (options) => {
+  const { agent, compact, env, exportName, extractEpisode, extractGraph, generate, instanceId, onTokenDelta, params, paths, run, step, streamGenerate } = options;
+  const maxTurns = agent.maxTurns ?? DEFAULT_MAX_TURNS;
+  const stopConditions = normalizeStopWhen(agent.stopWhen);
+  const appendMessage = toFunctionReference(paths.appendMessage);
+  const ensureThread = toFunctionReference(paths.ensureThread);
+  const listMessages = toFunctionReference(paths.listMessages);
+  const patchThread = toFunctionReference(paths.patchThread);
+  const setStateRef = toFunctionReference(paths.setState);
+  const stateRef = toFunctionReference(paths.state);
+  const persist = async (message) => {
+    await run(appendMessage, { threadKey: params.threadKey, ...message });
+  };
+  const patchThreadByKey = async (patch) => {
+    await run(patchThread, { key: params.threadKey, ...patch });
+  };
+  const getState = async () => await run(stateRef, { key: params.threadKey });
+  const setState = async (state) => {
+    await run(setStateRef, { key: params.threadKey, state });
+  };
+  const bootstrap = await run(ensureThread, {
+    agent: exportName,
+    instanceId,
+    key: params.threadKey,
+    ...agent.initialState === void 0 ? {} : { initialState: agent.initialState },
+    ...agent.onConcurrentRun === void 0 ? {} : { onConcurrentRun: agent.onConcurrentRun },
+    ...params.owner === void 0 ? {} : { owner: params.owner },
+    ...params.title === void 0 ? {} : { title: params.title }
+  });
+  if (bootstrap?.replaced && bootstrap.priorInstanceId !== void 0) {
+    await terminatePriorInstance(env, exportName, bootstrap.priorInstanceId);
+  }
+  await persist({ content: params.input, messageKey: `${instanceId}:user`, role: "user" });
+  const memoryContext = await retrieveMemoryContext(agent, params.input, params.owner, paths, step, run);
+  const instructions = typeof agent.instructions === "function" ? agent.instructions({ env, input: params.input, threadKey: params.threadKey }) : agent.instructions;
+  const turnContext = {
+    agent,
+    compact,
+    env,
+    generate,
+    getState,
+    instanceId,
+    instructions,
+    listMessages,
+    memoryContext,
+    onTokenDelta,
+    patchThread: patchThreadByKey,
+    persist,
+    run,
+    setState,
+    step,
+    streamGenerate,
+    threadKey: params.threadKey,
+    tools: agent.tools ?? {}
+  };
+  const usageBox = { value: void 0 };
+  try {
+    const { final, stoppedByCondition, turnsRun } = await runTurns(turnContext, maxTurns, stopConditions, usageBox);
+    const usagePatch = usageBox.value === void 0 ? {} : { usage: usageBox.value };
+    await extractGraphMemoryAtRunEnd({
+      agent,
+      env,
+      extractGraph,
+      finalText: final?.text,
+      input: params.input,
+      instanceId,
+      owner: params.owner,
+      paths,
+      run,
+      step
+    });
+    await extractEpisodeAtRunEnd({
+      agent,
+      env,
+      extractEpisode,
+      finalText: final?.text,
+      input: params.input,
+      instanceId,
+      owner: params.owner,
+      paths,
+      run,
+      step,
+      threadKey: params.threadKey
+    });
+    if (final) {
+      await run(patchThread, { key: params.threadKey, status: "idle", ...usagePatch });
+      return { ...final, ...usagePatch };
+    }
+    if (stoppedByCondition) {
+      await run(patchThread, { key: params.threadKey, status: "idle", ...usagePatch });
+      return { stopped: "stopCondition", turns: turnsRun, ...usagePatch };
+    }
+    await run(patchThread, { error: `agent stopped: maxTurns (${String(maxTurns)}) reached`, key: params.threadKey, status: "error", ...usagePatch });
+    return { stopped: "maxTurns", turns: maxTurns, ...usagePatch };
+  } catch (error) {
+    await run(patchThread, {
+      error: error instanceof Error ? error.message : String(error),
+      key: params.threadKey,
+      status: "error",
+      ...usageBox.value === void 0 ? {} : { usage: usageBox.value }
+    });
+    throw error;
+  }
+};
+
+export { runAgentLoop, splitForCompaction };

package/dist/packem_shared/runVoiceTurn-LnqLvCRR.mjs

@@ -0,0 +1,211 @@
+import { f as fromBase64 } from './base64-BVwtgRJV.mjs';
+import { buildModelMessages } from './buildModelMessages-BWFigaoo.mjs';
+import { toFunctionReference } from './AGENT_MODULE-Dnt_-AAT.mjs';
+
+const PCM_SAMPLE_RATE = 16e3;
+const PCM_CHANNELS = 1;
+const PCM_BITS_PER_SAMPLE = 16;
+const SENTENCE_BOUNDARY = /[^.!?]*[.!?]+\s+/u;
+const toByteIterable = async function* (source) {
+  if (source instanceof Uint8Array) {
+    yield source;
+    return;
+  }
+  if (source instanceof ReadableStream) {
+    const reader = source.getReader();
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        yield value;
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    return;
+  }
+  yield* source;
+};
+const pcmToWav = (pcm, sampleRate = PCM_SAMPLE_RATE, channels = PCM_CHANNELS, bitsPerSample = PCM_BITS_PER_SAMPLE) => {
+  const blockAlign = channels * bitsPerSample / 8;
+  const byteRate = sampleRate * blockAlign;
+  const buffer = new ArrayBuffer(44 + pcm.byteLength);
+  const view = new DataView(buffer);
+  const writeAscii = (offset, text) => {
+    for (let index = 0; index < text.length; index += 1) {
+      view.setUint8(offset + index, text.codePointAt(index) ?? 0);
+    }
+  };
+  writeAscii(0, "RIFF");
+  view.setUint32(4, 36 + pcm.byteLength, true);
+  writeAscii(8, "WAVE");
+  writeAscii(12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, channels, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, byteRate, true);
+  view.setUint16(32, blockAlign, true);
+  view.setUint16(34, bitsPerSample, true);
+  writeAscii(36, "data");
+  view.setUint32(40, pcm.byteLength, true);
+  const out = new Uint8Array(buffer);
+  out.set(pcm, 44);
+  return out;
+};
+const takeSentences = (buffer) => {
+  const sentences = [];
+  let rest = buffer;
+  let match = SENTENCE_BOUNDARY.exec(rest);
+  while (match && match[0].length > 0) {
+    const consumed = match[0];
+    const sentence = consumed.trim();
+    if (sentence.length > 0) {
+      sentences.push(sentence);
+    }
+    rest = rest.slice(consumed.length);
+    match = SENTENCE_BOUNDARY.exec(rest);
+  }
+  return { rest, sentences };
+};
+const runVoiceTurn = async (options) => {
+  const {
+    agent,
+    connectionId,
+    env,
+    exportName,
+    owner,
+    paths,
+    pcm,
+    run,
+    send,
+    sendAudio,
+    signal,
+    streamGenerate,
+    synthesize,
+    text,
+    threadKey,
+    transcribe,
+    turn,
+    waitForDrain
+  } = options;
+  const isAborted = () => signal.aborted;
+  const appendMessage = toFunctionReference(paths.appendMessage);
+  const ensureThread = toFunctionReference(paths.ensureThread);
+  const listMessages = toFunctionReference(paths.listMessages);
+  const patchThread = toFunctionReference(paths.patchThread);
+  const userText = (text ?? (pcm ? await transcribe(pcm) : "")).trim();
+  if (userText.length === 0) {
+    return { assistantText: "", interrupted: false, userText: "" };
+  }
+  send({ text: userText, type: "user_transcript" });
+  await run(ensureThread, {
+    agent: exportName,
+    key: threadKey,
+    ...agent.initialState === void 0 ? {} : { initialState: agent.initialState },
+    ...owner === void 0 ? {} : { owner }
+  });
+  await run(appendMessage, { content: userText, messageKey: `voice:${connectionId}:${String(turn)}:user`, role: "user", threadKey });
+  await run(patchThread, { key: threadKey, status: "running" });
+  const instructions = typeof agent.instructions === "function" ? agent.instructions({ env, input: userText, threadKey }) : agent.instructions;
+  const history = await run(listMessages, { key: threadKey });
+  const messages = buildModelMessages({ history, ...instructions === void 0 ? {} : { instructions } });
+  let pending = "";
+  let spoken = "";
+  let ttsChain = Promise.resolve();
+  const speak = async (sentence) => {
+    if (isAborted() || sentence.length === 0) {
+      return;
+    }
+    let flushed = false;
+    try {
+      for await (const chunk of toByteIterable(await synthesize(sentence, signal))) {
+        if (isAborted()) {
+          break;
+        }
+        await waitForDrain?.();
+        if (isAborted()) {
+          break;
+        }
+        sendAudio(chunk);
+        flushed = true;
+      }
+    } catch (error) {
+      send({ message: error instanceof Error ? error.message : String(error), type: "error" });
+    }
+    if (flushed) {
+      spoken = spoken.length > 0 ? `${spoken} ${sentence}` : sentence;
+    }
+  };
+  const enqueueSpeak = (sentence) => {
+    ttsChain = ttsChain.then(async () => speak(sentence));
+  };
+  try {
+    const result = await streamGenerate({ messages, signal }, (delta) => {
+      if (isAborted()) {
+        return;
+      }
+      send({ text: delta, type: "assistant_delta" });
+      pending += delta;
+      const { rest, sentences } = takeSentences(pending);
+      pending = rest;
+      for (const sentence of sentences) {
+        enqueueSpeak(sentence);
+      }
+    });
+    if (!isAborted() && pending.trim().length > 0) {
+      enqueueSpeak(pending.trim());
+    }
+    pending = "";
+    await ttsChain;
+    const interrupted = isAborted();
+    const assistantText = interrupted ? spoken : result.text;
+    await run(appendMessage, { content: assistantText, messageKey: `voice:${connectionId}:${String(turn)}:assistant`, role: "assistant", threadKey });
+    await run(patchThread, { key: threadKey, status: "idle" });
+    send(interrupted ? { type: "interrupted" } : { text: assistantText, type: "assistant_done" });
+    return { assistantText, interrupted, userText };
+  } catch (error) {
+    await run(patchThread, { key: threadKey, status: "idle" });
+    throw error;
+  }
+};
+const parseIdentity = (raw) => {
+  if (!raw) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+};
+const readTranscriptionText = (result) => {
+  if (typeof result === "object" && result !== null && "text" in result) {
+    const { text } = result;
+    return typeof text === "string" ? text : "";
+  }
+  return "";
+};
+const readSynthesisAudio = (result) => {
+  if (result instanceof Uint8Array || result instanceof ReadableStream) {
+    return result;
+  }
+  if (result instanceof Response && result.body) {
+    return result.body;
+  }
+  if (typeof result === "object" && result !== null && "audio" in result) {
+    const { audio } = result;
+    if (typeof audio === "string") {
+      return fromBase64(audio);
+    }
+    if (audio instanceof ReadableStream || audio instanceof Uint8Array) {
+      return audio;
+    }
+  }
+  return new Uint8Array(0);
+};
+
+export { parseIdentity, pcmToWav, readSynthesisAudio, readTranscriptionText, runVoiceTurn, toByteIterable };