@lunora/codegen 1.0.0-alpha.42 → 1.0.0-alpha.44

package/dist/packem_shared/{emit-31Yg1Ee5.mjs → emit-C_29WVlW.mjs}

@@ -1,3 +1,4 @@
+import { agentComponent } from '@lunora/agent/component';
 import { LunoraError } from '@lunora/errors';
 import { s as sanitizeNamespace } from './paths-BRd6JHuF.mjs';
 
@@ -696,19 +697,19 @@ ${members}
   };
   return [...namespaces.entries()].toSorted(([a], [b]) => a.localeCompare(b)).map((entry) => renderNamespace(entry)).join("\n");
 };
-const renderWorkflowsRef = (workflows) => {
-  if (workflows.length === 0) {
+const renderSchedulerReferences = (workflows, agents) => {
+  if (workflows.length === 0 && agents.length === 0) {
     return { block: "", importLine: "" };
   }
-  const sorted = [...workflows].toSorted((a, b) => a.exportName.localeCompare(b.exportName));
-  const refMembers = sorted.map((workflow) => `    ${workflow.exportName}: WorkflowReference<WorkflowParamsOf<typeof lunoraWorkflowDefinitions.${workflow.exportName}>>;`).join("\n");
-  const objectMembers = sorted.map(
-    (workflow) => `    ${workflow.exportName}: { isLunoraWorkflow: true, binding: ${JSON.stringify(workflow.bindingName)}, name: ${JSON.stringify(workflow.exportName)} },`
-  ).join("\n");
-  const block = `
+  const importLines = [];
+  let block = "";
+  if (workflows.length > 0) {
+    block += `
 /** Params type carried by a \`defineWorkflow\` definition (its phantom \`__params\`). */
 type WorkflowParamsOf<Definition> = Definition extends { __params?: infer Params } ? (unknown extends Params ? Record<string, unknown> : Params) : Record<string, unknown>;
-
+`;
+  }
+  block += `
 /** A typed reference to a durable workflow, addressable for \`cronJobs()\` targets. Mirrors \`@lunora/scheduler\`'s \`WorkflowReference\` structurally. */
 export interface WorkflowReference<Params = Record<string, unknown>> {
     readonly isLunoraWorkflow: true;
@@ -716,7 +717,14 @@ export interface WorkflowReference<Params = Record<string, unknown>> {
     readonly binding: string;
     readonly name: string;
 }
-
+`;
+  if (workflows.length > 0) {
+    const sorted = [...workflows].toSorted((a, b) => a.exportName.localeCompare(b.exportName));
+    const refMembers = sorted.map((workflow) => `    ${workflow.exportName}: WorkflowReference<WorkflowParamsOf<typeof lunoraWorkflowDefinitions.${workflow.exportName}>>;`).join("\n");
+    const objectMembers = sorted.map(
+      (workflow) => `    ${workflow.exportName}: { isLunoraWorkflow: true, binding: ${JSON.stringify(workflow.bindingName)}, name: ${JSON.stringify(workflow.exportName)} },`
+    ).join("\n");
+    block += `
 /** This project's durable workflows, addressable as typed references (e.g. \`crons.daily("digest", …, workflows.digestPipeline, params)\`). */
 export interface WorkflowsRef {
 ${refMembers}
@@ -726,17 +734,189 @@ export const workflows: WorkflowsRef = {
 ${objectMembers}
 };
 `;
-  return { block, importLine: `import type * as lunoraWorkflowDefinitions from "../workflows.js";
-` };
+    importLines.push(`import type * as lunoraWorkflowDefinitions from "../workflows.js";
+`);
+  }
+  if (agents.length > 0) {
+    const sorted = [...agents].toSorted((a, b) => a.exportName.localeCompare(b.exportName));
+    const refMembers = sorted.map((agent) => `    ${agent.exportName}: WorkflowReference<AgentRunInput>;`).join("\n");
+    const objectMembers = sorted.map(
+      (agent) => `    ${agent.exportName}: { isLunoraWorkflow: true, binding: ${JSON.stringify(agent.bindingName)}, name: ${JSON.stringify(agent.name)} },`
+    ).join("\n");
+    block += `
+/** This project's durable agents, addressable as typed references for \`cronJobs()\` — each fire starts a fresh agent run (e.g. \`crons.daily("sweep", …, agents.support, { input, threadKey })\`). */
+export interface AgentsRef {
+${refMembers}
+}
+
+export const agents: AgentsRef = {
+${objectMembers}
+};
+`;
+    importLines.push(`import type { AgentRunInput } from "@lunora/agent";
+`);
+  }
+  return { block, importLine: importLines.join("") };
+};
+const agentRuntimeFunctionNames = () => Object.keys(agentComponent().functions).toSorted((a, b) => a.localeCompare(b));
+const takenAgentFunctionNames = (functions) => new Set(functions.filter((definition) => sanitizeNamespace(definition.filePath) === "agents").map((definition) => definition.exportName));
+const renderAgentFunctionRegistry = (agents, functions) => {
+  const empty = { importLine: "", lines: "", prelude: "" };
+  if (agents.length === 0) {
+    return empty;
+  }
+  const taken = takenAgentFunctionNames(functions);
+  const names = agentRuntimeFunctionNames().filter((name) => !taken.has(name));
+  if (names.length === 0) {
+    return empty;
+  }
+  return {
+    importLine: 'import { agentComponent } from "@lunora/agent/component";\n',
+    lines: names.map((name) => `    "agents:${name}": lunoraAgentRuntimeFunctions.${name} as unknown as RegisteredLunoraFunction,`).join("\n"),
+    prelude: "\n/**\n * The `@lunora/agent` runtime component — auto-registered because `lunora/agents.ts`\n * declares agents. The durable loop dispatches the internal mutations; clients\n * subscribe to the public queries (`agents:agentMessages` is the live thread view).\n */\nconst lunoraAgentRuntimeFunctions = agentComponent().functions;\n"
+  };
+};
+const renderSandboxFunctionRegistry = (usesSandbox, functions) => {
+  if (!usesSandbox) {
+    return { importLine: "", lines: "", prelude: "" };
+  }
+  const collision = functions.find((definition) => sanitizeNamespace(definition.filePath) === "sandbox" && definition.exportName === "invoke");
+  if (collision) {
+    throw new LunoraError(
+      "INTERNAL",
+      `@lunora/codegen: "sandbox:invoke" is reserved for the batteries-included sandbox tool dispatcher (browserTool/containerTool) — rename the "invoke" export in ${collision.filePath}`
+    );
+  }
+  return {
+    importLine: 'import { sandboxComponent } from "@lunora/agent/component";\n',
+    lines: '    "sandbox:invoke": lunoraSandbox.invoke as unknown as RegisteredLunoraFunction,',
+    prelude: "\n/**\n * The `@lunora/agent` sandbox dispatcher — auto-registered because `lunora/`\n * imports a sandbox tool (`browserTool`/`containerTool`). The batteries-included\n * tools dispatch to this internal action, which runs on an action ctx carrying\n * `ctx.browser` + `ctx.containers` (the durable tool step itself has neither).\n */\nconst lunoraSandbox = sandboxComponent();\n"
+  };
 };
-const emitApi = (functions, workflows = [], useUmbrella = false) => {
+const syntheticAgentApiFunctions = (agents, functions) => {
+  if (agents.length === 0) {
+    return [];
+  }
+  const taken = takenAgentFunctionNames(functions);
+  const definitions = [
+    {
+      args: { key: { kind: "string" }, limit: { inner: { kind: "number" }, kind: "optional" } },
+      exportName: "agentMessages",
+      filePath: "agents",
+      kind: "query",
+      returnType: "Record<string, unknown>[]"
+    },
+    {
+      args: {
+        decision: {
+          kind: "union",
+          members: [
+            { kind: "literal", literalValue: '"approve"' },
+            { kind: "literal", literalValue: '"reject"' }
+          ]
+        },
+        instanceId: { kind: "string" },
+        note: { inner: { kind: "string" }, kind: "optional" },
+        threadKey: { kind: "string" },
+        toolCallId: { kind: "string" }
+      },
+      exportName: "agentResolveApproval",
+      filePath: "agents",
+      kind: "mutation",
+      returnType: "{ resolved: boolean }"
+    },
+    {
+      args: {
+        agent: { kind: "string" },
+        input: { kind: "string" },
+        threadKey: { kind: "string" },
+        title: { inner: { kind: "string" }, kind: "optional" }
+      },
+      exportName: "agentRun",
+      filePath: "agents",
+      kind: "mutation",
+      returnType: "{ id: string; threadKey: string }"
+    },
+    {
+      args: { key: { kind: "string" } },
+      exportName: "agentState",
+      filePath: "agents",
+      kind: "query",
+      returnType: "Record<string, unknown> | undefined"
+    },
+    {
+      args: { key: { kind: "string" } },
+      exportName: "agentThread",
+      filePath: "agents",
+      kind: "query",
+      returnType: "Record<string, unknown> | undefined"
+    }
+  ];
+  for (const agent of agents) {
+    if (agent.voice) {
+      definitions.push({
+        args: { threadKey: { kind: "string" } },
+        exportName: `${agent.exportName}Voice`,
+        filePath: "agents",
+        kind: "stream",
+        returnType: "Record<string, unknown>"
+      });
+    }
+  }
+  return definitions.filter((definition) => !taken.has(definition.exportName));
+};
+const renderHttpStreamsRef = (httpRoutes) => {
+  const streams = httpRoutes.filter((route) => route.stream);
+  if (streams.length === 0) {
+    return { block: "", body: "" };
+  }
+  const namespaces = /* @__PURE__ */ new Map();
+  for (const route of streams) {
+    const list = namespaces.get(route.filePath) ?? [];
+    list.push(route);
+    namespaces.set(route.filePath, list);
+  }
+  const sortedNamespaces = [...namespaces.entries()].toSorted(([a], [b]) => a.localeCompare(b));
+  const typeBody = sortedNamespaces.map(([file, list]) => {
+    const members = list.map((route) => {
+      const chunkType = relocateGeneratedImports(route.chunkType ?? "unknown");
+      return `        ${renderPropertyKey(route.exportName)}: HttpStreamRef<${chunkType}, ${renderArgsType(route.searchParams)}, ${renderArgsType(route.params)}>;`;
+    }).join("\n");
+    return `    ${renderPropertyKey(sanitizeNamespace(file))}: {
+${members}
+    };`;
+  }).join("\n");
+  const valueBody = sortedNamespaces.map(([file, list]) => {
+    const members = list.map(
+      (route) => `        ${renderPropertyKey(route.exportName)}: { method: ${JSON.stringify(route.method)}, path: ${JSON.stringify(route.path)} },`
+    ).join("\n");
+    return `    ${renderPropertyKey(sanitizeNamespace(file))}: {
+${members}
+    },`;
+  }).join("\n");
+  const block = `
+/** This project's HTTP-SSE stream routes (\`httpRoute.<verb>(path).stream()\`), addressable as typed references for \`client.httpStream\` / \`useHttpStream\`. */
+export interface HttpStreamsRef {
+${typeBody}
+}
+
+export const httpStreams: HttpStreamsRef = {
+${valueBody}
+};
+`;
+  return { block, body: typeBody };
+};
+const emitApi = (options) => {
+  const { agents = [], functions, httpRoutes = [], useUmbrella = false, workflows = [] } = options;
   const base = baseSpecifiers(useUmbrella);
-  const publicFunctions = functions.filter((definition) => definition.visibility !== "internal");
+  const publicFunctions = [...functions.filter((definition) => definition.visibility !== "internal"), ...syntheticAgentApiFunctions(agents, functions)];
   const internalFunctions = functions.filter((definition) => definition.visibility === "internal");
   const publicBody = renderApiBody(publicFunctions);
   const internalBody = renderApiBody(internalFunctions);
+  const httpStreamsRef = renderHttpStreamsRef(httpRoutes);
   const combinedBody = `${publicBody}
-${internalBody}`;
+${internalBody}
+${httpStreamsRef.body}`;
   const dataModelImports = referencedDataModelImports(combinedBody);
   const dataModelImportLine = dataModelImports.length > 0 ? `
 import type { ${dataModelImports.join(", ")} } from "./dataModel.js";
@@ -747,10 +927,11 @@ ${publicBody}
   const internalBlock = internalBody ? `
 ${internalBody}
 ` : "";
-  const workflowsRef = renderWorkflowsRef(workflows);
+  const schedulerReferences = renderSchedulerReferences(workflows, agents);
+  const clientImports = httpStreamsRef.block === "" ? "FunctionReference" : "FunctionReference, HttpStreamRef";
   return `${GENERATED_HEADER}import { anyApi } from "${base.serverTypes}";
-import type { FunctionReference } from "${base.client}";
-${workflowsRef.importLine}${dataModelImportLine}
+import type { ${clientImports} } from "${base.client}";
+${schedulerReferences.importLine}${dataModelImportLine}
 export interface ApiTypes {${apiBlock}}
 
 export const api = anyApi as unknown as ApiTypes;
@@ -759,7 +940,7 @@ export const api = anyApi as unknown as ApiTypes;
 export interface InternalApiTypes {${internalBlock}}
 
 export const internal = anyApi as unknown as InternalApiTypes;
-${workflowsRef.block}`;
+${schedulerReferences.block}${httpStreamsRef.block}`;
 };
 const emitSeed = (enabled) => {
   if (!enabled) {
@@ -928,6 +1109,7 @@ const buildStorageBucketNames = (schema, ruleBuckets = []) => {
   return ["default", ...[...named].toSorted((a, b) => a.localeCompare(b))];
 };
 const emitServer = ({
+  agents = [],
   containers = [],
   env,
   hasAccessFacade = false,
@@ -986,6 +1168,11 @@ const emitServer = ({
       assertIdentifier(queue.bindingName, `queue binding "${queue.bindingName}"`);
       return `    /** Queue producer binding for the \`${queue.exportName}\` queue. */
     readonly ${queue.bindingName}?: unknown;`;
+    }),
+    ...agents.map((agent) => {
+      assertIdentifier(agent.bindingName, `agent binding "${agent.bindingName}"`);
+      return `    /** Workflow binding for the \`${agent.exportName}\` agent. */
+    readonly ${agent.bindingName}?: unknown;`;
     })
   ].join("\n");
   const envBlock = `
@@ -1056,6 +1243,20 @@ ${queues.map((queue) => `    readonly ${queue.exportName}: QueueProducer<QueueBo
 }` : "";
   const queuesContextField = hasQueues ? `
     readonly queues: LunoraQueues;` : "";
+  const hasAgents = agents.length > 0;
+  const agentsTypeImport = hasAgents ? `import type { AgentHandle } from "@lunora/agent";
+` : "";
+  const agentsTypeBlock = hasAgents ? `
+
+/** This project's declared agents, addressable from \`ctx.agents\` by their \`lunora/agents.ts\` export name. */
+export interface LunoraAgents {
+${agents.map((agent) => {
+    assertIdentifier(agent.exportName, `agent export "${agent.exportName}"`);
+    return `    readonly ${agent.exportName}: AgentHandle;`;
+  }).join("\n")}
+}` : "";
+  const agentsContextField = hasAgents ? `
+    readonly agents: LunoraAgents;` : "";
   const identityTypeImport = identity ? `import type { InferIdentity } from "${base.server}";
 import type * as lunoraIdentityContract from "../identity.js";
 ` : "";
@@ -1101,11 +1302,11 @@ import type {
 } from "${base.server}";
 
 import type { DataModel, DatabaseReaderFacade, DatabaseWriterFacade, Doc, Id as IdOfTable, OrmReader, OrmWriter, Relations, TableName } from "./dataModel.js";
-${aiTypeImport}${paymentsTypeImport}${x402TypeImport}${containersTypeImport}${workflowsTypeImport}${queuesTypeImport}${identityTypeImport}${envTypeImport}
+${aiTypeImport}${paymentsTypeImport}${x402TypeImport}${containersTypeImport}${workflowsTypeImport}${queuesTypeImport}${agentsTypeImport}${identityTypeImport}${envTypeImport}
 export type { DataModel, Doc, Id, TableName } from "./dataModel.js";
 
 /** Storage buckets this schema declares (\`v.storage("name")\`), narrowing \`ctx.storage.bucket(name)\`. */
-export type StorageBucketName = ${storageBucketUnion};${envBlock}${workflowsTypeBlock}${queuesTypeBlock}${identityTypeBlock}${envTypeBlock}
+export type StorageBucketName = ${storageBucketUnion};${envBlock}${workflowsTypeBlock}${queuesTypeBlock}${agentsTypeBlock}${identityTypeBlock}${envTypeBlock}
 
 /**
  * Project-typed contexts. The base contexts from \`@lunora/server\` are
@@ -1143,13 +1344,13 @@ export interface QueryCtx extends Omit<QueryCtxBase, "db" | "storage"${authOmit}
 export interface MutationCtx extends Omit<MutationCtxBase, "db" | "storage"${workflowsOmit}${authOmit}${envOmit}> {
     readonly db: Omit<DatabaseWriter, "query" | "get"> & DatabaseWriterFacade & { query: TypedTableQuery; get: TypedTableGet };
     readonly orm: OrmWriter;
-    readonly storage: ReadOnlyStorage<StorageBucketName>;${accessContextField}${kvContextField}${flagsContextField}${analyticsContextField}${envContextField}${workflowsContextField}${queuesContextField}${authContextField}
+    readonly storage: ReadOnlyStorage<StorageBucketName>;${accessContextField}${kvContextField}${flagsContextField}${analyticsContextField}${envContextField}${workflowsContextField}${queuesContextField}${agentsContextField}${authContextField}
 }
 
 export interface ActionCtx extends Omit<ActionCtxBase, "db" | "storage"${workflowsOmit}${authOmit}${envOmit}> {
     readonly db: Omit<DatabaseWriter, "query" | "get"> & DatabaseWriterFacade & { query: TypedTableQuery; get: TypedTableGet };
     readonly orm: OrmWriter;
-    readonly storage: StorageBase<StorageBucketName>;${accessContextField}${aiActionField}${paymentsActionField}${x402ActionField}${containersActionField}${kvContextField}${flagsContextField}${hyperdriveActionField}${browserActionField}${imagesActionField}${analyticsContextField}${pipelinesActionField}${r2sqlActionField}${envContextField}${workflowsContextField}${queuesContextField}${authContextField}
+    readonly storage: StorageBase<StorageBucketName>;${accessContextField}${aiActionField}${paymentsActionField}${x402ActionField}${containersActionField}${kvContextField}${flagsContextField}${hyperdriveActionField}${browserActionField}${imagesActionField}${analyticsContextField}${pipelinesActionField}${r2sqlActionField}${envContextField}${workflowsContextField}${queuesContextField}${agentsContextField}${authContextField}
 }
 
 /**
@@ -1219,10 +1420,22 @@ const renderLifecycleManifest = (functions) => {
   }
   return manifest;
 };
-const emitFunctions = (functions, migrations = [], useUmbrella = false, mutators = [], shapes = []) => {
+const emitFunctions = (options) => {
+  const { agents = [], functions, migrations = [], mutators = [], shapes = [], useUmbrella = false, usesSandbox = false } = options;
   const hasFunctions = functions.length > 0;
   const base = baseSpecifiers(useUmbrella);
   const { dispatchBody, importBlock, installBlock, migrationBody, mutatorPaths, shapeBody } = renderFunctionRegistry(functions, migrations, mutators, shapes);
+  const agentRegistry = renderAgentFunctionRegistry(agents, functions);
+  const sandboxRegistry = renderSandboxFunctionRegistry(usesSandbox, functions);
+  const autoLines = [agentRegistry.lines, sandboxRegistry.lines].filter((block) => block.length > 0).join("\n");
+  let dispatchBodyWithAgents = dispatchBody;
+  if (autoLines.length > 0) {
+    dispatchBodyWithAgents = dispatchBody.length > 0 ? `${dispatchBody.trimEnd()}
+${autoLines}
+` : `
+${autoLines}
+`;
+  }
   const lifecycleHooks = renderLifecycleManifest(functions);
   const shapeTypeImport = shapes.length > 0 ? `import type { RegisteredShape } from "${base.server}";
 ` : "";
@@ -1267,7 +1480,7 @@ ${caller.implementation}
   const callRegisteredHelper = hasFunctions ? `${CALL_REGISTERED_HELPER}
 
 ` : "";
-  return `${GENERATED_HEADER}${importBlock}${compiledArgsImport}${shapeTypeImport}import { LunoraError } from "${base.server}";
+  return `${GENERATED_HEADER}${importBlock}${agentRegistry.importLine}${sandboxRegistry.importLine}${compiledArgsImport}${shapeTypeImport}import { LunoraError } from "${base.server}";
 import type { ActionCtx, MutationCtx, QueryCtx } from "./server.js";
 ${dataModelImport}
 /**
@@ -1288,12 +1501,12 @@ export interface RegisteredLunoraFunction {
     /** \`"internal"\` functions are rejected on the external RPC path; absence === public. */
     visibility?: "internal" | "public";
 }
-
+${agentRegistry.prelude}${sandboxRegistry.prelude}
 /**
  * Static dispatch table. The key matches the \`__lunoraRef\` the client
  * emits (\`api[namespace][fn].__lunoraRef === "namespace:fn"\`).
  */
-export const LUNORA_FUNCTIONS: Record<string, RegisteredLunoraFunction> = {${dispatchBody}};
+export const LUNORA_FUNCTIONS: Record<string, RegisteredLunoraFunction> = {${dispatchBodyWithAgents}};
 ${compiledArgsInstall}${shapeRegistry}${mutatorPathsRegistry}
 /**
  * Connection-lifecycle manifest: the function paths the generated ShardDO
@@ -1967,6 +2180,62 @@ type WorkflowParamsOf<Definition> = Definition extends { __params?: infer Params
 /** Output type carried by a \`defineWorkflow\` definition (its phantom \`__output\`), so each entrypoint keeps the authored return type. */
 type WorkflowOutputOf<Definition> = Definition extends { __output?: infer Output } ? Output : unknown;
 
+${classes}`;
+};
+const emitAgents = (agents) => {
+  if (agents.length === 0) {
+    return "";
+  }
+  const voiceAgents = agents.filter((agent) => agent.voice);
+  const hasVoice = voiceAgents.length > 0;
+  const classes = agents.map((agent) => {
+    assertIdentifier(agent.exportName, `agent export "${agent.exportName}"`);
+    assertIdentifier(agent.className, `agent class "${agent.className}"`);
+    const workflowClass = `/** WorkflowEntrypoint for the \`${agent.exportName}\` agent (binding \`${agent.bindingName}\`). */
+export class ${agent.className} extends LunoraWorkflow<AgentRunInput, AgentRunResult> {
+    public constructor(ctx: ConstructorParameters<typeof LunoraWorkflow>[0], env: Record<string, unknown>) {
+        super(ctx, env, compileAgentWorkflow(${agent.exportName}, "${agent.exportName}"), "${agent.exportName}");
+    }
+}
+`;
+    if (!agent.voice) {
+      return workflowClass;
+    }
+    const voiceClassName = agent.voiceClassName ?? "";
+    const voiceBindingName = agent.voiceBindingName ?? "";
+    assertIdentifier(voiceClassName, `agent voice class "${voiceClassName}"`);
+    const voiceClass = `
+/** Voice-session Durable Object for the \`${agent.exportName}\` agent (binding \`${voiceBindingName}\`). */
+export class ${voiceClassName} extends VoiceSessionDO {
+    public constructor(ctx: ConstructorParameters<typeof VoiceSessionDO>[0], env: Record<string, unknown>) {
+        super(ctx, env, ${agent.exportName}, "${agent.exportName}");
+    }
+}
+`;
+    return `${workflowClass}${voiceClass}`;
+  }).join("\n");
+  const imports = agents.map((agent) => agent.exportName).join(", ");
+  const runtimeImport = hasVoice ? `import { compileAgentWorkflow, VoiceSessionDO } from "@lunora/agent";` : `import { compileAgentWorkflow } from "@lunora/agent";`;
+  const voiceHeaderNote = hasVoice ? `
+ *
+ * Voice-enabled agents ALSO get a \`VoiceSessionDO\` subclass here — a real
+ * Durable Object (unlike the Workflow), so wrangler needs both its
+ * \`durable_objects\` binding and its \`class_name\` export (the same re-export
+ * line covers it).` : "";
+  return `${GENERATED_HEADER}/**
+ * WorkflowEntrypoint classes for the agents declared in \`lunora/agents.ts\`.
+ * Each \`defineAgent\` compiles a replay-safe tool-loop onto a Cloudflare
+ * Workflow. Re-export them from your worker entry — wrangler requires each
+ * \`workflows[].class_name\` to be exported by the worker:
+ *
+ * \`export * from "./lunora/_generated/agents.js";\`${voiceHeaderNote}
+ */
+import LunoraWorkflow from "@lunora/workflow/do";
+${runtimeImport}
+import type { AgentRunInput, AgentRunResult } from "@lunora/agent";
+
+import { ${imports} } from "../agents.js";
+
 ${classes}`;
 };
 const emitQueues = (queues) => {
@@ -2045,6 +2314,31 @@ ${specEntries}
 `
   };
 };
+const emitAgentFragments = (agents) => {
+  if (agents.length === 0) {
+    return { build: "", contextField: "", importLines: [], specs: "" };
+  }
+  for (const agent of agents) {
+    assertIdentifier(agent.exportName, `agent export "${agent.exportName}"`);
+    assertIdentifier(agent.bindingName, `agent binding "${agent.bindingName}"`);
+  }
+  const specEntries = agents.map((agent) => `    { binding: "${agent.bindingName}", exportName: "${agent.exportName}"${agent.publicRun === true ? ", publicRun: true" : ""} },`).join("\n");
+  return {
+    build: `
+            const agents = createAgentContext(env, LUNORA_AGENTS);
+`,
+    contextField: `
+                agents,`,
+    importLines: [`import { createAgentContext } from "@lunora/agent";`, `import type { AgentBindingSpec } from "@lunora/agent";`],
+    // eslint-disable-next-line no-secrets/no-secrets -- the emitted readonly-array type annotation is dense generated TS, not a credential
+    specs: `
+/** Wiring specs for \`ctx.agents\` (codegen-derived from \`lunora/agents.ts\`). */
+const LUNORA_AGENTS: ReadonlyArray<AgentBindingSpec> = [
+${specEntries}
+];
+`
+  };
+};
 const emitWorkflowsMetadataFragments = (workflows) => {
   if (workflows.length === 0) {
     return { constant: "", override: "" };
@@ -2208,6 +2502,7 @@ const buildDoTypeImports = (hasVectors, hasWorkflows, hasQueues, hasFlags) => [
 ];
 const emitShard = ({
   advisories = [],
+  agents = [],
   containers = [],
   env,
   flagKeys = [],
@@ -2262,6 +2557,7 @@ const emitShard = ({
     importLines: workflowImportLines,
     specs: workflowSpecs
   } = emitWorkflowFragments(workflows);
+  const { build: agentsBuild, contextField: agentsContextField, importLines: agentImportLines, specs: agentSpecs } = emitAgentFragments(agents);
   const {
     build: paymentsBuild,
     configField: paymentsConfigField,
@@ -2408,6 +2704,7 @@ const LUNORA_RLS_READ_REGISTRY = buildRlsReadRegistry(Object.values(LUNORA_FUNCT
     ...containerImportLines,
     ...workflowImportLines,
     ...queueImportLines,
+    ...agentImportLines,
     ...paymentsImports,
     ...x402Imports,
     ``,
@@ -2749,7 +3046,7 @@ const LUNORA_STORAGE_RULES: StorageRulesResult = ${JSON.stringify(storageRulesDa
 
 /** Which optional package-backed features this app wires up (discovered from imports / \`ctx.*\` reads / schema signals) served via \`__lunora_admin__:studioFeatures\` so the studio hides nav pages whose package isn't enabled. */
 const LUNORA_STUDIO_FEATURES: StudioFeaturesResult = ${JSON.stringify(studioFeaturesData, void 0, 4)};
-${flagsOverrides.constant}${shapeReadRegistryConst}${workflowsMetadataConst}${queuesMetadataConst}${containerSpecs}${workflowSpecs}${queueSpecs}
+${flagsOverrides.constant}${shapeReadRegistryConst}${workflowsMetadataConst}${queuesMetadataConst}${containerSpecs}${workflowSpecs}${queueSpecs}${agentSpecs}
 export interface ShardDOConfig {
     /** Opt into change-data-capture: records a post-image to \`__cdc_log\` on every write (backs streaming export + replay-PITR). */
     cdc?: boolean;
@@ -3165,7 +3462,7 @@ ${flagsOverrides.evaluateOverride}${flagsOverrides.subscriptionOverride}${workfl
             // dispatch path) fall back to the per-request fields as before.
             const userId = options.identity ? options.identity.userId : this.getCurrentUserId();
             const identity = options.identity ? options.identity.identity : this.getCurrentIdentity();
-${vectorsBuild}${aiBuild}${everyContextBuild}${containersBuild}${workflowsBuild}${queuesBuild}
+${vectorsBuild}${aiBuild}${everyContextBuild}${containersBuild}${workflowsBuild}${queuesBuild}${agentsBuild}
             const scheduler = (config.scheduler?.(env) ?? schedulerStub) as SchedulerLike;
             // Build the storage adapter once and share it between \`ctx.storage\`
             // and \`ctx.db.system._storage\` so both read the same R2 binding. The
@@ -3207,7 +3504,7 @@ ${facadeBlock}${paymentsBuild}
                 log,
                 now,${ormContextField}
                 scheduler,
-                storage,${vectorsContextField}${aiContextField}${everyContextField}${paymentsContextField}${containersContextField}${workflowsContextField}${queuesContextField}
+                storage,${vectorsContextField}${aiContextField}${everyContextField}${paymentsContextField}${containersContextField}${workflowsContextField}${queuesContextField}${agentsContextField}
             };
 ${isActionLine}${actionOnlyBlock}
             ctx.runAction = (reference: FunctionReference, fnArgs: Record<string, unknown>) => dispatchRun("action", reference.__lunoraRef, fnArgs, ctx);
@@ -3471,4 +3768,4 @@ const emitWranglerCronTriggers = (crons) => {
   return triggers;
 };
 
-export { APP_METHOD_CAPABILITIES as A, CAPABILITIES as C, GENERATED_HEADER as G, emitCollections as a, emitContainers as b, emitCrons as c, emitDataModel as d, emitApi as e, emitDrizzleSchema as f, emitFunctions as g, emitServer as h, emitShard as i, emitVectors as j, emitWorkflows as k, emitWranglerCronTriggers as l, buildStorageColumns as m, emitQueues as n, emitSeed as o };
+export { APP_METHOD_CAPABILITIES as A, CAPABILITIES as C, GENERATED_HEADER as G, emitApi as a, emitCollections as b, emitContainers as c, emitCrons as d, emitAgents as e, emitDataModel as f, emitDrizzleSchema as g, emitFunctions as h, emitServer as i, emitShard as j, emitVectors as k, emitWorkflows as l, emitWranglerCronTriggers as m, buildStorageColumns as n, emitQueues as o, emitSeed as p };

package/dist/packem_shared/{emitApp-DCP7Pr6M.mjs → emitApp-C9oljiZd.mjs}

@@ -1,4 +1,4 @@
-import { A as APP_METHOD_CAPABILITIES, G as GENERATED_HEADER } from './emit-31Yg1Ee5.mjs';
+import { A as APP_METHOD_CAPABILITIES, G as GENERATED_HEADER } from './emit-C_29WVlW.mjs';
 
 const hasFlagKey = (key) => `has${key.charAt(0).toUpperCase()}${key.slice(1)}`;
 const LONG_TAIL = APP_METHOD_CAPABILITIES.map(
@@ -11,6 +11,9 @@ const buildAccessImports = (hasAccess, hasAuth) => hasAccess ? [
   `import { createAccessResolver${hasAuth ? ", composeResolvers" : ""} } from "@lunora/cloudflare-access";`
 ] : [];
 const buildKvImports = (hasKv) => hasKv ? [`import { createKvIntrospectorFromEnv } from "@lunora/bindings/kv";`] : [];
+const hasEmailAgents = (options) => (options.emailAgents?.length ?? 0) > 0;
+const buildInboundImports = (options) => hasEmailAgents(options) ? [`import { dispatchAgentEmail } from "@lunora/agent/inbound";`] : [];
+const buildAgentDefinitionsImport = (options) => hasEmailAgents(options) ? [`import * as lunoraAgentDefinitions from "../agents.js";`] : [];
 const buildImportLines = (options) => {
   const {
     hasAccess,
@@ -59,10 +62,12 @@ const buildImportLines = (options) => {
     ...hasScheduler ? [`import type { DurableObjectNamespaceLike } from "@lunora/scheduler";`, `import { createScheduler } from "@lunora/scheduler";`] : [],
     ...hasStorage ? [`import type { R2BucketLike, Storage } from "@lunora/storage";`, `import { createBucketStorage, createStorage } from "@lunora/storage";`] : [],
     ...hasWorkflow ? [`import { createWorkflowsRestClient } from "@lunora/workflow";`] : [],
+    ...buildInboundImports(options),
     `import type { ${[...runtimeTypeImports].toSorted((a, b) => a.localeCompare(b)).join(", ")} } from "${runtimeModule}";`,
     `import { ${runtimeValueImports} } from "${runtimeModule}";`,
     ``,
     ...buildIdentityImports(options.identity),
+    ...buildAgentDefinitionsImport(options),
     ...hasGlobal || hasHyperdriveGlobal ? [`import schema from "../schema.js";`] : [],
     `import { LUNORA_CRONS } from "./crons.js";`,
     `import { LUNORA_FUNCTIONS } from "./functions.js";`,
@@ -383,6 +388,18 @@ const buildWorkerOptionLines = (options) => [
         }` : `        if (this.accessSelector) {
             options.resolveIdentity = createAccessResolver(this.accessSelector(env));
         }`
+  ] : [],
+  // Voice-enabled agents: map each export name to its `VOICE_*` Durable Object
+  // namespace so the runtime serves `/_lunora/voice/<exportName>`. Read off
+  // `env` structurally (the binding is provisioned by the config layer's
+  // reconcile step, so it may not be on the generated `Env` type). Emitted only
+  // when at least one agent opted into voice — voice-free output is unchanged.
+  ...options.voiceAgents && options.voiceAgents.length > 0 ? [
+    `        options.voiceAgents = {
+${options.voiceAgents.map(
+      (agent) => `            ${JSON.stringify(agent.exportName)}: (env as Record<string, unknown>)[${JSON.stringify(agent.bindingName)}] as ShardNamespaceLike,`
+    ).join("\n")}
+        };`
   ] : []
 ];
 const buildBaseWorkerOptions = (options) => [
@@ -554,6 +571,12 @@ const emitApp = (options) => {
   const buildWorkerLine = options.hasFramework ? `        const buildWorker = (env: Env): LunoraWorker =>
             host ? withFrameworkWorker(host, (hostEnv) => this.buildWorkerOptions(hostEnv as Env, ${getAuthArgument})) : createWorker(this.buildWorkerOptions(env, ${getAuthArgument}));` : `        const buildWorker = (env: Env): LunoraWorker => createWorker(this.buildWorkerOptions(env, ${getAuthArgument}));`;
   const assembleParameter = options.hasFramework ? `host?: FrameworkHostHandler` : ``;
+  const emailAgents = options.emailAgents ?? [];
+  const emailAgentsBlock = emailAgents.length > 0 ? `        composed.email = dispatchAgentEmail([
+${emailAgents.map((agent) => `            { agent: lunoraAgentDefinitions.${agent.exportName}, binding: ${JSON.stringify(agent.bindingName)} },`).join("\n")}
+        ]);
+
+` : "";
   const buildTerminals = `    /** Materialise the standalone Cloudflare worker + \`ShardDO\` class. */
     public build(): ComposedApp {
         return this.assemble();
@@ -630,7 +653,7 @@ ${buildWorkerLine}
             },` : ""}
         };
 
-        if (this.emailHandler) {
+${emailAgentsBlock}        if (this.emailHandler) {
             const handler = this.emailHandler;
 
             composed.email = (message, rawEnv, context) => handler(rawEnv as Env)(message, rawEnv, context);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/codegen",
-  "version": "1.0.0-alpha.42",
+  "version": "1.0.0-alpha.44",
   "description": "Code generator for Lunora: emits _generated/{api,server,dataModel}.ts from your schema",
   "keywords": [
     "cloudflare",
@@ -46,13 +46,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/advisor": "1.0.0-alpha.26",
-    "@lunora/container": "1.0.0-alpha.11",
-    "@lunora/errors": "1.0.0-alpha.4",
-    "@lunora/queue": "1.0.0-alpha.7",
-    "@lunora/scheduler": "1.0.0-alpha.8",
-    "@lunora/values": "1.0.0-alpha.7",
-    "@lunora/workflow": "1.0.0-alpha.9",
+    "@lunora/advisor": "1.0.0-alpha.28",
+    "@lunora/agent": "1.0.0-alpha.2",
+    "@lunora/container": "1.0.0-alpha.12",
+    "@lunora/errors": "1.0.0-alpha.5",
+    "@lunora/queue": "1.0.0-alpha.8",
+    "@lunora/scheduler": "1.0.0-alpha.10",
+    "@lunora/values": "1.0.0-alpha.8",
+    "@lunora/workflow": "1.0.0-alpha.10",
     "ts-morph": "^28.0.0"
   },
   "engines": {

package/dist/packem_shared/GENERATED_HEADER-D6RK1WF1.mjs

@@ -1,3 +0,0 @@
-import '@lunora/errors';
-export { G as GENERATED_HEADER, m as buildStorageColumns, e as emitApi, a as emitCollections, b as emitContainers, c as emitCrons, d as emitDataModel, f as emitDrizzleSchema, g as emitFunctions, n as emitQueues, o as emitSeed, h as emitServer, i as emitShard, j as emitVectors, k as emitWorkflows, l as emitWranglerCronTriggers } from './emit-31Yg1Ee5.mjs';
-import './paths-BRd6JHuF.mjs';