@lunora/agent 0.0.0 → 1.0.0-alpha.1

package/dist/index.mjs

@@ -0,0 +1,18 @@
+export { runAgentLoop, splitForCompaction } from './packem_shared/runAgentLoop-Dhg4ZNvw.mjs';
+export { collectAgenticMemoryTools, toSearchResults } from './packem_shared/collectAgenticMemoryTools-QrzpV-WX.mjs';
+export { agentAsTool } from './packem_shared/agentAsTool-Dt8NlU6k.mjs';
+export { codeTool } from './packem_shared/codeTool-CjgJOC9t.mjs';
+export { agentComponent, agentExtension } from './component.mjs';
+export { default as createAgentContext } from './packem_shared/createAgentContext-4xJGXNR4.mjs';
+export { defineAgent, defineAgentTool, isAgentDefinition } from './packem_shared/defineAgent-D6maSbVc.mjs';
+export { functionTool } from './packem_shared/functionTool-D6lCa2jB.mjs';
+export { createAgentGenerate, createEpisodeExtract, createGraphExtract, createStreamGenerate, resolveAgentModel } from './packem_shared/createAgentGenerate-BQv9YJ01.mjs';
+export { adaptMcpResult, mcpTools } from './packem_shared/adaptMcpResult-wtNMvLoP.mjs';
+export { buildModelMessages } from './packem_shared/buildModelMessages-BWFigaoo.mjs';
+export { agentBindingName, agentClassName, agentDefaultName, voiceBindingName, voiceClassName } from './naming.mjs';
+export { AGENT_MODULE, DEFAULT_AGENT_FUNCTION_PATHS, SANDBOX_INVOKE_PATH, SANDBOX_MODULE, toFunctionReference } from './packem_shared/AGENT_MODULE-Dnt_-AAT.mjs';
+export { browserTool, containerTool, fsTool } from './sandbox.mjs';
+export { defineSkill, isSkillDefinition } from './packem_shared/defineSkill-Ctf_S-rz.mjs';
+export { default as VoiceSessionDO } from './packem_shared/VoiceSessionDO-DLoXsHGF.mjs';
+export { runVoiceTurn } from './packem_shared/runVoiceTurn-LnqLvCRR.mjs';
+export { default as compileAgentWorkflow } from './packem_shared/compileAgentWorkflow-BxJjHgtD.mjs';

package/dist/naming.d.mts

@@ -0,0 +1,17 @@
+/** `support` → `SupportAgentWorkflow` — the generated WorkflowEntrypoint class name. */
+declare const agentClassName: (exportName: string) => string;
+/** `support` → `AGENT_SUPPORT` — the Cloudflare Workflows binding name. */
+declare const agentBindingName: (exportName: string) => string;
+/** `supportBot` → `agent-support-bot` — the default deployed workflow name. */
+declare const agentDefaultName: (exportName: string) => string;
+/**
+* `support` → `SupportVoiceDO` — the generated voice-session Durable Object
+* class name (a subclass of `VoiceSessionDO`). Distinct from the agent's
+* `WorkflowEntrypoint` (`SupportAgentWorkflow`): the voice path is a
+* hibernatable-WebSocket DO that runs the per-turn STT→LLM→TTS pipeline in-DO,
+* NOT the replay-durable Workflow.
+*/
+declare const voiceClassName: (exportName: string) => string;
+/** `support` → `VOICE_SUPPORT` — the Cloudflare Durable Object binding name for the voice session. */
+declare const voiceBindingName: (exportName: string) => string;
+export { agentBindingName, agentClassName, agentDefaultName, voiceBindingName, voiceClassName };

package/dist/naming.d.ts

@@ -0,0 +1,17 @@
+/** `support` → `SupportAgentWorkflow` — the generated WorkflowEntrypoint class name. */
+declare const agentClassName: (exportName: string) => string;
+/** `support` → `AGENT_SUPPORT` — the Cloudflare Workflows binding name. */
+declare const agentBindingName: (exportName: string) => string;
+/** `supportBot` → `agent-support-bot` — the default deployed workflow name. */
+declare const agentDefaultName: (exportName: string) => string;
+/**
+* `support` → `SupportVoiceDO` — the generated voice-session Durable Object
+* class name (a subclass of `VoiceSessionDO`). Distinct from the agent's
+* `WorkflowEntrypoint` (`SupportAgentWorkflow`): the voice path is a
+* hibernatable-WebSocket DO that runs the per-turn STT→LLM→TTS pipeline in-DO,
+* NOT the replay-durable Workflow.
+*/
+declare const voiceClassName: (exportName: string) => string;
+/** `support` → `VOICE_SUPPORT` — the Cloudflare Durable Object binding name for the voice session. */
+declare const voiceBindingName: (exportName: string) => string;
+export { agentBindingName, agentClassName, agentDefaultName, voiceBindingName, voiceClassName };

