experimental-agent 0.7.1 → 0.8.0-alpha.2

package/dist/next/agents.d.mts

@@ -0,0 +1,43 @@
+import { F as Framework } from '../framework-c9fvEy0o.mjs';
+import { NextConfig } from 'next';
+import '../types-B3lbsOa7.mjs';
+
+/** A Next.js config object or async config function. */
+type NextConfigInput = NextConfig | ((phase: string, ctx: {
+    defaultConfig: NextConfig;
+}) => Promise<NextConfig>);
+/** Options for {@link withAgents}. */
+type WithAgentsConfig = {
+    /**
+     * Path to the agents directory, relative to the project root.
+     * When omitted, auto-detected as the first existing directory
+     * among `src/agents` and `agents`.
+     */
+    agentsDir?: string;
+    /** Enable verbose logging to stdout. */
+    debug?: boolean;
+};
+
+/**
+ * Next.js config wrapper that discovers agents on the filesystem and
+ * generates the route handler + registry files needed to serve them.
+ *
+ * Call this in `next.config.ts`:
+ *
+ * @example
+ * ```ts
+ * import { withAgents } from "experimental-agent/next/agents";
+ *
+ * export default withAgents({ reactStrictMode: true });
+ * ```
+ *
+ * Debug logs:
+ * ```ts
+ * import { withAgents } from "experimental-agent/next/agents";
+ *
+ * export default withAgents({ reactStrictMode: true }, { debug: true });
+ * ```
+ */
+declare function withAgents(config: NextConfigInput, agentsConfig?: Pick<ConstructorParameters<typeof Framework>[0], "agentsDir" | "debug">): NextConfigInput;
+
+export { type NextConfigInput, type WithAgentsConfig, withAgents };

package/dist/next/agents.d.ts

@@ -0,0 +1,43 @@
+import { F as Framework } from '../framework-DH4Z1NLV.js';
+import { NextConfig } from 'next';
+import '../types-B3lbsOa7.js';
+
+/** A Next.js config object or async config function. */
+type NextConfigInput = NextConfig | ((phase: string, ctx: {
+    defaultConfig: NextConfig;
+}) => Promise<NextConfig>);
+/** Options for {@link withAgents}. */
+type WithAgentsConfig = {
+    /**
+     * Path to the agents directory, relative to the project root.
+     * When omitted, auto-detected as the first existing directory
+     * among `src/agents` and `agents`.
+     */
+    agentsDir?: string;
+    /** Enable verbose logging to stdout. */
+    debug?: boolean;
+};
+
+/**
+ * Next.js config wrapper that discovers agents on the filesystem and
+ * generates the route handler + registry files needed to serve them.
+ *
+ * Call this in `next.config.ts`:
+ *
+ * @example
+ * ```ts
+ * import { withAgents } from "experimental-agent/next/agents";
+ *
+ * export default withAgents({ reactStrictMode: true });
+ * ```
+ *
+ * Debug logs:
+ * ```ts
+ * import { withAgents } from "experimental-agent/next/agents";
+ *
+ * export default withAgents({ reactStrictMode: true }, { debug: true });
+ * ```
+ */
+declare function withAgents(config: NextConfigInput, agentsConfig?: Pick<ConstructorParameters<typeof Framework>[0], "agentsDir" | "debug">): NextConfigInput;
+
+export { type NextConfigInput, type WithAgentsConfig, withAgents };

package/dist/next/agents.js

@@ -0,0 +1,364 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/framework-next/agents-plugin.ts
+var agents_plugin_exports = {};
+__export(agents_plugin_exports, {
+  withAgents: () => withAgents
+});
+module.exports = __toCommonJS(agents_plugin_exports);
+
+// src/framework/generate.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var TS_IMPORT_EXT = /\.(ts|mts)$/;
+function generateRegistry(opts) {
+  const entries = opts.agents.map(
+    (agent) => inlineEntry({ agent, outputDir: opts.outputDir })
+  );
+  return [
+    "// Auto-generated by withAgents - do not edit",
+    'import type { AgentRegistry } from "experimental-agent/framework";',
+    "",
+    "export const agents = {",
+    ...entries,
+    "} satisfies AgentRegistry;",
+    ""
+  ].join("\n");
+}
+function inlineEntry(opts) {
+  const config = buildConfig(opts.agent);
+  const configStr = JSON.stringify(config, null, 2).split("\n").map((line, i) => i === 0 ? line : `      ${line}`).join("\n");
+  const parts = [`    config: ${configStr}`];
+  if (opts.agent.hasAgentConfig) {
+    const configPath = findAgentConfigPath(opts.agent.absolutePath);
+    const relativePath = relativeImportPath({
+      from: opts.outputDir,
+      to: configPath
+    });
+    parts.push(`    import: () => import(${JSON.stringify(relativePath)})`);
+  }
+  return `  ${JSON.stringify(opts.agent.name)}: {
+${parts.join(",\n")}
+  },`;
+}
+function buildConfig(agent) {
+  const config = {};
+  if (agent.systemPrompt) {
+    config.system = agent.systemPrompt;
+  }
+  if (agent.skills.length > 0) {
+    config.skills = agent.skills;
+  }
+  return config;
+}
+function findAgentConfigPath(agentDir) {
+  const extensions = [".ts", ".js", ".mts", ".mjs"];
+  for (const ext of extensions) {
+    const candidate = path.join(agentDir, `agent${ext}`);
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return path.join(agentDir, "agent");
+}
+function relativeImportPath(opts) {
+  let rel = path.relative(opts.from, opts.to).replace(/\\/g, "/");
+  rel = rel.replace(TS_IMPORT_EXT, "");
+  if (!rel.startsWith(".")) {
+    rel = `./${rel}`;
+  }
+  return rel;
+}
+
+// src/framework/scan.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var AGENT_CONFIG_FILES = ["agent.ts", "agent.js", "agent.mts", "agent.mjs"];
+var MD_EXT = /\.md$/;
+var TS_EXT = /\.(ts|js|mts|mjs)$/;
+function listDir(dir) {
+  if (!fs2.existsSync(dir)) {
+    return [];
+  }
+  return fs2.readdirSync(dir);
+}
+function readFile(filePath) {
+  return fs2.readFileSync(filePath, "utf-8");
+}
+function fileExists(filePath) {
+  return fs2.existsSync(filePath);
+}
+function isDirectory(filePath) {
+  return fs2.existsSync(filePath) && fs2.statSync(filePath).isDirectory();
+}
+function discoverAgentDirs(agentsRoot) {
+  const entries = listDir(agentsRoot);
+  const dirs = [];
+  for (const entry of entries) {
+    const absolutePath = path2.join(agentsRoot, entry);
+    if (!isDirectory(absolutePath)) {
+      continue;
+    }
+    if (entry.startsWith(".")) {
+      continue;
+    }
+    dirs.push({
+      name: entry,
+      absolutePath,
+      hasAgentConfig: hasAgentConfig(absolutePath)
+    });
+  }
+  return dirs;
+}
+function hasAgentConfig(agentDir) {
+  return AGENT_CONFIG_FILES.some((f) => fileExists(path2.join(agentDir, f)));
+}
+function getSkills(agentDir) {
+  const skillsDir = path2.join(agentDir, "skills");
+  const entries = listDir(skillsDir);
+  const skills = [];
+  const tsSkillImportPaths = [];
+  for (const entry of entries.sort()) {
+    const absolutePath = path2.join(skillsDir, entry);
+    if (MD_EXT.test(entry)) {
+      skills.push({
+        type: "host",
+        path: absolutePath
+      });
+    } else if (TS_EXT.test(entry)) {
+      tsSkillImportPaths.push(absolutePath);
+    }
+  }
+  return { skills, tsSkillImportPaths };
+}
+function getSystemPrompt(agentDir) {
+  const systemDir = path2.join(agentDir, "system");
+  const entries = listDir(systemDir);
+  const mdFiles = entries.filter((e) => MD_EXT.test(e)).sort();
+  if (mdFiles.length === 0) {
+    return void 0;
+  }
+  const parts = [];
+  for (const file of mdFiles) {
+    const content = readFile(path2.join(systemDir, file)).trim();
+    if (content) {
+      parts.push(content);
+    }
+  }
+  return parts.length > 0 ? parts.join("\n\n") : void 0;
+}
+function scanAgent(agentDir) {
+  const { skills, tsSkillImportPaths } = getSkills(agentDir.absolutePath);
+  const systemPrompt = getSystemPrompt(agentDir.absolutePath);
+  return { ...agentDir, skills, systemPrompt, tsSkillImportPaths };
+}
+function findAgentsRoot(cwd, userDefinedAgentsDir) {
+  if (userDefinedAgentsDir) {
+    return path2.resolve(cwd, userDefinedAgentsDir);
+  }
+  const candidates = [
+    path2.join(cwd, "src", "agents"),
+    path2.join(cwd, "agents")
+  ];
+  for (const candidate of candidates) {
+    if (isDirectory(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+// src/framework/framework.ts
+var Framework = class {
+  cwd;
+  agentsDir;
+  log;
+  constructor(opts) {
+    this.cwd = opts.cwd ?? process.cwd();
+    this.agentsDir = opts.agentsDir;
+    this.log = opts.debug ? console.log.bind(console, "[Framework]") : () => void 0;
+  }
+  /**
+   * Scan the agents directory and return metadata for every agent found.
+   * Each subfolder inside the agents directory becomes one agent.
+   * Returns an empty array when no agents directory exists.
+   */
+  discoverAgents() {
+    const root = findAgentsRoot(this.cwd, this.agentsDir);
+    if (!root) {
+      return [];
+    }
+    const dirs = discoverAgentDirs(root);
+    return dirs.map(scanAgent);
+  }
+  /**
+   * Generate the TypeScript source for an agent registry module.
+   *
+   * @param opts.agents - Scanned agents to include in the registry.
+   * @param opts.outputDir - Directory where the registry file will be written
+   *   (used to compute relative import paths to each agent's config module).
+   * @returns The full source text of the generated `_registry.ts` file.
+   */
+  generateRegistrySource = generateRegistry;
+};
+
+// src/framework-next/next.ts
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var Next = class {
+  constructor(framework) {
+    this.framework = framework;
+  }
+  get appDir() {
+    const cwd = this.framework.cwd;
+    const srcAppDir = path3.join(cwd, "src", "app");
+    const rootAppDir = path3.join(cwd, "app");
+    if (this.hasAppLayout(srcAppDir)) {
+      return "src/app";
+    }
+    if (this.hasAppLayout(rootAppDir)) {
+      return "app";
+    }
+    if (fs3.existsSync(srcAppDir)) {
+      return "src/app";
+    }
+    return "app";
+  }
+  generateNextRouteHandlerSource(opts) {
+    return `// Auto-generated by withAgents - do not edit
+// @ts-nocheck
+// biome-ignore format, lint, lint/style, lint/suspicious, lint/complexity, lint/performance, lint/security, lint/correctness, lint/strict
+// prettier-ignore
+
+import { runtime } from "experimental-agent/framework-runtime";
+import { handleRequest } from "experimental-agent";
+import { agents } from ${JSON.stringify(opts.registryImportPath)};
+
+async function workflow(agent, sessionId, ...args) {
+  "use workflow";
+  return agent.session(sessionId).send(...args);
+}
+
+async function handler(
+  req: Request,
+  ctx: { params: Promise<{ agent: string; path?: string[] }> }
+) {
+  const params = await ctx.params;
+  const name = params.agent;
+  const instance = await runtime.resolveAgent({ name, agents });
+
+  if (!instance) {
+    const available = Object.keys(agents).join(", ");
+    const body =
+      \`Agent "\${name}" not found.\\n\\n\` +
+      \`Available agents: \${available}\\n\\n\` +
+      \`hint: each folder inside agents/ becomes an agent.\\n\` +
+      \`      Create agents/\${name}/ to add this agent.\\n\`;
+    return new Response(body, { status: 404 });
+  }
+
+  return handleRequest(instance, { basePath: \`/.well-known/agents/\${name}\`, workflow }).fetch(req);
+}
+
+export const GET = handler;
+export const POST = handler;
+`;
+  }
+  /**
+   * Pure codegen step: scan agents and return the generated source
+   * strings without touching the filesystem. Useful for adapters that
+   * need to control where and how files are written.
+   *
+   * Returns `null` when no agents are found.
+   */
+  filesToWrite() {
+    const agents = this.framework.discoverAgents();
+    if (agents.length === 0) {
+      return null;
+    }
+    this.framework.log(
+      "discovered agents:",
+      agents.map((a) => a.name)
+    );
+    const dir = path3.join(
+      this.framework.cwd,
+      this.appDir,
+      ".well-known",
+      "agents",
+      "[agent]",
+      "[[...path]]"
+    );
+    const registrySource = this.framework.generateRegistrySource({
+      agents,
+      outputDir: dir
+    });
+    const routeSource = this.generateNextRouteHandlerSource({
+      registryImportPath: "./_registry"
+    });
+    return { registrySource, routeSource, dir };
+  }
+  /**
+   * Scan for agents, generate source, and write the `_registry.ts` and
+   * `route.ts` files into the Next.js app directory.
+   */
+  writeFiles() {
+    const filesToWrite = this.filesToWrite();
+    if (!filesToWrite) {
+      console.warn("[withAgents] No agents found");
+      return;
+    }
+    const { registrySource, routeSource, dir } = filesToWrite;
+    fs3.mkdirSync(dir, { recursive: true });
+    fs3.writeFileSync(path3.join(dir, "_registry.ts"), registrySource);
+    fs3.writeFileSync(path3.join(dir, "route.ts"), routeSource);
+    const gitignorePath = path3.join(dir, ".gitignore");
+    if (!fs3.existsSync(gitignorePath)) {
+      fs3.writeFileSync(gitignorePath, "*\n");
+    }
+  }
+  hasAppLayout(dir) {
+    return ["layout.tsx", "layout.js", "layout.jsx"].some(
+      (f) => fs3.existsSync(path3.join(dir, f))
+    );
+  }
+};
+
+// src/framework-next/agents-plugin.ts
+function withAgents(config, agentsConfig = {}) {
+  const framework = new Framework(agentsConfig);
+  const next = new Next(framework);
+  next.writeFiles();
+  return config;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withAgents
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/framework-next/agents-plugin.ts", "../../src/framework/generate.ts", "../../src/framework/scan.ts", "../../src/framework/framework.ts", "../../src/framework-next/next.ts"],
  "sourcesContent": ["import { Framework } from \"../framework/framework\";\nimport { Next, type NextConfigInput } from \"./next\";\n\nexport type { NextConfigInput, WithAgentsConfig } from \"./next\";\n\n/**\n * Next.js config wrapper that discovers agents on the filesystem and\n * generates the route handler + registry files needed to serve them.\n *\n * Call this in `next.config.ts`:\n *\n * @example\n * ```ts\n * import { withAgents } from \"experimental-agent/next/agents\";\n *\n * export default withAgents({ reactStrictMode: true });\n * ```\n *\n * Debug logs:\n * ```ts\n * import { withAgents } from \"experimental-agent/next/agents\";\n *\n * export default withAgents({ reactStrictMode: true }, { debug: true });\n * ```\n */\nexport function withAgents(\n  config: NextConfigInput,\n  agentsConfig: Pick<\n    ConstructorParameters<typeof Framework>[0],\n    \"agentsDir\" | \"debug\"\n  > = {}\n): NextConfigInput {\n  const framework = new Framework(agentsConfig);\n  const next = new Next(framework);\n  next.writeFiles();\n\n  return config;\n}\n", "import * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport type { ScannedAgent } from \"./scan\";\n\nconst TS_IMPORT_EXT = /\\.(ts|mts)$/;\nexport function generateRegistry(opts: {\n  agents: ScannedAgent[];\n  outputDir: string;\n}): string {\n  const entries = opts.agents.map((agent) =>\n    inlineEntry({ agent, outputDir: opts.outputDir })\n  );\n\n  return [\n    \"// Auto-generated by withAgents - do not edit\",\n    'import type { AgentRegistry } from \"experimental-agent/framework\";',\n    \"\",\n    \"export const agents = {\",\n    ...entries,\n    \"} satisfies AgentRegistry;\",\n    \"\",\n  ].join(\"\\n\");\n}\n\nfunction inlineEntry(opts: {\n  agent: ScannedAgent;\n  outputDir: string;\n}): string {\n  const config = buildConfig(opts.agent);\n  const configStr = JSON.stringify(config, null, 2)\n    .split(\"\\n\")\n    .map((line, i) => (i === 0 ? line : `      ${line}`))\n    .join(\"\\n\");\n\n  const parts = [`    config: ${configStr}`];\n\n  if (opts.agent.hasAgentConfig) {\n    const configPath = findAgentConfigPath(opts.agent.absolutePath);\n    const relativePath = relativeImportPath({\n      from: opts.outputDir,\n      to: configPath,\n    });\n    parts.push(`    import: () => import(${JSON.stringify(relativePath)})`);\n  }\n\n  return `  ${JSON.stringify(opts.agent.name)}: {\\n${parts.join(\",\\n\")}\\n  },`;\n}\n\nfunction buildConfig(agent: ScannedAgent): Record<string, unknown> {\n  const config: Record<string, unknown> = {};\n\n  if (agent.systemPrompt) {\n    config.system = agent.systemPrompt;\n  }\n\n  if (agent.skills.length > 0) {\n    config.skills = agent.skills;\n  }\n\n  return config;\n}\n\nfunction findAgentConfigPath(agentDir: string): string {\n  const extensions = [\".ts\", \".js\", \".mts\", \".mjs\"];\n  for (const ext of extensions) {\n    const candidate = path.join(agentDir, `agent${ext}`);\n    if (fs.existsSync(candidate)) {\n      return candidate;\n    }\n  }\n  return path.join(agentDir, \"agent\");\n}\n\nfunction relativeImportPath(opts: { from: string; to: string }): string {\n  let rel = path.relative(opts.from, opts.to).replace(/\\\\/g, \"/\");\n  rel = rel.replace(TS_IMPORT_EXT, \"\");\n  if (!rel.startsWith(\".\")) {\n    rel = `./${rel}`;\n  }\n  return rel;\n}\n\n", "import * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport type { HostSkillInput, SkillInput } from \"../skills/types\";\n\nexport type AgentDir = {\n  name: string;\n  absolutePath: string;\n  hasAgentConfig: boolean;\n};\n\nexport type ScannedAgent = AgentDir & {\n  skills: SkillInput[];\n  systemPrompt: string | undefined;\n  tsSkillImportPaths: string[];\n};\n\nconst AGENT_CONFIG_FILES = [\"agent.ts\", \"agent.js\", \"agent.mts\", \"agent.mjs\"];\nconst MD_EXT = /\\.md$/;\nconst TS_EXT = /\\.(ts|js|mts|mjs)$/;\n\nexport function listDir(dir: string): string[] {\n  if (!fs.existsSync(dir)) {\n    return [];\n  }\n  return fs.readdirSync(dir);\n}\n\nexport function readFile(filePath: string): string {\n  return fs.readFileSync(filePath, \"utf-8\");\n}\n\nexport function fileExists(filePath: string): boolean {\n  return fs.existsSync(filePath);\n}\n\nexport function isDirectory(filePath: string): boolean {\n  return fs.existsSync(filePath) && fs.statSync(filePath).isDirectory();\n}\n\nexport function discoverAgentDirs(agentsRoot: string): AgentDir[] {\n  const entries = listDir(agentsRoot);\n  const dirs: AgentDir[] = [];\n\n  for (const entry of entries) {\n    const absolutePath = path.join(agentsRoot, entry);\n    if (!isDirectory(absolutePath)) {\n      continue;\n    }\n    if (entry.startsWith(\".\")) {\n      continue;\n    }\n\n    dirs.push({\n      name: entry,\n      absolutePath,\n      hasAgentConfig: hasAgentConfig(absolutePath),\n    });\n  }\n\n  return dirs;\n}\n\nexport function hasAgentConfig(agentDir: string): boolean {\n  return AGENT_CONFIG_FILES.some((f) => fileExists(path.join(agentDir, f)));\n}\n\nexport function getSkills(agentDir: string): {\n  skills: SkillInput[];\n  tsSkillImportPaths: string[];\n} {\n  const skillsDir = path.join(agentDir, \"skills\");\n  const entries = listDir(skillsDir);\n  const skills: SkillInput[] = [];\n  const tsSkillImportPaths: string[] = [];\n\n  for (const entry of entries.sort()) {\n    const absolutePath = path.join(skillsDir, entry);\n\n    if (MD_EXT.test(entry)) {\n      skills.push({\n        type: \"host\",\n        path: absolutePath,\n      } satisfies HostSkillInput);\n    } else if (TS_EXT.test(entry)) {\n      tsSkillImportPaths.push(absolutePath);\n    }\n  }\n\n  return { skills, tsSkillImportPaths };\n}\n\nexport function getSystemPrompt(agentDir: string): string | undefined {\n  const systemDir = path.join(agentDir, \"system\");\n  const entries = listDir(systemDir);\n  const mdFiles = entries.filter((e) => MD_EXT.test(e)).sort();\n\n  if (mdFiles.length === 0) {\n    return undefined;\n  }\n\n  const parts: string[] = [];\n  for (const file of mdFiles) {\n    const content = readFile(path.join(systemDir, file)).trim();\n    if (content) {\n      parts.push(content);\n    }\n  }\n\n  return parts.length > 0 ? parts.join(\"\\n\\n\") : undefined;\n}\n\nexport function scanAgent(agentDir: AgentDir): ScannedAgent {\n  const { skills, tsSkillImportPaths } = getSkills(agentDir.absolutePath);\n  const systemPrompt = getSystemPrompt(agentDir.absolutePath);\n\n  return { ...agentDir, skills, systemPrompt, tsSkillImportPaths };\n}\n\nexport function findAgentsRoot(\n  cwd: string,\n  userDefinedAgentsDir: string | undefined\n): string | null {\n  if (userDefinedAgentsDir) {\n    return path.resolve(cwd, userDefinedAgentsDir);\n  }\n  const candidates = [\n    path.join(cwd, \"src\", \"agents\"),\n    path.join(cwd, \"agents\"),\n  ];\n\n  for (const candidate of candidates) {\n    if (isDirectory(candidate)) {\n      return candidate;\n    }\n  }\n\n  return null;\n}\n", "import { generateRegistry } from \"./generate\";\nimport type { ScannedAgent } from \"./scan\";\nimport { discoverAgentDirs, findAgentsRoot, scanAgent } from \"./scan\";\n\n/**\n * Framework-agnostic core for filesystem-based agent discovery and\n * registry code generation. Adapters like {@link Next} receive a\n * `Framework` instance and use it to scan agents and produce registry\n * source code.\n */\nexport class Framework {\n  readonly cwd: string;\n  readonly agentsDir: string | undefined;\n  readonly log: (...args: unknown[]) => void;\n\n  constructor(opts: {\n    /**\n     * Project root directory.\n     * @defaultValue `process.cwd()`\n     */\n    cwd?: string;\n    /**\n     * Path to the agents directory, relative to `cwd`.\n     * When omitted, auto-detected as the first existing directory\n     * among `src/agents` and `agents`.\n     */\n    agentsDir?: string;\n    /** Enable verbose logging to stdout. */\n    debug?: boolean;\n  }) {\n    this.cwd = opts.cwd ?? process.cwd();\n    this.agentsDir = opts.agentsDir;\n    this.log = opts.debug\n      ? console.log.bind(console, \"[Framework]\")\n      : () => undefined;\n  }\n\n  /**\n   * Scan the agents directory and return metadata for every agent found.\n   * Each subfolder inside the agents directory becomes one agent.\n   * Returns an empty array when no agents directory exists.\n   */\n  discoverAgents(): ScannedAgent[] {\n    const root = findAgentsRoot(this.cwd, this.agentsDir);\n    if (!root) {\n      return [];\n    }\n    const dirs = discoverAgentDirs(root);\n    return dirs.map(scanAgent);\n  }\n\n  /**\n   * Generate the TypeScript source for an agent registry module.\n   *\n   * @param opts.agents - Scanned agents to include in the registry.\n   * @param opts.outputDir - Directory where the registry file will be written\n   *   (used to compute relative import paths to each agent's config module).\n   * @returns The full source text of the generated `_registry.ts` file.\n   */\n  generateRegistrySource = generateRegistry;\n}\n", "import * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport type { NextConfig } from \"next\";\nimport type { Framework } from \"../framework/framework\";\n\n/** A Next.js config object or async config function. */\nexport type NextConfigInput =\n  | NextConfig\n  | ((\n      phase: string,\n      ctx: { defaultConfig: NextConfig }\n    ) => Promise<NextConfig>);\n\n/** Options for {@link withAgents}. */\nexport type WithAgentsConfig = {\n  /**\n   * Path to the agents directory, relative to the project root.\n   * When omitted, auto-detected as the first existing directory\n   * among `src/agents` and `agents`.\n   */\n  agentsDir?: string;\n  /** Enable verbose logging to stdout. */\n  debug?: boolean;\n};\n\n/**\n * Next.js adapter for filesystem-based agent routing.\n *\n * Receives a {@link Framework} instance (composition) and uses it to\n * discover agents, generate a registry, and write the Next.js route\n * handler files that serve them.\n *\n * Most users should use the {@link withAgents} helper instead of\n * constructing this class directly.\n *\n * @example\n * ```ts\n * import { Framework } from \"experimental-agent/framework\";\n * import { Next } from \"experimental-agent/next/agents\";\n *\n * const framework = new Framework({ cwd: process.cwd() });\n * new Next(framework).generate();\n * ```\n */\nexport class Next {\n  constructor(private readonly framework: Framework) {}\n\n  private get appDir(): string {\n    const cwd = this.framework.cwd;\n    const srcAppDir = path.join(cwd, \"src\", \"app\");\n    const rootAppDir = path.join(cwd, \"app\");\n\n    if (this.hasAppLayout(srcAppDir)) {\n      return \"src/app\";\n    }\n    if (this.hasAppLayout(rootAppDir)) {\n      return \"app\";\n    }\n    if (fs.existsSync(srcAppDir)) {\n      return \"src/app\";\n    }\n    return \"app\";\n  }\n\n  generateNextRouteHandlerSource(opts: { registryImportPath: string }): string {\n    return `// Auto-generated by withAgents - do not edit\n// @ts-nocheck\n// biome-ignore format, lint, lint/style, lint/suspicious, lint/complexity, lint/performance, lint/security, lint/correctness, lint/strict\n// prettier-ignore\n\nimport { runtime } from \"experimental-agent/framework-runtime\";\nimport { handleRequest } from \"experimental-agent\";\nimport { agents } from ${JSON.stringify(opts.registryImportPath)};\n\nasync function workflow(agent, sessionId, ...args) {\n  \"use workflow\";\n  return agent.session(sessionId).send(...args);\n}\n\nasync function handler(\n  req: Request,\n  ctx: { params: Promise<{ agent: string; path?: string[] }> }\n) {\n  const params = await ctx.params;\n  const name = params.agent;\n  const instance = await runtime.resolveAgent({ name, agents });\n\n  if (!instance) {\n    const available = Object.keys(agents).join(\", \");\n    const body =\n      \\`Agent \"\\${name}\" not found.\\\\n\\\\n\\` +\n      \\`Available agents: \\${available}\\\\n\\\\n\\` +\n      \\`hint: each folder inside agents/ becomes an agent.\\\\n\\` +\n      \\`      Create agents/\\${name}/ to add this agent.\\\\n\\`;\n    return new Response(body, { status: 404 });\n  }\n\n  return handleRequest(instance, { basePath: \\`/.well-known/agents/\\${name}\\`, workflow }).fetch(req);\n}\n\nexport const GET = handler;\nexport const POST = handler;\n`;\n  }\n\n  /**\n   * Pure codegen step: scan agents and return the generated source\n   * strings without touching the filesystem. Useful for adapters that\n   * need to control where and how files are written.\n   *\n   * Returns `null` when no agents are found.\n   */\n  filesToWrite(): {\n    registrySource: string;\n    routeSource: string;\n    dir: string;\n  } | null {\n    const agents = this.framework.discoverAgents();\n\n    if (agents.length === 0) {\n      return null;\n    }\n\n    this.framework.log(\n      \"discovered agents:\",\n      agents.map((a) => a.name)\n    );\n\n    const dir = path.join(\n      this.framework.cwd,\n      this.appDir,\n      \".well-known\",\n      \"agents\",\n      \"[agent]\",\n      \"[[...path]]\"\n    );\n\n    const registrySource = this.framework.generateRegistrySource({\n      agents,\n      outputDir: dir,\n    });\n    const routeSource = this.generateNextRouteHandlerSource({\n      registryImportPath: \"./_registry\",\n    });\n\n    return { registrySource, routeSource, dir };\n  }\n\n  /**\n   * Scan for agents, generate source, and write the `_registry.ts` and\n   * `route.ts` files into the Next.js app directory.\n   */\n  writeFiles(): void {\n    const filesToWrite = this.filesToWrite();\n\n    if (!filesToWrite) {\n      console.warn(\"[withAgents] No agents found\");\n      return;\n    }\n\n    const { registrySource, routeSource, dir } = filesToWrite;\n\n    fs.mkdirSync(dir, { recursive: true });\n    fs.writeFileSync(path.join(dir, \"_registry.ts\"), registrySource);\n    fs.writeFileSync(path.join(dir, \"route.ts\"), routeSource);\n\n    const gitignorePath = path.join(dir, \".gitignore\");\n    if (!fs.existsSync(gitignorePath)) {\n      fs.writeFileSync(gitignorePath, \"*\\n\");\n    }\n  }\n\n  private hasAppLayout(dir: string): boolean {\n    return [\"layout.tsx\", \"layout.js\", \"layout.jsx\"].some((f) =>\n      fs.existsSync(path.join(dir, f))\n    );\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,SAAoB;AACpB,WAAsB;AAGtB,IAAM,gBAAgB;AACf,SAAS,iBAAiB,MAGtB;AACT,QAAM,UAAU,KAAK,OAAO;AAAA,IAAI,CAAC,UAC/B,YAAY,EAAE,OAAO,WAAW,KAAK,UAAU,CAAC;AAAA,EAClD;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAG;AAAA,IACH;AAAA,IACA;AAAA,EACF,EAAE,KAAK,IAAI;AACb;AAEA,SAAS,YAAY,MAGV;AACT,QAAM,SAAS,YAAY,KAAK,KAAK;AACrC,QAAM,YAAY,KAAK,UAAU,QAAQ,MAAM,CAAC,EAC7C,MAAM,IAAI,EACV,IAAI,CAAC,MAAM,MAAO,MAAM,IAAI,OAAO,SAAS,IAAI,EAAG,EACnD,KAAK,IAAI;AAEZ,QAAM,QAAQ,CAAC,eAAe,SAAS,EAAE;AAEzC,MAAI,KAAK,MAAM,gBAAgB;AAC7B,UAAM,aAAa,oBAAoB,KAAK,MAAM,YAAY;AAC9D,UAAM,eAAe,mBAAmB;AAAA,MACtC,MAAM,KAAK;AAAA,MACX,IAAI;AAAA,IACN,CAAC;AACD,UAAM,KAAK,4BAA4B,KAAK,UAAU,YAAY,CAAC,GAAG;AAAA,EACxE;AAEA,SAAO,KAAK,KAAK,UAAU,KAAK,MAAM,IAAI,CAAC;AAAA,EAAQ,MAAM,KAAK,KAAK,CAAC;AAAA;AACtE;AAEA,SAAS,YAAY,OAA8C;AACjE,QAAM,SAAkC,CAAC;AAEzC,MAAI,MAAM,cAAc;AACtB,WAAO,SAAS,MAAM;AAAA,EACxB;AAEA,MAAI,MAAM,OAAO,SAAS,GAAG;AAC3B,WAAO,SAAS,MAAM;AAAA,EACxB;AAEA,SAAO;AACT;AAEA,SAAS,oBAAoB,UAA0B;AACrD,QAAM,aAAa,CAAC,OAAO,OAAO,QAAQ,MAAM;AAChD,aAAW,OAAO,YAAY;AAC5B,UAAM,YAAiB,UAAK,UAAU,QAAQ,GAAG,EAAE;AACnD,QAAO,cAAW,SAAS,GAAG;AAC5B,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAY,UAAK,UAAU,OAAO;AACpC;AAEA,SAAS,mBAAmB,MAA4C;AACtE,MAAI,MAAW,cAAS,KAAK,MAAM,KAAK,EAAE,EAAE,QAAQ,OAAO,GAAG;AAC9D,QAAM,IAAI,QAAQ,eAAe,EAAE;AACnC,MAAI,CAAC,IAAI,WAAW,GAAG,GAAG;AACxB,UAAM,KAAK,GAAG;AAAA,EAChB;AACA,SAAO;AACT;;;AChFA,IAAAA,MAAoB;AACpB,IAAAC,QAAsB;AAetB,IAAM,qBAAqB,CAAC,YAAY,YAAY,aAAa,WAAW;AAC5E,IAAM,SAAS;AACf,IAAM,SAAS;AAER,SAAS,QAAQ,KAAuB;AAC7C,MAAI,CAAI,eAAW,GAAG,GAAG;AACvB,WAAO,CAAC;AAAA,EACV;AACA,SAAU,gBAAY,GAAG;AAC3B;AAEO,SAAS,SAAS,UAA0B;AACjD,SAAU,iBAAa,UAAU,OAAO;AAC1C;AAEO,SAAS,WAAW,UAA2B;AACpD,SAAU,eAAW,QAAQ;AAC/B;AAEO,SAAS,YAAY,UAA2B;AACrD,SAAU,eAAW,QAAQ,KAAQ,aAAS,QAAQ,EAAE,YAAY;AACtE;AAEO,SAAS,kBAAkB,YAAgC;AAChE,QAAM,UAAU,QAAQ,UAAU;AAClC,QAAM,OAAmB,CAAC;AAE1B,aAAW,SAAS,SAAS;AAC3B,UAAM,eAAoB,WAAK,YAAY,KAAK;AAChD,QAAI,CAAC,YAAY,YAAY,GAAG;AAC9B;AAAA,IACF;AACA,QAAI,MAAM,WAAW,GAAG,GAAG;AACzB;AAAA,IACF;AAEA,SAAK,KAAK;AAAA,MACR,MAAM;AAAA,MACN;AAAA,MACA,gBAAgB,eAAe,YAAY;AAAA,IAC7C,CAAC;AAAA,EACH;AAEA,SAAO;AACT;AAEO,SAAS,eAAe,UAA2B;AACxD,SAAO,mBAAmB,KAAK,CAAC,MAAM,WAAgB,WAAK,UAAU,CAAC,CAAC,CAAC;AAC1E;AAEO,SAAS,UAAU,UAGxB;AACA,QAAM,YAAiB,WAAK,UAAU,QAAQ;AAC9C,QAAM,UAAU,QAAQ,SAAS;AACjC,QAAM,SAAuB,CAAC;AAC9B,QAAM,qBAA+B,CAAC;AAEtC,aAAW,SAAS,QAAQ,KAAK,GAAG;AAClC,UAAM,eAAoB,WAAK,WAAW,KAAK;AAE/C,QAAI,OAAO,KAAK,KAAK,GAAG;AACtB,aAAO,KAAK;AAAA,QACV,MAAM;AAAA,QACN,MAAM;AAAA,MACR,CAA0B;AAAA,IAC5B,WAAW,OAAO,KAAK,KAAK,GAAG;AAC7B,yBAAmB,KAAK,YAAY;AAAA,IACtC;AAAA,EACF;AAEA,SAAO,EAAE,QAAQ,mBAAmB;AACtC;AAEO,SAAS,gBAAgB,UAAsC;AACpE,QAAM,YAAiB,WAAK,UAAU,QAAQ;AAC9C,QAAM,UAAU,QAAQ,SAAS;AACjC,QAAM,UAAU,QAAQ,OAAO,CAAC,MAAM,OAAO,KAAK,CAAC,CAAC,EAAE,KAAK;AAE3D,MAAI,QAAQ,WAAW,GAAG;AACxB,WAAO;AAAA,EACT;AAEA,QAAM,QAAkB,CAAC;AACzB,aAAW,QAAQ,SAAS;AAC1B,UAAM,UAAU,SAAc,WAAK,WAAW,IAAI,CAAC,EAAE,KAAK;AAC1D,QAAI,SAAS;AACX,YAAM,KAAK,OAAO;AAAA,IACpB;AAAA,EACF;AAEA,SAAO,MAAM,SAAS,IAAI,MAAM,KAAK,MAAM,IAAI;AACjD;AAEO,SAAS,UAAU,UAAkC;AAC1D,QAAM,EAAE,QAAQ,mBAAmB,IAAI,UAAU,SAAS,YAAY;AACtE,QAAM,eAAe,gBAAgB,SAAS,YAAY;AAE1D,SAAO,EAAE,GAAG,UAAU,QAAQ,cAAc,mBAAmB;AACjE;AAEO,SAAS,eACd,KACA,sBACe;AACf,MAAI,sBAAsB;AACxB,WAAY,cAAQ,KAAK,oBAAoB;AAAA,EAC/C;AACA,QAAM,aAAa;AAAA,IACZ,WAAK,KAAK,OAAO,QAAQ;AAAA,IACzB,WAAK,KAAK,QAAQ;AAAA,EACzB;AAEA,aAAW,aAAa,YAAY;AAClC,QAAI,YAAY,SAAS,GAAG;AAC1B,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;;;AC/HO,IAAM,YAAN,MAAgB;AAAA,EACZ;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,MAcT;AACD,SAAK,MAAM,KAAK,OAAO,QAAQ,IAAI;AACnC,SAAK,YAAY,KAAK;AACtB,SAAK,MAAM,KAAK,QACZ,QAAQ,IAAI,KAAK,SAAS,aAAa,IACvC,MAAM;AAAA,EACZ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,iBAAiC;AAC/B,UAAM,OAAO,eAAe,KAAK,KAAK,KAAK,SAAS;AACpD,QAAI,CAAC,MAAM;AACT,aAAO,CAAC;AAAA,IACV;AACA,UAAM,OAAO,kBAAkB,IAAI;AACnC,WAAO,KAAK,IAAI,SAAS;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,yBAAyB;AAC3B;;;AC5DA,IAAAC,MAAoB;AACpB,IAAAC,QAAsB;AA2Cf,IAAM,OAAN,MAAW;AAAA,EAChB,YAA6B,WAAsB;AAAtB;AAAA,EAAuB;AAAA,EAEpD,IAAY,SAAiB;AAC3B,UAAM,MAAM,KAAK,UAAU;AAC3B,UAAM,YAAiB,WAAK,KAAK,OAAO,KAAK;AAC7C,UAAM,aAAkB,WAAK,KAAK,KAAK;AAEvC,QAAI,KAAK,aAAa,SAAS,GAAG;AAChC,aAAO;AAAA,IACT;AACA,QAAI,KAAK,aAAa,UAAU,GAAG;AACjC,aAAO;AAAA,IACT;AACA,QAAO,eAAW,SAAS,GAAG;AAC5B,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AAAA,EAEA,+BAA+B,MAA8C;AAC3E,WAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yBAOc,KAAK,UAAU,KAAK,kBAAkB,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA+B9D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,eAIS;AACP,UAAM,SAAS,KAAK,UAAU,eAAe;AAE7C,QAAI,OAAO,WAAW,GAAG;AACvB,aAAO;AAAA,IACT;AAEA,SAAK,UAAU;AAAA,MACb;AAAA,MACA,OAAO,IAAI,CAAC,MAAM,EAAE,IAAI;AAAA,IAC1B;AAEA,UAAM,MAAW;AAAA,MACf,KAAK,UAAU;AAAA,MACf,KAAK;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAEA,UAAM,iBAAiB,KAAK,UAAU,uBAAuB;AAAA,MAC3D;AAAA,MACA,WAAW;AAAA,IACb,CAAC;AACD,UAAM,cAAc,KAAK,+BAA+B;AAAA,MACtD,oBAAoB;AAAA,IACtB,CAAC;AAED,WAAO,EAAE,gBAAgB,aAAa,IAAI;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,aAAmB;AACjB,UAAM,eAAe,KAAK,aAAa;AAEvC,QAAI,CAAC,cAAc;AACjB,cAAQ,KAAK,8BAA8B;AAC3C;AAAA,IACF;AAEA,UAAM,EAAE,gBAAgB,aAAa,IAAI,IAAI;AAE7C,IAAG,cAAU,KAAK,EAAE,WAAW,KAAK,CAAC;AACrC,IAAG,kBAAmB,WAAK,KAAK,cAAc,GAAG,cAAc;AAC/D,IAAG,kBAAmB,WAAK,KAAK,UAAU,GAAG,WAAW;AAExD,UAAM,gBAAqB,WAAK,KAAK,YAAY;AACjD,QAAI,CAAI,eAAW,aAAa,GAAG;AACjC,MAAG,kBAAc,eAAe,KAAK;AAAA,IACvC;AAAA,EACF;AAAA,EAEQ,aAAa,KAAsB;AACzC,WAAO,CAAC,cAAc,aAAa,YAAY,EAAE;AAAA,MAAK,CAAC,MAClD,eAAgB,WAAK,KAAK,CAAC,CAAC;AAAA,IACjC;AAAA,EACF;AACF;;;AJxJO,SAAS,WACd,QACA,eAGI,CAAC,GACY;AACjB,QAAM,YAAY,IAAI,UAAU,YAAY;AAC5C,QAAM,OAAO,IAAI,KAAK,SAAS;AAC/B,OAAK,WAAW;AAEhB,SAAO;AACT;",
  "names": ["fs", "path", "fs", "path"]
}


package/dist/next/agents.mjs

@@ -0,0 +1,137 @@
+import {
+  Framework
+} from "../chunk-DO4HKPHR.mjs";
+import "../chunk-BJTO5JO5.mjs";
+
+// src/framework-next/next.ts
+import * as fs from "fs";
+import * as path from "path";
+var Next = class {
+  constructor(framework) {
+    this.framework = framework;
+  }
+  get appDir() {
+    const cwd = this.framework.cwd;
+    const srcAppDir = path.join(cwd, "src", "app");
+    const rootAppDir = path.join(cwd, "app");
+    if (this.hasAppLayout(srcAppDir)) {
+      return "src/app";
+    }
+    if (this.hasAppLayout(rootAppDir)) {
+      return "app";
+    }
+    if (fs.existsSync(srcAppDir)) {
+      return "src/app";
+    }
+    return "app";
+  }
+  generateNextRouteHandlerSource(opts) {
+    return `// Auto-generated by withAgents - do not edit
+// @ts-nocheck
+// biome-ignore format, lint, lint/style, lint/suspicious, lint/complexity, lint/performance, lint/security, lint/correctness, lint/strict
+// prettier-ignore
+
+import { runtime } from "experimental-agent/framework-runtime";
+import { handleRequest } from "experimental-agent";
+import { agents } from ${JSON.stringify(opts.registryImportPath)};
+
+async function workflow(agent, sessionId, ...args) {
+  "use workflow";
+  return agent.session(sessionId).send(...args);
+}
+
+async function handler(
+  req: Request,
+  ctx: { params: Promise<{ agent: string; path?: string[] }> }
+) {
+  const params = await ctx.params;
+  const name = params.agent;
+  const instance = await runtime.resolveAgent({ name, agents });
+
+  if (!instance) {
+    const available = Object.keys(agents).join(", ");
+    const body =
+      \`Agent "\${name}" not found.\\n\\n\` +
+      \`Available agents: \${available}\\n\\n\` +
+      \`hint: each folder inside agents/ becomes an agent.\\n\` +
+      \`      Create agents/\${name}/ to add this agent.\\n\`;
+    return new Response(body, { status: 404 });
+  }
+
+  return handleRequest(instance, { basePath: \`/.well-known/agents/\${name}\`, workflow }).fetch(req);
+}
+
+export const GET = handler;
+export const POST = handler;
+`;
+  }
+  /**
+   * Pure codegen step: scan agents and return the generated source
+   * strings without touching the filesystem. Useful for adapters that
+   * need to control where and how files are written.
+   *
+   * Returns `null` when no agents are found.
+   */
+  filesToWrite() {
+    const agents = this.framework.discoverAgents();
+    if (agents.length === 0) {
+      return null;
+    }
+    this.framework.log(
+      "discovered agents:",
+      agents.map((a) => a.name)
+    );
+    const dir = path.join(
+      this.framework.cwd,
+      this.appDir,
+      ".well-known",
+      "agents",
+      "[agent]",
+      "[[...path]]"
+    );
+    const registrySource = this.framework.generateRegistrySource({
+      agents,
+      outputDir: dir
+    });
+    const routeSource = this.generateNextRouteHandlerSource({
+      registryImportPath: "./_registry"
+    });
+    return { registrySource, routeSource, dir };
+  }
+  /**
+   * Scan for agents, generate source, and write the `_registry.ts` and
+   * `route.ts` files into the Next.js app directory.
+   */
+  writeFiles() {
+    const filesToWrite = this.filesToWrite();
+    if (!filesToWrite) {
+      console.warn("[withAgents] No agents found");
+      return;
+    }
+    const { registrySource, routeSource, dir } = filesToWrite;
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, "_registry.ts"), registrySource);
+    fs.writeFileSync(path.join(dir, "route.ts"), routeSource);
+    const gitignorePath = path.join(dir, ".gitignore");
+    if (!fs.existsSync(gitignorePath)) {
+      fs.writeFileSync(gitignorePath, "*\n");
+    }
+  }
+  hasAppLayout(dir) {
+    return ["layout.tsx", "layout.js", "layout.jsx"].some(
+      (f) => fs.existsSync(path.join(dir, f))
+    );
+  }
+};
+
+// src/framework-next/agents-plugin.ts
+function withAgents(config, agentsConfig = {}) {
+  const framework = new Framework(agentsConfig);
+  const next = new Next(framework);
+  next.writeFiles();
+  return config;
+}
+export {
+  withAgents
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/framework-next/next.ts", "../../src/framework-next/agents-plugin.ts"],
  "sourcesContent": ["import * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport type { NextConfig } from \"next\";\nimport type { Framework } from \"../framework/framework\";\n\n/** A Next.js config object or async config function. */\nexport type NextConfigInput =\n  | NextConfig\n  | ((\n      phase: string,\n      ctx: { defaultConfig: NextConfig }\n    ) => Promise<NextConfig>);\n\n/** Options for {@link withAgents}. */\nexport type WithAgentsConfig = {\n  /**\n   * Path to the agents directory, relative to the project root.\n   * When omitted, auto-detected as the first existing directory\n   * among `src/agents` and `agents`.\n   */\n  agentsDir?: string;\n  /** Enable verbose logging to stdout. */\n  debug?: boolean;\n};\n\n/**\n * Next.js adapter for filesystem-based agent routing.\n *\n * Receives a {@link Framework} instance (composition) and uses it to\n * discover agents, generate a registry, and write the Next.js route\n * handler files that serve them.\n *\n * Most users should use the {@link withAgents} helper instead of\n * constructing this class directly.\n *\n * @example\n * ```ts\n * import { Framework } from \"experimental-agent/framework\";\n * import { Next } from \"experimental-agent/next/agents\";\n *\n * const framework = new Framework({ cwd: process.cwd() });\n * new Next(framework).generate();\n * ```\n */\nexport class Next {\n  constructor(private readonly framework: Framework) {}\n\n  private get appDir(): string {\n    const cwd = this.framework.cwd;\n    const srcAppDir = path.join(cwd, \"src\", \"app\");\n    const rootAppDir = path.join(cwd, \"app\");\n\n    if (this.hasAppLayout(srcAppDir)) {\n      return \"src/app\";\n    }\n    if (this.hasAppLayout(rootAppDir)) {\n      return \"app\";\n    }\n    if (fs.existsSync(srcAppDir)) {\n      return \"src/app\";\n    }\n    return \"app\";\n  }\n\n  generateNextRouteHandlerSource(opts: { registryImportPath: string }): string {\n    return `// Auto-generated by withAgents - do not edit\n// @ts-nocheck\n// biome-ignore format, lint, lint/style, lint/suspicious, lint/complexity, lint/performance, lint/security, lint/correctness, lint/strict\n// prettier-ignore\n\nimport { runtime } from \"experimental-agent/framework-runtime\";\nimport { handleRequest } from \"experimental-agent\";\nimport { agents } from ${JSON.stringify(opts.registryImportPath)};\n\nasync function workflow(agent, sessionId, ...args) {\n  \"use workflow\";\n  return agent.session(sessionId).send(...args);\n}\n\nasync function handler(\n  req: Request,\n  ctx: { params: Promise<{ agent: string; path?: string[] }> }\n) {\n  const params = await ctx.params;\n  const name = params.agent;\n  const instance = await runtime.resolveAgent({ name, agents });\n\n  if (!instance) {\n    const available = Object.keys(agents).join(\", \");\n    const body =\n      \\`Agent \"\\${name}\" not found.\\\\n\\\\n\\` +\n      \\`Available agents: \\${available}\\\\n\\\\n\\` +\n      \\`hint: each folder inside agents/ becomes an agent.\\\\n\\` +\n      \\`      Create agents/\\${name}/ to add this agent.\\\\n\\`;\n    return new Response(body, { status: 404 });\n  }\n\n  return handleRequest(instance, { basePath: \\`/.well-known/agents/\\${name}\\`, workflow }).fetch(req);\n}\n\nexport const GET = handler;\nexport const POST = handler;\n`;\n  }\n\n  /**\n   * Pure codegen step: scan agents and return the generated source\n   * strings without touching the filesystem. Useful for adapters that\n   * need to control where and how files are written.\n   *\n   * Returns `null` when no agents are found.\n   */\n  filesToWrite(): {\n    registrySource: string;\n    routeSource: string;\n    dir: string;\n  } | null {\n    const agents = this.framework.discoverAgents();\n\n    if (agents.length === 0) {\n      return null;\n    }\n\n    this.framework.log(\n      \"discovered agents:\",\n      agents.map((a) => a.name)\n    );\n\n    const dir = path.join(\n      this.framework.cwd,\n      this.appDir,\n      \".well-known\",\n      \"agents\",\n      \"[agent]\",\n      \"[[...path]]\"\n    );\n\n    const registrySource = this.framework.generateRegistrySource({\n      agents,\n      outputDir: dir,\n    });\n    const routeSource = this.generateNextRouteHandlerSource({\n      registryImportPath: \"./_registry\",\n    });\n\n    return { registrySource, routeSource, dir };\n  }\n\n  /**\n   * Scan for agents, generate source, and write the `_registry.ts` and\n   * `route.ts` files into the Next.js app directory.\n   */\n  writeFiles(): void {\n    const filesToWrite = this.filesToWrite();\n\n    if (!filesToWrite) {\n      console.warn(\"[withAgents] No agents found\");\n      return;\n    }\n\n    const { registrySource, routeSource, dir } = filesToWrite;\n\n    fs.mkdirSync(dir, { recursive: true });\n    fs.writeFileSync(path.join(dir, \"_registry.ts\"), registrySource);\n    fs.writeFileSync(path.join(dir, \"route.ts\"), routeSource);\n\n    const gitignorePath = path.join(dir, \".gitignore\");\n    if (!fs.existsSync(gitignorePath)) {\n      fs.writeFileSync(gitignorePath, \"*\\n\");\n    }\n  }\n\n  private hasAppLayout(dir: string): boolean {\n    return [\"layout.tsx\", \"layout.js\", \"layout.jsx\"].some((f) =>\n      fs.existsSync(path.join(dir, f))\n    );\n  }\n}\n", "import { Framework } from \"../framework/framework\";\nimport { Next, type NextConfigInput } from \"./next\";\n\nexport type { NextConfigInput, WithAgentsConfig } from \"./next\";\n\n/**\n * Next.js config wrapper that discovers agents on the filesystem and\n * generates the route handler + registry files needed to serve them.\n *\n * Call this in `next.config.ts`:\n *\n * @example\n * ```ts\n * import { withAgents } from \"experimental-agent/next/agents\";\n *\n * export default withAgents({ reactStrictMode: true });\n * ```\n *\n * Debug logs:\n * ```ts\n * import { withAgents } from \"experimental-agent/next/agents\";\n *\n * export default withAgents({ reactStrictMode: true }, { debug: true });\n * ```\n */\nexport function withAgents(\n  config: NextConfigInput,\n  agentsConfig: Pick<\n    ConstructorParameters<typeof Framework>[0],\n    \"agentsDir\" | \"debug\"\n  > = {}\n): NextConfigInput {\n  const framework = new Framework(agentsConfig);\n  const next = new Next(framework);\n  next.writeFiles();\n\n  return config;\n}\n"],
  "mappings": ";;;;;;AAAA,YAAY,QAAQ;AACpB,YAAY,UAAU;AA2Cf,IAAM,OAAN,MAAW;AAAA,EAChB,YAA6B,WAAsB;AAAtB;AAAA,EAAuB;AAAA,EAEpD,IAAY,SAAiB;AAC3B,UAAM,MAAM,KAAK,UAAU;AAC3B,UAAM,YAAiB,UAAK,KAAK,OAAO,KAAK;AAC7C,UAAM,aAAkB,UAAK,KAAK,KAAK;AAEvC,QAAI,KAAK,aAAa,SAAS,GAAG;AAChC,aAAO;AAAA,IACT;AACA,QAAI,KAAK,aAAa,UAAU,GAAG;AACjC,aAAO;AAAA,IACT;AACA,QAAO,cAAW,SAAS,GAAG;AAC5B,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AAAA,EAEA,+BAA+B,MAA8C;AAC3E,WAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yBAOc,KAAK,UAAU,KAAK,kBAAkB,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA+B9D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,eAIS;AACP,UAAM,SAAS,KAAK,UAAU,eAAe;AAE7C,QAAI,OAAO,WAAW,GAAG;AACvB,aAAO;AAAA,IACT;AAEA,SAAK,UAAU;AAAA,MACb;AAAA,MACA,OAAO,IAAI,CAAC,MAAM,EAAE,IAAI;AAAA,IAC1B;AAEA,UAAM,MAAW;AAAA,MACf,KAAK,UAAU;AAAA,MACf,KAAK;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAEA,UAAM,iBAAiB,KAAK,UAAU,uBAAuB;AAAA,MAC3D;AAAA,MACA,WAAW;AAAA,IACb,CAAC;AACD,UAAM,cAAc,KAAK,+BAA+B;AAAA,MACtD,oBAAoB;AAAA,IACtB,CAAC;AAED,WAAO,EAAE,gBAAgB,aAAa,IAAI;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,aAAmB;AACjB,UAAM,eAAe,KAAK,aAAa;AAEvC,QAAI,CAAC,cAAc;AACjB,cAAQ,KAAK,8BAA8B;AAC3C;AAAA,IACF;AAEA,UAAM,EAAE,gBAAgB,aAAa,IAAI,IAAI;AAE7C,IAAG,aAAU,KAAK,EAAE,WAAW,KAAK,CAAC;AACrC,IAAG,iBAAmB,UAAK,KAAK,cAAc,GAAG,cAAc;AAC/D,IAAG,iBAAmB,UAAK,KAAK,UAAU,GAAG,WAAW;AAExD,UAAM,gBAAqB,UAAK,KAAK,YAAY;AACjD,QAAI,CAAI,cAAW,aAAa,GAAG;AACjC,MAAG,iBAAc,eAAe,KAAK;AAAA,IACvC;AAAA,EACF;AAAA,EAEQ,aAAa,KAAsB;AACzC,WAAO,CAAC,cAAc,aAAa,YAAY,EAAE;AAAA,MAAK,CAAC,MAClD,cAAgB,UAAK,KAAK,CAAC,CAAC;AAAA,IACjC;AAAA,EACF;AACF;;;ACxJO,SAAS,WACd,QACA,eAGI,CAAC,GACY;AACjB,QAAM,YAAY,IAAI,UAAU,YAAY;AAC5C,QAAM,OAAO,IAAI,KAAK,SAAS;AAC/B,OAAK,WAAW;AAEhB,SAAO;AACT;",
  "names": []
}