package/dist/naming.mjs

@@ -0,0 +1,8 @@
+const CAMEL_BOUNDARY = /([a-z0-9])([A-Z])/gu;
+const agentClassName = (exportName) => `${exportName.charAt(0).toUpperCase()}${exportName.slice(1)}AgentWorkflow`;
+const agentBindingName = (exportName) => `AGENT_${exportName.replaceAll(CAMEL_BOUNDARY, "$1_$2").toUpperCase()}`;
+const agentDefaultName = (exportName) => `agent-${exportName.replaceAll(CAMEL_BOUNDARY, "$1-$2").toLowerCase()}`;
+const voiceClassName = (exportName) => `${exportName.charAt(0).toUpperCase()}${exportName.slice(1)}VoiceDO`;
+const voiceBindingName = (exportName) => `VOICE_${exportName.replaceAll(CAMEL_BOUNDARY, "$1_$2").toUpperCase()}`;
+
+export { agentBindingName, agentClassName, agentDefaultName, voiceBindingName, voiceClassName };

package/dist/packem_shared/AGENT_MODULE-Dnt_-AAT.mjs

@@ -0,0 +1,24 @@
+const AGENT_MODULE = "agents";
+const SANDBOX_MODULE = "sandbox";
+const SANDBOX_INVOKE_PATH = `${SANDBOX_MODULE}:invoke`;
+const DEFAULT_AGENT_FUNCTION_PATHS = {
+  appendMessage: `${AGENT_MODULE}:agentAppendMessage`,
+  ensureThread: `${AGENT_MODULE}:agentEnsureThread`,
+  episodeRecall: `${AGENT_MODULE}:agentEpisodeRecall`,
+  episodeUpsert: `${AGENT_MODULE}:agentEpisodeUpsert`,
+  graphTraverse: `${AGENT_MODULE}:agentGraphTraverse`,
+  graphUpsert: `${AGENT_MODULE}:agentGraphUpsert`,
+  listMessages: `${AGENT_MODULE}:agentMessages`,
+  patchThread: `${AGENT_MODULE}:agentPatchThread`,
+  run: `${AGENT_MODULE}:agentRun`,
+  setState: `${AGENT_MODULE}:agentSetState`,
+  state: `${AGENT_MODULE}:agentState`
+};
+const toFunctionReference = (source) => {
+  if (typeof source === "string") {
+    return { __lunoraRef: source };
+  }
+  return source;
+};
+
+export { AGENT_MODULE, DEFAULT_AGENT_FUNCTION_PATHS, SANDBOX_INVOKE_PATH, SANDBOX_MODULE, toFunctionReference };

package/dist/packem_shared/VoiceSessionDO-DLoXsHGF.mjs

@@ -0,0 +1,297 @@
+import { createAi } from '@lunora/ai';
+import { c as createDispatchRunner } from './createDispatchRunner-DSbp_dph-ZHTtxy3f.mjs';
+import { t as toBase64 } from './base64-BVwtgRJV.mjs';
+import { createStreamGenerate } from './createAgentGenerate-BQv9YJ01.mjs';
+import { DEFAULT_AGENT_FUNCTION_PATHS, toFunctionReference } from './AGENT_MODULE-Dnt_-AAT.mjs';
+import { parseIdentity, pcmToWav, readTranscriptionText, readSynthesisAudio, runVoiceTurn, toByteIterable } from './runVoiceTurn-LnqLvCRR.mjs';
+
+const DEFAULT_STT_MODEL = "@cf/openai/whisper-large-v3-turbo";
+const DEFAULT_TTS_MODEL = "@cf/deepgram/aura-1";
+const MAX_UTTERANCE_BYTES = 8 * 1024 * 1024;
+const MAX_SOCKET_BUFFER_BYTES = 256 * 1024;
+const DRAIN_POLL_MS = 15;
+const MAX_DRAIN_WAIT_MS = 5e3;
+class VoiceSessionDO {
+  agent;
+  ai;
+  env;
+  exportName;
+  paths;
+  streamGenerate;
+  sttModel;
+  ttsModel;
+  audioBuffers = /* @__PURE__ */ new Map();
+  bufferedBytes = /* @__PURE__ */ new Map();
+  controllers = /* @__PURE__ */ new Map();
+  state;
+  constructor(state, env, agent, exportName) {
+    this.state = state;
+    this.env = env;
+    this.agent = agent;
+    this.exportName = exportName;
+    this.paths = DEFAULT_AGENT_FUNCTION_PATHS;
+    this.ai = createAi({ binding: env["AI"] });
+    this.streamGenerate = createStreamGenerate(agent, env);
+    this.sttModel = agent.voice?.stt ?? DEFAULT_STT_MODEL;
+    this.ttsModel = agent.voice?.tts ?? DEFAULT_TTS_MODEL;
+  }
+  /** HTTP entry — only a WebSocket upgrade carrying a `threadKey` is accepted. */
+  fetch(request) {
+    if (request.headers.get("Upgrade") !== "websocket") {
+      return new Response("Expected a WebSocket upgrade", { status: 426 });
+    }
+    const url = new URL(request.url);
+    const threadKey = url.searchParams.get("threadKey");
+    if (!threadKey) {
+      return new Response("Missing threadKey", { status: 400 });
+    }
+    const WebSocketPairConstructor = globalThis.WebSocketPair;
+    const pair = new WebSocketPairConstructor();
+    const client = pair[0];
+    const server = pair[1];
+    this.state.acceptWebSocket(server);
+    const connectionId = crypto.randomUUID();
+    const identity = parseIdentity(request.headers.get("x-lunora-identity"));
+    const userId = request.headers.get("x-lunora-userid") ?? void 0;
+    server.serializeAttachment?.({
+      connectionId,
+      threadKey,
+      turn: 0,
+      ...identity === void 0 ? {} : { identity },
+      ...userId === void 0 ? {} : { userId }
+    });
+    this.send(server, { audioFormat: this.agent.voice?.audioFormat ?? "mp3", type: "ready" });
+    const greeting = this.agent.voice?.greeting;
+    if (greeting && greeting.length > 0) {
+      this.state.waitUntil?.(this.speakGreeting(server, connectionId, threadKey, userId, identity, greeting));
+    }
+    return new Response(null, { status: 101, webSocket: client });
+  }
+  /** Hibernation message handler — never throws (a thrown handler is fatal to the socket). */
+  async webSocketMessage(ws, message) {
+    const attachment = ws.deserializeAttachment?.();
+    if (!attachment) {
+      return;
+    }
+    try {
+      if (typeof message === "string") {
+        await this.handleControl(ws, attachment, message);
+        return;
+      }
+      this.bufferAudio(attachment.connectionId, new Uint8Array(message), ws);
+    } catch (error) {
+      this.send(ws, { message: error instanceof Error ? error.message : String(error), type: "error" });
+    }
+  }
+  /** Abort any in-flight turn + free the socket's buffers on close. Never throws. */
+  webSocketClose(ws) {
+    this.cleanupSocket(ws);
+  }
+  /** Abort any in-flight turn + free the socket's buffers on error. Never throws. */
+  webSocketError(ws) {
+    this.cleanupSocket(ws);
+  }
+  /**
+   * The runtime dispatch seam reaching the shared agent thread functions. When
+   * the socket carries a verified identity it is forwarded so the `agents:*`
+   * thread writes are attributed to the caller (RLS / row ownership) rather
+   * than the anonymous system dispatch.
+   */
+  resolveRun(userId, claims) {
+    const identity = userId === void 0 && claims === void 0 ? void 0 : { ...claims === void 0 ? {} : { claims }, ...userId === void 0 ? {} : { userId } };
+    return createDispatchRunner({ env: this.env, label: "@lunora/agent voice", ...identity === void 0 ? {} : { identity } });
+  }
+  /** Production STT seam: WAV-wrap the utterance and run the batch transcription model. */
+  async transcribe(pcm) {
+    const wav = pcmToWav(pcm);
+    return readTranscriptionText(await this.ai.run(this.sttModel, { audio: toBase64(wav) }));
+  }
+  /** Production TTS seam: synthesize one sentence to a normalized audio source; `signal` aborts an in-flight barge-in. */
+  async synthesize(text, signal) {
+    const speaker = this.agent.voice?.speaker;
+    return readSynthesisAudio(
+      await this.ai.run(this.ttsModel, { text, ...speaker === void 0 ? {} : { speaker } }, signal === void 0 ? void 0 : { signal })
+    );
+  }
+  /** Route a JSON control frame (`commit` / `interrupt` / `text`). */
+  async handleControl(ws, attachment, raw) {
+    let frame;
+    try {
+      frame = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (frame.type === "interrupt") {
+      this.controllers.get(attachment.connectionId)?.abort();
+      return;
+    }
+    if (this.controllers.has(attachment.connectionId)) {
+      this.send(ws, { message: "a turn is already in progress — send an interrupt before the next utterance", type: "error" });
+      return;
+    }
+    if (frame.type === "commit") {
+      const pcm = this.drainAudio(attachment.connectionId);
+      await this.runTurn(ws, attachment, { pcm });
+      return;
+    }
+    await this.runTurn(ws, attachment, { text: frame.text });
+  }
+  /** Append a binary audio frame to the socket's utterance buffer (bounded). */
+  bufferAudio(connectionId, chunk, ws) {
+    const total = (this.bufferedBytes.get(connectionId) ?? 0) + chunk.byteLength;
+    if (total > MAX_UTTERANCE_BYTES) {
+      this.audioBuffers.delete(connectionId);
+      this.bufferedBytes.delete(connectionId);
+      this.send(ws, { message: "utterance exceeded the maximum buffer — send a commit sooner", type: "error" });
+      return;
+    }
+    const chunks = this.audioBuffers.get(connectionId) ?? [];
+    chunks.push(chunk);
+    this.audioBuffers.set(connectionId, chunks);
+    this.bufferedBytes.set(connectionId, total);
+  }
+  /** Concatenate + clear the socket's buffered utterance. */
+  drainAudio(connectionId) {
+    const chunks = this.audioBuffers.get(connectionId) ?? [];
+    this.audioBuffers.delete(connectionId);
+    this.bufferedBytes.delete(connectionId);
+    const total = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+    const pcm = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      pcm.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return pcm;
+  }
+  /** Execute a turn under a fresh abort controller, advancing the socket's turn index. */
+  async runTurn(ws, attachment, input) {
+    const controller = new AbortController();
+    this.controllers.set(attachment.connectionId, controller);
+    try {
+      await runVoiceTurn({
+        agent: this.agent,
+        connectionId: attachment.connectionId,
+        env: this.env,
+        exportName: this.exportName,
+        paths: this.paths,
+        run: this.resolveRun(attachment.userId, attachment.identity),
+        send: (frame) => {
+          this.send(ws, frame);
+        },
+        sendAudio: (bytes) => {
+          this.sendAudio(ws, bytes);
+        },
+        signal: controller.signal,
+        streamGenerate: this.streamGenerate,
+        synthesize: async (text, signal) => this.synthesizeWithSignal(text, signal),
+        threadKey: attachment.threadKey,
+        transcribe: async (pcm) => this.transcribe(pcm),
+        turn: attachment.turn,
+        waitForDrain: async () => this.waitForSocketDrain(ws),
+        ...attachment.userId === void 0 ? {} : { owner: attachment.userId },
+        ...input.pcm === void 0 ? {} : { pcm: input.pcm },
+        ...input.text === void 0 ? {} : { text: input.text }
+      });
+    } finally {
+      if (this.controllers.get(attachment.connectionId) === controller) {
+        this.controllers.delete(attachment.connectionId);
+      }
+      ws.serializeAttachment?.({ ...attachment, turn: attachment.turn + 1 });
+    }
+  }
+  /** Synthesize a greeting on connect and persist it as the thread's opening assistant turn. */
+  async speakGreeting(ws, connectionId, threadKey, userId, identity, greeting) {
+    const run = this.resolveRun(userId, identity);
+    const controller = new AbortController();
+    const isAborted = () => controller.signal.aborted;
+    this.controllers.set(connectionId, controller);
+    try {
+      await run(toFunctionReference(this.paths.ensureThread), {
+        agent: this.exportName,
+        key: threadKey,
+        ...this.agent.initialState === void 0 ? {} : { initialState: this.agent.initialState },
+        ...userId === void 0 ? {} : { owner: userId }
+      });
+      for await (const chunk of toByteIterable(await this.synthesizeWithSignal(greeting, controller.signal))) {
+        if (isAborted()) {
+          break;
+        }
+        await this.waitForSocketDrain(ws);
+        if (isAborted()) {
+          break;
+        }
+        this.sendAudio(ws, chunk);
+      }
+      if (!isAborted()) {
+        await run(toFunctionReference(this.paths.appendMessage), {
+          content: greeting,
+          messageKey: "voice:greeting:assistant",
+          role: "assistant",
+          threadKey
+        });
+        this.send(ws, { text: greeting, type: "assistant_done" });
+      }
+    } catch (error) {
+      this.send(ws, { message: error instanceof Error ? error.message : String(error), type: "error" });
+    } finally {
+      if (this.controllers.get(connectionId) === controller) {
+        this.controllers.delete(connectionId);
+      }
+    }
+  }
+  /** Bridge the pipeline's `(text, signal)` synthesize seam onto the class TTS method, forwarding the barge-in signal. */
+  async synthesizeWithSignal(text, signal) {
+    if (signal.aborted) {
+      return new Uint8Array(0);
+    }
+    return this.synthesize(text, signal);
+  }
+  /** Abort an in-flight turn and free a socket's transient buffers. */
+  cleanupSocket(ws) {
+    const attachment = ws.deserializeAttachment?.();
+    if (!attachment) {
+      return;
+    }
+    this.controllers.get(attachment.connectionId)?.abort();
+    this.controllers.delete(attachment.connectionId);
+    this.audioBuffers.delete(attachment.connectionId);
+    this.bufferedBytes.delete(attachment.connectionId);
+  }
+  /** Send a JSON control frame, swallowing a closed-socket error (never throw from a handler). */
+  // eslint-disable-next-line class-methods-use-this -- instance method (kept non-static for subclass override symmetry); acts on the passed socket
+  send(ws, frame) {
+    try {
+      ws.send(JSON.stringify(frame));
+    } catch {
+    }
+  }
+  /** Send a binary audio frame, swallowing a closed-socket error. */
+  // eslint-disable-next-line class-methods-use-this -- instance method (kept non-static for subclass override symmetry); acts on the passed socket
+  sendAudio(ws, bytes) {
+    try {
+      ws.send(bytes);
+    } catch {
+    }
+  }
+  /**
+   * Outbound backpressure: if the socket exposes `bufferedAmount`, yield in
+   * short polls until the send buffer drains below the cap so a slow client
+   * can't balloon DO memory. Bounded by {@link MAX_DRAIN_WAIT_MS} so a stuck
+   * socket never blocks a turn forever, and never throws (a socket without
+   * `bufferedAmount` resolves immediately).
+   */
+  // eslint-disable-next-line class-methods-use-this -- instance method (kept non-static for subclass override symmetry); acts on the passed socket
+  async waitForSocketDrain(ws) {
+    const socket = ws;
+    let waited = 0;
+    while (typeof socket.bufferedAmount === "number" && socket.bufferedAmount > MAX_SOCKET_BUFFER_BYTES && waited < MAX_DRAIN_WAIT_MS) {
+      await new Promise((resolve) => {
+        setTimeout(resolve, DRAIN_POLL_MS);
+      });
+      waited += DRAIN_POLL_MS;
+    }
+  }
+}
+
+export { VoiceSessionDO as default };

package/dist/packem_shared/adaptMcpResult-wtNMvLoP.mjs

@@ -0,0 +1,65 @@
+import { LunoraError } from '@lunora/errors';
+import { jsonSchema } from 'ai';
+
+const adaptMcpResult = (result) => {
+  if (result.structuredContent !== void 0) {
+    return result.structuredContent;
+  }
+  const text = (result.content ?? []).filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n");
+  if (result.isError === true) {
+    return `MCP tool error: ${text.length > 0 ? text : "unknown error"}`;
+  }
+  if (text.length > 0) {
+    return text;
+  }
+  return result.content;
+};
+const adaptMcpTool = (client, info) => {
+  return {
+    description: info.description ?? `MCP tool "${info.name}".`,
+    // Runs inside the loop's `tool:NAME:CALL_ID` durable step: a completed
+    // call is memoized on replay, and a failed step retries at-least-once —
+    // the same idempotency contract every agent tool carries.
+    execute: async (input) => adaptMcpResult(await client.callTool({ arguments: input, name: info.name })),
+    inputSchema: jsonSchema(info.inputSchema),
+    isLunoraAgentTool: true
+  };
+};
+const connectClient = async (options) => {
+  if (options.command !== void 0) {
+    throw new LunoraError(
+      "INTERNAL",
+      "@lunora/agent: mcpTools `command` (stdio transport) cannot run in the Workers runtime — pass a `url` for an HTTP/SSE MCP server, or inject a connected `client`"
+    );
+  }
+  if (options.url === void 0) {
+    throw new LunoraError("INTERNAL", "@lunora/agent: mcpTools requires a `url` (an HTTP/SSE MCP server) or an injected `client`");
+  }
+  const url = new URL(options.url);
+  const { Client } = await import('@modelcontextprotocol/sdk/client/index.js');
+  let transport;
+  if (options.transport === "sse") {
+    const { SSEClientTransport } = await import('@modelcontextprotocol/sdk/client/sse.js');
+    transport = new SSEClientTransport(url);
+  } else {
+    const { StreamableHTTPClientTransport } = await import('@modelcontextprotocol/sdk/client/streamableHttp.js');
+    transport = new StreamableHTTPClientTransport(url);
+  }
+  const client = new Client({ name: options.name ?? "lunora-agent", version: options.version ?? "0.0.0" });
+  await client.connect(transport);
+  return client;
+};
+const mcpTools = async (options) => {
+  const client = options.client ?? await connectClient(options);
+  const { tools: listed } = await client.listTools();
+  const record = {};
+  for (const info of listed) {
+    if (options.only !== void 0 && !options.only.includes(info.name)) {
+      continue;
+    }
+    record[`${options.prefix ?? ""}${info.name}`] = adaptMcpTool(client, info);
+  }
+  return record;
+};
+
+export { adaptMcpResult, mcpTools };

package/dist/packem_shared/agentAsTool-Dt8NlU6k.mjs

@@ -0,0 +1,94 @@
+import { LunoraError } from '@lunora/errors';
+import { jsonSchema } from 'ai';
+import { agentBindingName } from '../naming.mjs';
+import { toFunctionReference, DEFAULT_AGENT_FUNCTION_PATHS } from './AGENT_MODULE-Dnt_-AAT.mjs';
+
+const TERMINAL_STATUSES = /* @__PURE__ */ new Set(["complete", "errored", "terminated"]);
+const DEFAULT_MAX_POLLS = 120;
+const DEFAULT_POLL_INTERVAL_MS = 500;
+const readStatus = (raw) => {
+  if (raw !== null && typeof raw === "object" && typeof raw.status === "string") {
+    return raw.status;
+  }
+  return "unknown";
+};
+const defaultWait = async (ms) => {
+  await new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+};
+const pollUntilTerminal = async (instance, maxPolls, pollIntervalMs, wait) => {
+  for (let attempt = 0; attempt < maxPolls; attempt += 1) {
+    const status = readStatus(await instance.status());
+    if (TERMINAL_STATUSES.has(status)) {
+      return status;
+    }
+    await wait(pollIntervalMs);
+  }
+  return "timeout";
+};
+const finalAnswer = (history) => {
+  for (let index = history.length - 1; index >= 0; index -= 1) {
+    const row = history[index];
+    if (row?.role === "assistant" && (row.toolCalls === void 0 || row.toolCalls.length === 0)) {
+      return row.content;
+    }
+  }
+  return "";
+};
+const agentAsTool = (options) => {
+  if (typeof options.name !== "string" || options.name.length === 0) {
+    throw new LunoraError("INTERNAL", "@lunora/agent: agent.asTool requires a `name` (the child agent's export name, selecting its AGENT_* binding)");
+  }
+  if (typeof options.description !== "string" || options.description.length === 0) {
+    throw new LunoraError("INTERNAL", "@lunora/agent: agent.asTool requires a non-empty `description` (the parent model decides from it)");
+  }
+  const { name } = options;
+  const bindingName = agentBindingName(name);
+  const maxPolls = options.maxPolls ?? DEFAULT_MAX_POLLS;
+  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const wait = options.wait ?? defaultWait;
+  const listMessages = toFunctionReference(DEFAULT_AGENT_FUNCTION_PATHS.listMessages);
+  const execute = async (input, context) => {
+    const binding = context.env[bindingName];
+    if (!binding || typeof binding.create !== "function" || typeof binding.get !== "function") {
+      throw new LunoraError(
+        "INTERNAL",
+        `@lunora/agent: agent.asTool("${name}") found no Workflow binding "${bindingName}" on env — declare the "${name}" agent so codegen wires its binding`
+      );
+    }
+    const childThreadKey = `${context.threadKey}::sub::${name}::${context.toolCallId}`;
+    const childInstanceId = `sub-${name}-${context.toolCallId}`;
+    const params = { input: input.prompt, threadKey: childThreadKey };
+    let instance;
+    try {
+      const handle = await binding.create({ id: childInstanceId, params });
+      instance = await binding.get(handle.id);
+    } catch {
+      instance = await binding.get(childInstanceId);
+    }
+    const terminal = await pollUntilTerminal(instance, maxPolls, pollIntervalMs, wait);
+    if (terminal === "errored" || terminal === "terminated") {
+      return `Sub-agent "${name}" ${terminal} before producing an answer.`;
+    }
+    if (terminal === "timeout") {
+      return `Sub-agent "${name}" did not finish within the allotted time.`;
+    }
+    const history = await context.run(listMessages, { key: childThreadKey });
+    return finalAnswer(history);
+  };
+  return {
+    description: options.description,
+    execute,
+    inputSchema: jsonSchema({
+      properties: {
+        prompt: { description: "The task or question to delegate to the sub-agent.", type: "string" }
+      },
+      required: ["prompt"],
+      type: "object"
+    }),
+    isLunoraAgentTool: true
+  };
+};
+
+export { agentAsTool };

package/dist/packem_shared/base64-BVwtgRJV.mjs

@@ -0,0 +1,18 @@
+const toBase64 = (bytes) => {
+  let binary = "";
+  const chunk = 32768;
+  for (let index = 0; index < bytes.length; index += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(index, index + chunk));
+  }
+  return btoa(binary);
+};
+const fromBase64 = (base64) => {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.codePointAt(index) ?? 0;
+  }
+  return bytes;
+};
+
+export { fromBase64 as f, toBase64 as t };

package/dist/packem_shared/braintrustTelemetry-wuGDErob.mjs

@@ -0,0 +1,47 @@
+import { d as describeError, t as toolInputOf, r as readField } from './common-DAeFCot5.mjs';
+
+const stringOr = (value, fallback) => typeof value === "string" && value.length > 0 ? value : fallback;
+const braintrustTelemetry = (options) => {
+  const { functionId, logger, recordInputs = false, recordOutputs = false } = options;
+  return {
+    executeLanguageModelCall: (options_) => logger.traced(
+      async (span) => {
+        if (recordInputs) {
+          span.log({ input: readField(options_, "messages"), model: readField(options_, "modelId") });
+        }
+        const output = await options_.execute();
+        if (recordOutputs) {
+          span.log({ output });
+        }
+        return output;
+      },
+      { name: stringOr(functionId, "language_model_call"), type: "llm" }
+    ),
+    executeTool: (options_) => {
+      const toolName = readField(readField(options_, "toolCall"), "toolName");
+      return logger.traced(
+        async (span) => {
+          if (recordInputs) {
+            span.log({ input: toolInputOf(options_), tool: toolName });
+          }
+          const output = await options_.execute();
+          if (recordOutputs) {
+            span.log({ output });
+          }
+          return output;
+        },
+        { name: stringOr(toolName, "execute_tool"), type: "tool" }
+      );
+    },
+    onError: (error) => {
+      logger.traced(
+        (span) => {
+          span.log({ error: describeError(error) });
+        },
+        { name: "error", type: "error" }
+      );
+    }
+  };
+};
+
+export { braintrustTelemetry };