@standardagents/cli 0.10.1-next.bbd142a → 0.11.0-next.14455ae

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import fs, { readFileSync } from 'fs';
-import path, { dirname, resolve } from 'path';
+import fs3, { readFileSync } from 'fs';
+import path3, { dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import crypto from 'crypto';
 import readline from 'readline';
@@ -10,6 +10,7 @@ import chalk from 'chalk';
 import { parse, modify, applyEdits } from 'jsonc-parser';
 import { loadFile, writeFile, generateCode } from 'magicast';
 import { addVitePlugin } from 'magicast/helpers';
+import net from 'net';
 
 var logger = {
   success: (message) => {
@@ -115,30 +116,32 @@ agents/
 
 Files are **auto-discovered** at runtime. No manual registration needed.
 
-## FlowState
+## ThreadState
 
-\`FlowState\` is the central state object available in tools and hooks:
+\`ThreadState\` is the state object available in tools and hooks:
 
 \`\`\`typescript
-interface FlowState {
-  thread: {
-    id: string;           // Thread identifier
-    instance: DurableThread;  // Durable Object instance
-  };
-  agent: AgentConfig;     // Current agent configuration
-  prompt: PromptConfig;   // Current prompt configuration
-  model: ModelConfig;     // Current model configuration
-  messages: Message[];    // Conversation history
-  env: Env;               // Cloudflare Worker environment
-  rootState: FlowState;   // Parent state (for sub-prompts)
+interface ThreadState {
+  // Identity (readonly)
+  threadId: string;           // Thread identifier
+  agentId: string;            // Agent identifier
+  userId: string | null;      // User identifier (if set)
+  createdAt: number;          // Creation timestamp
+
+  // Methods
+  getMessages(options?): Promise<MessagesResult>;  // Get conversation history
+  injectMessage(input): Promise<Message>;          // Add message to thread
+  loadModel(name): Promise<ModelConfig>;           // Load model definition
+  loadPrompt(name): Promise<PromptConfig>;         // Load prompt definition
+  loadAgent(name): Promise<AgentConfig>;           // Load agent definition
 }
 \`\`\`
 
 Access in tools:
 \`\`\`typescript
 export default defineTool('...', schema, async (flow, args) => {
-  const threadId = flow.thread.id;
-  const messages = flow.messages;
+  const threadId = flow.threadId;
+  const { messages } = await flow.getMessages();
   // ...
 });
 \`\`\`
@@ -205,15 +208,24 @@ Models define which LLM provider and model to use for prompts.
 import { defineModel } from '@standardagents/builder';
 
 export default defineModel({
-  name: 'gpt-4o',
-  provider: 'openai',
-  model: 'gpt-4o',
-  fallbacks: ['gpt-4-turbo', 'gpt-3.5-turbo'],
-  inputPrice: 2.5,
-  outputPrice: 10,
+  name: 'default',
+  provider: 'openrouter',
+  model: 'google/gemini-3-flash-preview',
+  fallbacks: ['fast', 'cheap-heavy'],
 });
 \`\`\`
 
+## Recommended Models (OpenRouter)
+
+| Use Case | Model ID | Description |
+|----------|----------|-------------|
+| Fast/Cheap | \`z-ai/glm-4.5-air\` | Quick responses, low cost |
+| Mid-tier | \`google/gemini-3-flash-preview\` | Good balance of speed and quality |
+| Cheap Heavy | \`z-ai/glm-4.7\` | More capable, still affordable |
+| Heavy | \`google/gemini-3-pro-preview\` | Most capable, for complex tasks |
+
+**\u26A0\uFE0F Google Models**: When using Google models (\`google/gemini-*\`), you must enable \`reasoning\` in your prompt configuration or tool calls will fail. See the prompts CLAUDE.md for details.
+
 ## Provider API Keys
 
 Set these environment variables in \`.dev.vars\` (local) or Cloudflare secrets (production):
@@ -241,16 +253,16 @@ For OpenRouter, use the full model path:
 
 \`\`\`typescript
 export default defineModel({
-  name: 'claude-3-opus',
+  name: 'heavy',
   provider: 'openrouter',
-  model: 'anthropic/claude-3-opus',
-  includedProviders: ['anthropic'],  // Prefer Anthropic's servers
+  model: 'google/gemini-3-pro-preview',
+  includedProviders: ['google'],  // Prefer Google's servers
 });
 \`\`\`
 
 ## Best Practices
 
-- **Name by use case**, not model ID (e.g., \`fast_reasoning\` not \`gpt-4o-mini\`)
+- **Name by use case**, not model ID (e.g., \`fast\`, \`default\`, \`heavy\`)
 - **Configure fallbacks** for production reliability
 - **Set pricing** for cost tracking in logs
 - **Use environment variables** for API keys, never hardcode
@@ -273,15 +285,12 @@ Prompts define system instructions, model selection, and available tools for LLM
 | \`toolDescription\` | \`string\` | Yes | Description shown when used as a tool |
 | \`prompt\` | \`string \\| StructuredPrompt\` | Yes | System instructions |
 | \`model\` | \`string\` | Yes | Model name to use (references \`agents/models/\`) |
-| \`tools\` | \`(string \\| ToolConfig)[]\` | No | Available tools for LLM |
-| \`handoffAgents\` | \`string[]\` | No | Agents this prompt can hand off to |
+| \`tools\` | \`(string \\| ToolConfig)[]\` | No | Available tools (include ai_human agent names for handoffs) |
 | \`includeChat\` | \`boolean\` | No | Include full conversation history |
 | \`includePastTools\` | \`boolean\` | No | Include previous tool results |
 | \`parallelToolCalls\` | \`boolean\` | No | Allow multiple concurrent tool calls |
 | \`toolChoice\` | \`'auto' \\| 'none' \\| 'required'\` | No | Tool calling strategy |
 | \`requiredSchema\` | \`z.ZodObject\` | No | Input validation when called as tool |
-| \`beforeTool\` | \`string\` | No | Tool to run before LLM request |
-| \`afterTool\` | \`string\` | No | Tool to run after LLM response |
 | \`reasoning\` | \`ReasoningConfig\` | No | Extended thinking configuration |
 
 ## Basic Example
@@ -292,7 +301,7 @@ import { definePrompt } from '@standardagents/builder';
 export default definePrompt({
   name: 'customer_support',
   toolDescription: 'Handle customer support inquiries',
-  model: 'gpt-4o',
+  model: 'default',
   prompt: \`You are a helpful customer support agent.
 Always be polite and professional.
 If you cannot help, escalate to a human.\`,
@@ -309,7 +318,7 @@ Include other prompts for reusable instruction blocks:
 export default definePrompt({
   name: 'main_assistant',
   toolDescription: 'Primary assistant',
-  model: 'gpt-4o',
+  model: 'default',
   prompt: [
     { type: 'text', content: 'You are a helpful assistant.\\n\\n' },
     { type: 'include', prompt: 'common_rules' },  // Includes another prompt
@@ -345,7 +354,7 @@ import { z } from 'zod';
 export default definePrompt({
   name: 'data_extractor',
   toolDescription: 'Extract structured data from text',
-  model: 'gpt-4o',
+  model: 'default',
   prompt: 'Extract the requested data from the input.',
   requiredSchema: z.object({
     text: z.string().describe('Text to extract from'),
@@ -362,7 +371,7 @@ Enable for complex reasoning tasks:
 export default definePrompt({
   name: 'code_reviewer',
   toolDescription: 'Review code for issues',
-  model: 'claude-3-opus',
+  model: 'heavy',
   prompt: 'Review the code thoroughly...',
   reasoning: {
     effort: 'high',      // 'low' | 'medium' | 'high'
@@ -372,6 +381,14 @@ export default definePrompt({
 });
 \`\`\`
 
+**\u26A0\uFE0F Google Models Require Reasoning**: When using Google models (\`google/gemini-*\`) via OpenRouter, you **must** include \`reasoning\` configuration or tool calls will fail. At minimum:
+
+\`\`\`typescript
+reasoning: {
+  effort: 'low',  // Can be 'low', 'medium', or 'high'
+},
+\`\`\`
+
 ## Best Practices
 
 - **Write clear instructions** - Structure with headers and bullet points
@@ -473,7 +490,7 @@ export default defineAgent({
 });
 \`\`\`
 
-Other prompts can then include it in their \`handoffAgents\` array.
+Other prompts can then include the agent name in their \`tools\` array to enable handoffs.
 
 ## Stop Conditions (Priority Order)
 
@@ -483,9 +500,15 @@ Other prompts can then include it in their \`handoffAgents\` array.
 4. **stopOnResponse** - Ends turn when LLM returns text
 5. **maxSessionTurns** - Ends conversation (hard limit: 250)
 
+## Naming Convention
+
+Agent names **must** end with the \`_agent\` suffix (e.g., \`support_agent\`, \`research_agent\`).
+This convention is enforced by the builder UI and makes agents easily identifiable in logs and code.
+
 ## Best Practices
 
 - **Use descriptive names** (\`customer_support_agent\` not \`agent1\`)
+- **Always use the _agent suffix** - names like \`support_agent\`, \`research_agent\`
 - **Always set maxTurns** as a safety limit
 - **Match stop conditions to use case** - chat apps use stopOnResponse, workflows use stopTool
 - **Use labels** for clarity in logs and UI
@@ -504,12 +527,12 @@ Tools extend agent capabilities beyond text generation. They allow LLMs to fetch
 ## Function Signature
 
 \`\`\`typescript
-defineTool(
+defineTool({
   description: string,           // What the tool does (shown to LLM)
-  args: z.ZodObject,             // Input validation schema
-  handler: (flow, args) => ToolResult,  // Implementation
-  returnSchema?: z.ZodObject     // Optional output schema
-)
+  args?: z.ZodObject,            // Input validation schema (optional)
+  execute: (state, args) => ToolResult,  // Implementation
+  tenvs?: z.ZodObject,           // Thread environment variables (optional)
+})
 \`\`\`
 
 ## Basic Example
@@ -518,20 +541,20 @@ defineTool(
 import { defineTool } from '@standardagents/builder';
 import { z } from 'zod';
 
-export default defineTool(
-  'Search the knowledge base for articles matching a query',
-  z.object({
+export default defineTool({
+  description: 'Search the knowledge base for articles matching a query',
+  args: z.object({
     query: z.string().describe('Search query'),
     limit: z.number().optional().default(10).describe('Max results'),
   }),
-  async (flow, args) => {
+  execute: async (state, args) => {
     const results = await searchKB(args.query, args.limit);
     return {
       status: 'success',
       result: JSON.stringify(results),
     };
-  }
-);
+  },
+});
 \`\`\`
 
 ## ToolResult Interface
@@ -541,44 +564,45 @@ export default defineTool(
 | \`status\` | \`'success' \\| 'error'\` | Whether the tool succeeded |
 | \`result\` | \`string\` | Tool output (required for success) |
 | \`error\` | \`string\` | Error message (for error status) |
+| \`attachments\` | \`ToolAttachment[]\` | Files to attach (images, etc.) |
 
-## FlowState Access
+## ThreadState Access
 
-The \`flow\` parameter provides access to:
+The \`state\` parameter provides access to:
 
 \`\`\`typescript
-async (flow, args) => {
+execute: async (state, args) => {
   // Thread information
-  const threadId = flow.thread.id;
-  const thread = flow.thread.instance;
+  const threadId = state.thread.id;
+  const thread = state.thread.instance;
 
   // Configuration
-  const agentName = flow.agent.name;
-  const modelName = flow.model.name;
+  const agentName = state.agent.name;
+  const modelName = state.model.name;
 
   // Message history
-  const messages = flow.messages;
+  const messages = state.messages;
 
   // Environment bindings
-  const env = flow.env;
+  const env = state.env;
 
   // Parent state (for sub-prompts)
-  const root = flow.rootState;
+  const root = state.rootState;
 }
 \`\`\`
 
 ## Tool Without Arguments
 
 \`\`\`typescript
-export default defineTool(
-  'Get current server time',
-  async (flow) => {
+export default defineTool({
+  description: 'Get current server time',
+  execute: async (state) => {
     return {
       status: 'success',
       result: new Date().toISOString(),
     };
-  }
-);
+  },
+});
 \`\`\`
 
 ## Error Handling
@@ -586,10 +610,10 @@ export default defineTool(
 Return errors gracefully instead of throwing:
 
 \`\`\`typescript
-export default defineTool(
-  'Fetch user data',
-  z.object({ userId: z.string() }),
-  async (flow, args) => {
+export default defineTool({
+  description: 'Fetch user data',
+  args: z.object({ userId: z.string() }),
+  execute: async (state, args) => {
     try {
       const user = await fetchUser(args.userId);
       return { status: 'success', result: JSON.stringify(user) };
@@ -599,8 +623,8 @@ export default defineTool(
         error: \`Failed to fetch user: \${error.message}\`,
       };
     }
-  }
-);
+  },
+});
 \`\`\`
 
 ## Queueing Additional Tools
@@ -610,21 +634,21 @@ Queue another tool to run after the current one:
 \`\`\`typescript
 import { queueTool } from '@standardagents/builder';
 
-export default defineTool(
-  'Create order and send confirmation',
-  z.object({ items: z.array(z.string()) }),
-  async (flow, args) => {
+export default defineTool({
+  description: 'Create order and send confirmation',
+  args: z.object({ items: z.array(z.string()) }),
+  execute: async (state, args) => {
     const order = await createOrder(args.items);
 
     // Queue email tool to run next
-    queueTool(flow, 'send_confirmation_email', {
+    queueTool(state, 'send_confirmation_email', {
       orderId: order.id,
-      email: flow.thread.metadata.userEmail,
+      email: state.thread.metadata.userEmail,
     });
 
     return { status: 'success', result: JSON.stringify(order) };
-  }
-);
+  },
+});
 \`\`\`
 
 ## Injecting Messages
@@ -634,17 +658,61 @@ Add messages without triggering re-execution:
 \`\`\`typescript
 import { injectMessage } from '@standardagents/builder';
 
-export default defineTool(
-  'Log audit event',
-  z.object({ event: z.string() }),
-  async (flow, args) => {
-    await injectMessage(flow, {
+export default defineTool({
+  description: 'Log audit event',
+  args: z.object({ event: z.string() }),
+  execute: async (state, args) => {
+    await injectMessage(state, {
       role: 'system',
       content: \`[AUDIT] \${args.event}\`,
     });
     return { status: 'success', result: 'Logged' };
-  }
-);
+  },
+});
+\`\`\`
+
+## Thread Environment Variables (tenvs)
+
+Tools can declare required thread environment variables:
+
+\`\`\`typescript
+export default defineTool({
+  description: 'Search uploaded documents',
+  args: z.object({ query: z.string() }),
+  execute: async (state, args) => {
+    const vectorStoreId = state.tenvs.vectorStoreId;
+    const results = await searchVectorStore(vectorStoreId, args.query);
+    return { status: 'success', result: JSON.stringify(results) };
+  },
+  tenvs: z.object({
+    vectorStoreId: z.string().describe('OpenAI Vector Store ID'),
+  }),
+});
+\`\`\`
+
+## Returning Attachments
+
+Tools can return file attachments (e.g., generated images):
+
+\`\`\`typescript
+export default defineTool({
+  description: 'Generate a chart from data',
+  args: z.object({ data: z.array(z.number()) }),
+  execute: async (state, args) => {
+    const chartImage = await generateChart(args.data);
+    return {
+      status: 'success',
+      result: 'Chart generated successfully',
+      attachments: [{
+        name: 'chart.png',
+        mimeType: 'image/png',
+        data: chartImage.base64,
+        width: 800,
+        height: 600,
+      }],
+    };
+  },
+});
 \`\`\`
 
 ## Best Practices
@@ -654,7 +722,7 @@ export default defineTool(
 - **Handle errors gracefully** - return error status, don't throw
 - **Use snake_case** for file names (\`search_knowledge_base.ts\`)
 - **Keep tools focused** - one task per tool
-- **Use \`flow.rootState\`** when queueing from sub-prompts
+- **Use \`state.rootState\`** when queueing from sub-prompts
 
 ## Supported Zod Types
 
@@ -958,17 +1026,19 @@ Full reference: https://docs.standardagentbuilder.com/core-concepts/api
 `;
 
 // src/commands/scaffold.ts
-var WRANGLER_TEMPLATE = (name) => `{
+var WRANGLER_TEMPLATE = (name) => {
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return `{
   "$schema": "node_modules/wrangler/config-schema.json",
   "name": "${name}",
   "main": "worker/index.ts",
-  "compatibility_date": "2025-01-01",
+  "compatibility_date": "${today}",
   "compatibility_flags": ["nodejs_compat"],
   "observability": {
     "enabled": true
   },
   "assets": {
-    "directory": "dist",
+    "directory": "dist/client",
     "not_found_handling": "single-page-application",
     "binding": "ASSETS",
     "run_worker_first": ["/**"]
@@ -997,6 +1067,7 @@ var WRANGLER_TEMPLATE = (name) => `{
   ]
 }
 `;
+};
 var THREAD_TS = `import { DurableThread } from 'virtual:@standardagents/builder'
 
 export default class Thread extends DurableThread {}
@@ -1019,23 +1090,23 @@ export default {
 export { DurableThread, DurableAgentBuilder }
 `;
 function getProjectName(cwd) {
-  const packageJsonPath = path.join(cwd, "package.json");
-  if (fs.existsSync(packageJsonPath)) {
+  const packageJsonPath = path3.join(cwd, "package.json");
+  if (fs3.existsSync(packageJsonPath)) {
     try {
-      const pkg2 = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+      const pkg2 = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
       if (pkg2.name) {
         return pkg2.name.replace(/^@[^/]+\//, "");
       }
     } catch {
     }
   }
-  return path.basename(cwd);
+  return path3.basename(cwd);
 }
 function findViteConfig(cwd) {
   const candidates = ["vite.config.ts", "vite.config.js", "vite.config.mts", "vite.config.mjs"];
   for (const candidate of candidates) {
-    const configPath = path.join(cwd, candidate);
-    if (fs.existsSync(configPath)) {
+    const configPath = path3.join(cwd, candidate);
+    if (fs3.existsSync(configPath)) {
       return configPath;
     }
   }
@@ -1044,8 +1115,8 @@ function findViteConfig(cwd) {
 function findWranglerConfig(cwd) {
   const candidates = ["wrangler.jsonc", "wrangler.json"];
   for (const candidate of candidates) {
-    const configPath = path.join(cwd, candidate);
-    if (fs.existsSync(configPath)) {
+    const configPath = path3.join(cwd, candidate);
+    if (fs3.existsSync(configPath)) {
       return configPath;
     }
   }
@@ -1054,21 +1125,13 @@ function findWranglerConfig(cwd) {
 async function modifyViteConfig(configPath, force) {
   try {
     const mod = await loadFile(configPath);
-    const code = fs.readFileSync(configPath, "utf-8");
+    const code = fs3.readFileSync(configPath, "utf-8");
     const hasCloudflare = code.includes("@cloudflare/vite-plugin") || code.includes("cloudflare()");
     const hasAgentBuilder = code.includes("@standardagents/builder") || code.includes("agentbuilder()");
     if (hasCloudflare && hasAgentBuilder && !force) {
       logger.info("Vite config already includes Standard Agents plugins");
       return true;
     }
-    if (!hasCloudflare || force) {
-      addVitePlugin(mod, {
-        from: "@cloudflare/vite-plugin",
-        imported: "cloudflare",
-        constructor: "cloudflare"
-      });
-      logger.success("Added cloudflare plugin to vite.config");
-    }
     if (!hasAgentBuilder || force) {
       addVitePlugin(mod, {
         from: "@standardagents/builder",
@@ -1078,6 +1141,14 @@ async function modifyViteConfig(configPath, force) {
       });
       logger.success("Added agentbuilder plugin to vite.config");
     }
+    if (!hasCloudflare || force) {
+      addVitePlugin(mod, {
+        from: "@cloudflare/vite-plugin",
+        imported: "cloudflare",
+        constructor: "cloudflare"
+      });
+      logger.success("Added cloudflare plugin to vite.config");
+    }
     await writeFile(mod, configPath);
     return true;
   } catch (error) {
@@ -1085,10 +1156,10 @@ async function modifyViteConfig(configPath, force) {
     logger.log("");
     logger.log("Please manually add the following to your vite.config.ts:");
     logger.log("");
-    logger.log(`  import { cloudflare } from '@cloudflare/vite-plugin'`);
     logger.log(`  import { agentbuilder } from '@standardagents/builder'`);
+    logger.log(`  import { cloudflare } from '@cloudflare/vite-plugin'`);
     logger.log("");
-    logger.log(`  plugins: [cloudflare(), agentbuilder({ mountPoint: '/' })]`);
+    logger.log(`  plugins: [agentbuilder({ mountPoint: '/' }), cloudflare()]`);
     logger.log("");
     return false;
   }
@@ -1097,7 +1168,7 @@ function createOrUpdateWranglerConfig(cwd, projectName, force) {
   const existingConfig = findWranglerConfig(cwd);
   if (existingConfig && !force) {
     try {
-      const text = fs.readFileSync(existingConfig, "utf-8");
+      const text = fs3.readFileSync(existingConfig, "utf-8");
       const config = parse(text);
       const hasBindings = config.durable_objects?.bindings?.some(
         (b) => b.name === "AGENT_BUILDER_THREAD" || b.name === "AGENT_BUILDER"
@@ -1137,14 +1208,14 @@ function createOrUpdateWranglerConfig(cwd, projectName, force) {
       }
       if (!config.assets) {
         const edits = modify(result, ["assets"], {
-          directory: "dist",
+          directory: "dist/client",
           not_found_handling: "single-page-application",
           binding: "ASSETS",
           run_worker_first: ["/**"]
         }, {});
         result = applyEdits(result, edits);
       }
-      fs.writeFileSync(existingConfig, result, "utf-8");
+      fs3.writeFileSync(existingConfig, result, "utf-8");
       logger.success("Updated wrangler.jsonc with Standard Agents configuration");
       return true;
     } catch (error) {
@@ -1152,9 +1223,9 @@ function createOrUpdateWranglerConfig(cwd, projectName, force) {
       return false;
     }
   }
-  const wranglerPath = path.join(cwd, "wrangler.jsonc");
+  const wranglerPath = path3.join(cwd, "wrangler.jsonc");
   const sanitizedName = projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
-  fs.writeFileSync(wranglerPath, WRANGLER_TEMPLATE(sanitizedName), "utf-8");
+  fs3.writeFileSync(wranglerPath, WRANGLER_TEMPLATE(sanitizedName), "utf-8");
   logger.success("Created wrangler.jsonc");
   return true;
 }
@@ -1162,33 +1233,33 @@ function getWorkerEntryPoint(cwd) {
   const wranglerConfig = findWranglerConfig(cwd);
   if (wranglerConfig) {
     try {
-      const text = fs.readFileSync(wranglerConfig, "utf-8");
+      const text = fs3.readFileSync(wranglerConfig, "utf-8");
       const config = parse(text);
       if (config.main) {
-        return path.join(cwd, config.main);
+        return path3.join(cwd, config.main);
       }
     } catch {
     }
   }
-  return path.join(cwd, "worker", "index.ts");
+  return path3.join(cwd, "worker", "index.ts");
 }
 async function createOrUpdateWorkerEntry(cwd, force) {
   const entryPath = getWorkerEntryPoint(cwd);
-  const entryDir = path.dirname(entryPath);
-  if (!fs.existsSync(entryDir)) {
-    fs.mkdirSync(entryDir, { recursive: true });
-    logger.success(`Created ${path.relative(cwd, entryDir)} directory`);
+  const entryDir = path3.dirname(entryPath);
+  if (!fs3.existsSync(entryDir)) {
+    fs3.mkdirSync(entryDir, { recursive: true });
+    logger.success(`Created ${path3.relative(cwd, entryDir)} directory`);
   }
-  if (!fs.existsSync(entryPath)) {
-    fs.writeFileSync(entryPath, WORKER_INDEX, "utf-8");
-    logger.success(`Created ${path.relative(cwd, entryPath)}`);
+  if (!fs3.existsSync(entryPath)) {
+    fs3.writeFileSync(entryPath, WORKER_INDEX, "utf-8");
+    logger.success(`Created ${path3.relative(cwd, entryPath)}`);
     return true;
   }
-  const content = fs.readFileSync(entryPath, "utf-8");
+  const content = fs3.readFileSync(entryPath, "utf-8");
   const hasRouter = content.includes("virtual:@standardagents/builder") && content.includes("router");
   const hasDurableExports = content.includes("DurableThread") && content.includes("DurableAgentBuilder");
   if (hasRouter && hasDurableExports && !force) {
-    logger.info(`${path.relative(cwd, entryPath)} already configured`);
+    logger.info(`${path3.relative(cwd, entryPath)} already configured`);
     return true;
   }
   try {
@@ -1216,17 +1287,17 @@ async function createOrUpdateWorkerEntry(cwd, force) {
     }
     const { code } = generateCode(mod);
     if (force || !hasRouter) {
-      fs.writeFileSync(entryPath, WORKER_INDEX, "utf-8");
-      logger.success(`Updated ${path.relative(cwd, entryPath)} with Standard Agents router`);
+      fs3.writeFileSync(entryPath, WORKER_INDEX, "utf-8");
+      logger.success(`Updated ${path3.relative(cwd, entryPath)} with Standard Agents router`);
     }
     return true;
   } catch (error) {
     if (force) {
-      fs.writeFileSync(entryPath, WORKER_INDEX, "utf-8");
-      logger.success(`Created ${path.relative(cwd, entryPath)}`);
+      fs3.writeFileSync(entryPath, WORKER_INDEX, "utf-8");
+      logger.success(`Created ${path3.relative(cwd, entryPath)}`);
       return true;
     }
-    logger.warning(`Could not automatically modify ${path.relative(cwd, entryPath)}`);
+    logger.warning(`Could not automatically modify ${path3.relative(cwd, entryPath)}`);
     logger.log("");
     logger.log("Please ensure your worker entry point includes:");
     logger.log("");
@@ -1245,31 +1316,31 @@ async function createOrUpdateWorkerEntry(cwd, force) {
   }
 }
 function createDurableObjects(cwd) {
-  const agentsDir = path.join(cwd, "agents");
-  if (!fs.existsSync(agentsDir)) {
-    fs.mkdirSync(agentsDir, { recursive: true });
+  const agentsDir = path3.join(cwd, "agents");
+  if (!fs3.existsSync(agentsDir)) {
+    fs3.mkdirSync(agentsDir, { recursive: true });
   }
-  const threadPath = path.join(agentsDir, "Thread.ts");
-  if (!fs.existsSync(threadPath)) {
-    fs.writeFileSync(threadPath, THREAD_TS, "utf-8");
+  const threadPath = path3.join(agentsDir, "Thread.ts");
+  if (!fs3.existsSync(threadPath)) {
+    fs3.writeFileSync(threadPath, THREAD_TS, "utf-8");
     logger.success("Created agents/Thread.ts");
   } else {
     logger.info("agents/Thread.ts already exists");
   }
-  const agentBuilderPath = path.join(agentsDir, "AgentBuilder.ts");
-  if (!fs.existsSync(agentBuilderPath)) {
-    fs.writeFileSync(agentBuilderPath, AGENT_BUILDER_TS, "utf-8");
+  const agentBuilderPath = path3.join(agentsDir, "AgentBuilder.ts");
+  if (!fs3.existsSync(agentBuilderPath)) {
+    fs3.writeFileSync(agentBuilderPath, AGENT_BUILDER_TS, "utf-8");
     logger.success("Created agents/AgentBuilder.ts");
   } else {
     logger.info("agents/AgentBuilder.ts already exists");
   }
 }
 function createDirectoriesAndDocs(cwd) {
-  const agentsDir = path.join(cwd, "agents");
-  const rootDocPath = path.join(agentsDir, "CLAUDE.md");
-  if (!fs.existsSync(rootDocPath)) {
-    fs.writeFileSync(rootDocPath, ROOT_CLAUDE_MD, "utf-8");
-    logger.success("Created agents/CLAUDE.md");
+  path3.join(cwd, "agents");
+  const rootDocPath = path3.join(cwd, "CLAUDE.md");
+  if (!fs3.existsSync(rootDocPath)) {
+    fs3.writeFileSync(rootDocPath, ROOT_CLAUDE_MD, "utf-8");
+    logger.success("Created CLAUDE.md");
   }
   const directories = [
     { path: "agents/agents", doc: AGENTS_CLAUDE_MD },
@@ -1280,26 +1351,26 @@ function createDirectoriesAndDocs(cwd) {
     { path: "agents/api", doc: API_CLAUDE_MD }
   ];
   for (const dir of directories) {
-    const dirPath = path.join(cwd, dir.path);
-    const docPath = path.join(dirPath, "CLAUDE.md");
-    if (!fs.existsSync(dirPath)) {
-      fs.mkdirSync(dirPath, { recursive: true });
+    const dirPath = path3.join(cwd, dir.path);
+    const docPath = path3.join(dirPath, "CLAUDE.md");
+    if (!fs3.existsSync(dirPath)) {
+      fs3.mkdirSync(dirPath, { recursive: true });
       logger.success(`Created ${dir.path}`);
     }
-    if (!fs.existsSync(docPath)) {
-      fs.writeFileSync(docPath, dir.doc, "utf-8");
+    if (!fs3.existsSync(docPath)) {
+      fs3.writeFileSync(docPath, dir.doc, "utf-8");
       logger.success(`Created ${dir.path}/CLAUDE.md`);
     }
   }
 }
 function updateTsConfig(cwd) {
-  const tsconfigPath = path.join(cwd, "tsconfig.json");
-  if (!fs.existsSync(tsconfigPath)) {
+  const tsconfigPath = path3.join(cwd, "tsconfig.json");
+  if (!fs3.existsSync(tsconfigPath)) {
     logger.info("No tsconfig.json found, skipping TypeScript configuration");
     return;
   }
   try {
-    const text = fs.readFileSync(tsconfigPath, "utf-8");
+    const text = fs3.readFileSync(tsconfigPath, "utf-8");
     const config = parse(text);
     let result = text;
     const types = config.compilerOptions?.types || [];
@@ -1321,7 +1392,7 @@ function updateTsConfig(cwd) {
       result = applyEdits(result, edits);
     }
     if (newTypes.length > 0 || newIncludes.length > 0) {
-      fs.writeFileSync(tsconfigPath, result, "utf-8");
+      fs3.writeFileSync(tsconfigPath, result, "utf-8");
       logger.success("Updated tsconfig.json with Standard Agents types");
     } else {
       logger.info("tsconfig.json already configured");
@@ -1342,21 +1413,21 @@ function cleanupViteDefaults(cwd) {
   ];
   const dirsToRemove = ["src", "public"];
   for (const file of filesToRemove) {
-    const filePath = path.join(cwd, file);
-    if (fs.existsSync(filePath)) {
+    const filePath = path3.join(cwd, file);
+    if (fs3.existsSync(filePath)) {
       try {
-        fs.unlinkSync(filePath);
+        fs3.unlinkSync(filePath);
       } catch {
       }
     }
   }
   for (const dir of dirsToRemove) {
-    const dirPath = path.join(cwd, dir);
-    if (fs.existsSync(dirPath)) {
+    const dirPath = path3.join(cwd, dir);
+    if (fs3.existsSync(dirPath)) {
       try {
-        const files = fs.readdirSync(dirPath);
+        const files = fs3.readdirSync(dirPath);
         if (files.length === 0) {
-          fs.rmdirSync(dirPath);
+          fs3.rmdirSync(dirPath);
         }
       } catch {
       }
@@ -1388,8 +1459,8 @@ async function scaffold(options = {}) {
   logger.log("");
   logger.log("Your project structure:");
   logger.log("");
+  logger.log("  CLAUDE.md               # Architecture documentation");
   logger.log("  agents/");
-  logger.log("  \u251C\u2500\u2500 CLAUDE.md           # Architecture documentation");
   logger.log("  \u251C\u2500\u2500 Thread.ts           # Durable Object for threads");
   logger.log("  \u251C\u2500\u2500 AgentBuilder.ts     # Durable Object for agent state");
   logger.log("  \u251C\u2500\u2500 agents/             # Agent definitions");
@@ -1490,12 +1561,22 @@ function detectPackageManager() {
     if (userAgent.includes("yarn")) return "yarn";
     if (userAgent.includes("bun")) return "bun";
   }
-  if (fs.existsSync("pnpm-lock.yaml")) return "pnpm";
-  if (fs.existsSync("yarn.lock")) return "yarn";
-  if (fs.existsSync("bun.lockb")) return "bun";
-  if (fs.existsSync("package-lock.json")) return "npm";
+  if (fs3.existsSync("pnpm-lock.yaml")) return "pnpm";
+  if (fs3.existsSync("yarn.lock")) return "yarn";
+  if (fs3.existsSync("bun.lockb")) return "bun";
+  if (fs3.existsSync("package-lock.json")) return "npm";
   return "npm";
 }
+function getCliVersion() {
+  try {
+    const __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
+    const pkgPath = path3.resolve(__dirname2, "../../package.json");
+    const pkg2 = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+    return pkg2.version;
+  } catch {
+    return "latest";
+  }
+}
 async function selectPackageManager(detected) {
   const options = ["npm", "pnpm", "yarn", "bun"];
   const detectedIndex = options.indexOf(detected);
@@ -1577,8 +1658,8 @@ async function init(projectNameArg, options = {}) {
     logger.error("Project name is required");
     process.exit(1);
   }
-  const projectPath = path.join(cwd, projectName);
-  if (fs.existsSync(projectPath)) {
+  const projectPath = path3.join(cwd, projectName);
+  if (fs3.existsSync(projectPath)) {
     logger.error(`Directory "${projectName}" already exists`);
     process.exit(1);
   }
@@ -1610,51 +1691,28 @@ async function init(projectNameArg, options = {}) {
     logger.error("Failed to create Vite project");
     process.exit(1);
   }
-  const viteConfigPath = path.join(projectPath, "vite.config.ts");
-  if (!fs.existsSync(viteConfigPath)) {
+  const viteConfigPath = path3.join(projectPath, "vite.config.ts");
+  if (!fs3.existsSync(viteConfigPath)) {
     const viteConfigContent = `import { defineConfig } from 'vite'
 
 export default defineConfig({
   plugins: [],
 })
 `;
-    fs.writeFileSync(viteConfigPath, viteConfigContent, "utf-8");
+    fs3.writeFileSync(viteConfigPath, viteConfigContent, "utf-8");
     logger.success("Created vite.config.ts");
   }
-  const packageJsonPath = path.join(projectPath, "package.json");
-  if (fs.existsSync(packageJsonPath)) {
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+  const packageJsonPath = path3.join(projectPath, "package.json");
+  if (fs3.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
     const kebabName = toKebabCase(projectName);
     if (packageJson.name !== kebabName) {
       packageJson.name = kebabName;
-      fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
+      fs3.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
     }
   }
   logger.log("");
-  logger.info("Step 2: Installing Standard Agents dependencies...");
-  logger.log("");
-  try {
-    const installCmd = pm === "npm" ? "install" : "add";
-    const devFlag = pm === "npm" ? "--save-dev" : "-D";
-    await runCommand(pm, [
-      installCmd,
-      devFlag,
-      "@cloudflare/vite-plugin",
-      "@standardagents/builder",
-      "wrangler",
-      "zod"
-    ], projectPath);
-  } catch (error) {
-    logger.error("Failed to install dependencies");
-    process.exit(1);
-  }
-  logger.log("");
-  logger.info("Step 3: Configuring Standard Agents...");
-  logger.log("");
-  process.chdir(projectPath);
-  await scaffold({ force: true });
-  logger.log("");
-  logger.info("Step 4: Configuring environment variables...");
+  logger.info("Step 2: Configuring environment variables...");
   logger.log("");
   const encryptionKey = crypto.randomBytes(32).toString("hex");
   let openrouterKey = "";
@@ -1689,6 +1747,42 @@ export default defineConfig({
   if (!adminPassword) {
     adminPassword = "admin";
   }
+  logger.log("");
+  logger.info("Step 3: Installing Standard Agents dependencies...");
+  logger.log("");
+  try {
+    const installCmd = pm === "npm" ? "install" : "add";
+    const devFlag = pm === "npm" ? "--save-dev" : "-D";
+    const cliVersion = getCliVersion();
+    await runCommand(pm, [
+      installCmd,
+      devFlag,
+      "@cloudflare/vite-plugin",
+      "wrangler"
+    ], projectPath);
+    const deps = [
+      `@standardagents/builder@${cliVersion}`,
+      "zod"
+    ];
+    if (openaiKey) {
+      deps.push(`@standardagents/openai@${cliVersion}`);
+    }
+    if (openrouterKey) {
+      deps.push(`@standardagents/openrouter@${cliVersion}`);
+    }
+    await runCommand(pm, [installCmd, ...deps], projectPath);
+  } catch (error) {
+    logger.error("Failed to install dependencies");
+    process.exit(1);
+  }
+  logger.log("");
+  logger.info("Step 4: Configuring Standard Agents...");
+  logger.log("");
+  process.chdir(projectPath);
+  await scaffold({ force: true });
+  logger.log("");
+  logger.info("Writing environment configuration...");
+  logger.log("");
   const devVarsLines = [
     "# Standard Agents Environment Variables",
     "# This file contains secrets for local development only",
@@ -1714,14 +1808,14 @@ export default defineConfig({
     devVarsLines.push("# OPENAI_API_KEY=your-openai-key");
   }
   devVarsLines.push("");
-  const devVarsPath = path.join(projectPath, ".dev.vars");
-  fs.writeFileSync(devVarsPath, devVarsLines.join("\n"), "utf-8");
+  const devVarsPath = path3.join(projectPath, ".dev.vars");
+  fs3.writeFileSync(devVarsPath, devVarsLines.join("\n"), "utf-8");
   logger.success("Created .dev.vars with encryption key");
-  const gitignorePath = path.join(projectPath, ".gitignore");
-  if (fs.existsSync(gitignorePath)) {
-    const gitignoreContent = fs.readFileSync(gitignorePath, "utf-8");
+  const gitignorePath = path3.join(projectPath, ".gitignore");
+  if (fs3.existsSync(gitignorePath)) {
+    const gitignoreContent = fs3.readFileSync(gitignorePath, "utf-8");
     if (!gitignoreContent.includes(".dev.vars")) {
-      fs.appendFileSync(gitignorePath, "\n# Local environment variables\n.dev.vars\n");
+      fs3.appendFileSync(gitignorePath, "\n# Local environment variables\n.dev.vars\n");
       logger.success("Added .dev.vars to .gitignore");
     }
   }
@@ -1743,6 +1837,535 @@ export default defineConfig({
   logger.log("");
   logger.log("For more information, visit: https://standardagents.ai/docs");
 }
+function getReactPackageVersion() {
+  try {
+    const __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
+    const pkgPath = path3.resolve(__dirname2, "../package.json");
+    const pkg2 = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+    const version = pkg2.version;
+    const prereleaseMatch = version.match(/-([a-z]+)\./i);
+    if (prereleaseMatch) {
+      return prereleaseMatch[1];
+    }
+    return `^${version}`;
+  } catch {
+    return "latest";
+  }
+}
+function getChatSourceDir() {
+  const __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
+  return path3.resolve(__dirname2, "../chat");
+}
+async function prompt2(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+}
+function runCommand2(command, args, cwd) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: "inherit",
+      shell: false
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve2();
+      } else {
+        reject(new Error(`Command failed with exit code ${code}`));
+      }
+    });
+    child.on("error", reject);
+  });
+}
+function detectPackageManager2() {
+  const userAgent = process.env.npm_config_user_agent;
+  if (userAgent) {
+    if (userAgent.includes("pnpm")) return "pnpm";
+    if (userAgent.includes("yarn")) return "yarn";
+    if (userAgent.includes("bun")) return "bun";
+  }
+  if (fs3.existsSync("pnpm-lock.yaml")) return "pnpm";
+  if (fs3.existsSync("yarn.lock")) return "yarn";
+  if (fs3.existsSync("bun.lockb")) return "bun";
+  if (fs3.existsSync("package-lock.json")) return "npm";
+  return "npm";
+}
+async function selectPackageManager2(detected) {
+  const options = ["npm", "pnpm", "yarn", "bun"];
+  const detectedIndex = options.indexOf(detected);
+  return new Promise((resolve2) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    let selectedIndex = detectedIndex;
+    const renderOptions = () => {
+      stdout.write("\x1B[?25l");
+      stdout.write(`\x1B[${options.length + 1}A`);
+      stdout.write("\x1B[0J");
+      stdout.write("Select a package manager:\n");
+      options.forEach((opt, i) => {
+        const marker = i === detectedIndex ? " (detected)" : "";
+        const prefix = i === selectedIndex ? "\x1B[36m\u276F\x1B[0m" : " ";
+        const highlight = i === selectedIndex ? "\x1B[36m" : "\x1B[90m";
+        stdout.write(`${prefix} ${highlight}${opt}${marker}\x1B[0m
+`);
+      });
+    };
+    stdout.write("Select a package manager:\n");
+    options.forEach((opt, i) => {
+      const marker = i === detectedIndex ? " (detected)" : "";
+      const prefix = i === selectedIndex ? "\x1B[36m\u276F\x1B[0m" : " ";
+      const highlight = i === selectedIndex ? "\x1B[36m" : "\x1B[90m";
+      stdout.write(`${prefix} ${highlight}${opt}${marker}\x1B[0m
+`);
+    });
+    const wasRaw = stdin.isRaw;
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const cleanup = () => {
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      stdout.write("\x1B[?25h");
+    };
+    const onData = (key) => {
+      if (key === "\x1B[A" || key === "k") {
+        selectedIndex = (selectedIndex - 1 + options.length) % options.length;
+        renderOptions();
+      } else if (key === "\x1B[B" || key === "j") {
+        selectedIndex = (selectedIndex + 1) % options.length;
+        renderOptions();
+      } else if (key === "\r" || key === "\n") {
+        cleanup();
+        resolve2(options[selectedIndex]);
+      } else if (key === "") {
+        cleanup();
+        stdout.write("\n");
+        process.exit(1);
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+async function selectFramework() {
+  const options = [
+    { value: "vite", label: "Vite (React + TypeScript)" },
+    { value: "nextjs", label: "Next.js (App Router)" }
+  ];
+  return new Promise((resolve2) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    let selectedIndex = 0;
+    const renderOptions = () => {
+      stdout.write("\x1B[?25l");
+      stdout.write(`\x1B[${options.length + 1}A`);
+      stdout.write("\x1B[0J");
+      stdout.write("Select a framework:\n");
+      options.forEach((opt, i) => {
+        const prefix = i === selectedIndex ? "\x1B[36m\u276F\x1B[0m" : " ";
+        const highlight = i === selectedIndex ? "\x1B[36m" : "\x1B[90m";
+        stdout.write(`${prefix} ${highlight}${opt.label}\x1B[0m
+`);
+      });
+    };
+    stdout.write("Select a framework:\n");
+    options.forEach((opt, i) => {
+      const prefix = i === selectedIndex ? "\x1B[36m\u276F\x1B[0m" : " ";
+      const highlight = i === selectedIndex ? "\x1B[36m" : "\x1B[90m";
+      stdout.write(`${prefix} ${highlight}${opt.label}\x1B[0m
+`);
+    });
+    const wasRaw = stdin.isRaw;
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const cleanup = () => {
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      stdout.write("\x1B[?25h");
+    };
+    const onData = (key) => {
+      if (key === "\x1B[A" || key === "k") {
+        selectedIndex = (selectedIndex - 1 + options.length) % options.length;
+        renderOptions();
+      } else if (key === "\x1B[B" || key === "j") {
+        selectedIndex = (selectedIndex + 1) % options.length;
+        renderOptions();
+      } else if (key === "\r" || key === "\n") {
+        cleanup();
+        resolve2(options[selectedIndex].value);
+      } else if (key === "") {
+        cleanup();
+        stdout.write("\n");
+        process.exit(1);
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+function isValidUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isPortOpen(port) {
+  const tryConnect = (host) => {
+    return new Promise((resolve2) => {
+      const socket = new net.Socket();
+      socket.setTimeout(200);
+      socket.on("connect", () => {
+        socket.destroy();
+        resolve2(true);
+      });
+      socket.on("timeout", () => {
+        socket.destroy();
+        resolve2(false);
+      });
+      socket.on("error", () => {
+        socket.destroy();
+        resolve2(false);
+      });
+      socket.connect(port, host);
+    });
+  };
+  if (await tryConnect("127.0.0.1")) return true;
+  if (await tryConnect("::1")) return true;
+  return false;
+}
+async function isAgentbuilderInstance(url) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1e3);
+    const response = await fetch(`${url}/api/agents`, {
+      signal: controller.signal,
+      headers: { "Accept": "application/json" }
+    });
+    clearTimeout(timeout);
+    if (response.status === 401) {
+      return true;
+    }
+    if (response.ok) {
+      const data = await response.json();
+      return Array.isArray(data.agents);
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function detectAgentbuilderInstance() {
+  const portsToScan = [
+    5173,
+    5174,
+    5175,
+    5176,
+    5177,
+    5178,
+    5179,
+    5180,
+    3e3,
+    3001,
+    3002,
+    3003,
+    8080,
+    8e3,
+    4e3
+  ];
+  logger.log("\x1B[90mScanning for running agentbuilder instance...\x1B[0m");
+  const openPorts = [];
+  await Promise.all(
+    portsToScan.map(async (port) => {
+      if (await isPortOpen(port)) {
+        openPorts.push(port);
+      }
+    })
+  );
+  for (const port of openPorts.sort((a, b) => a - b)) {
+    const url = `http://localhost:${port}`;
+    if (await isAgentbuilderInstance(url)) {
+      return url;
+    }
+  }
+  return null;
+}
+function copyDir(src, dest, skip = []) {
+  if (!fs3.existsSync(dest)) {
+    fs3.mkdirSync(dest, { recursive: true });
+  }
+  const entries = fs3.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    if (skip.includes(entry.name)) continue;
+    const srcPath = path3.join(src, entry.name);
+    const destPath = path3.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath, skip);
+    } else {
+      fs3.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+async function initChat(projectNameArg, options = {}) {
+  const cwd = process.cwd();
+  const chatSourceDir = getChatSourceDir();
+  if (!fs3.existsSync(chatSourceDir)) {
+    logger.error("Chat source files not found. This CLI installation may be corrupted.");
+    process.exit(1);
+  }
+  logger.log("");
+  logger.info("Scaffolding a frontend chat application...");
+  logger.log("");
+  let projectName = projectNameArg;
+  if (!projectName && !options.yes) {
+    projectName = await prompt2("Project name: ");
+  }
+  if (!projectName) {
+    logger.error("Project name is required");
+    process.exit(1);
+  }
+  const projectPath = path3.join(cwd, projectName);
+  if (fs3.existsSync(projectPath)) {
+    logger.error(`Directory "${projectName}" already exists`);
+    process.exit(1);
+  }
+  let framework;
+  if (options.framework) {
+    framework = options.framework;
+  } else if (options.yes) {
+    framework = "vite";
+  } else {
+    framework = await selectFramework();
+    logger.log("");
+  }
+  let serverUrl;
+  if (options.yes) {
+    serverUrl = "http://localhost:5173";
+  } else {
+    const detectedUrl = await detectAgentbuilderInstance();
+    if (detectedUrl) {
+      logger.success(`Found agentbuilder at ${detectedUrl}`);
+      const urlInput = await prompt2(`Agentbuilder dev server URL [${detectedUrl}]: `);
+      serverUrl = urlInput || detectedUrl;
+    } else {
+      logger.log("\x1B[90mNo running agentbuilder instance found\x1B[0m");
+      const urlInput = await prompt2("Agentbuilder dev server URL [http://localhost:5173]: ");
+      serverUrl = urlInput || "http://localhost:5173";
+    }
+    if (!isValidUrl(serverUrl)) {
+      logger.error("Invalid URL format");
+      process.exit(1);
+    }
+  }
+  const detectedPm = detectPackageManager2();
+  let pm;
+  if (options.yes) {
+    pm = detectedPm;
+  } else {
+    pm = await selectPackageManager2(detectedPm);
+    logger.log("");
+  }
+  logger.log("");
+  logger.info(`Creating ${framework === "vite" ? "Vite" : "Next.js"} project...`);
+  logger.log("");
+  fs3.mkdirSync(projectPath, { recursive: true });
+  const reactVersion = getReactPackageVersion();
+  if (framework === "vite") {
+    await scaffoldVite(projectPath, chatSourceDir, projectName, serverUrl, reactVersion);
+  } else {
+    await scaffoldNextjs(projectPath, chatSourceDir, projectName, serverUrl, reactVersion);
+  }
+  logger.log("");
+  logger.info("Installing dependencies...");
+  logger.log("");
+  try {
+    await runCommand2(pm, pm === "npm" ? ["install"] : ["install"], projectPath);
+  } catch (error) {
+    logger.error("Failed to install dependencies");
+    process.exit(1);
+  }
+  logger.log("");
+  logger.success("Chat UI scaffolded successfully!");
+  logger.log("");
+  logger.info("Starting development server...");
+  logger.log("");
+  const devArgs = pm === "npm" ? ["run", "dev"] : ["dev"];
+  const devProcess = spawn(pm, devArgs, {
+    cwd: projectPath,
+    stdio: ["inherit", "pipe", "pipe"],
+    shell: false
+  });
+  let browserOpened = false;
+  const openBrowser = (url) => {
+    if (browserOpened) return;
+    browserOpened = true;
+    const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    spawn(openCmd, [url], { stdio: "ignore", detached: true }).unref();
+  };
+  devProcess.stdout?.on("data", (data) => {
+    const text = data.toString();
+    process.stdout.write(data);
+    const urlMatch = text.match(/Local:\s+(https?:\/\/localhost:\d+\/?)/);
+    if (urlMatch && !browserOpened) {
+      openBrowser(urlMatch[1]);
+    }
+  });
+  devProcess.stderr?.on("data", (data) => {
+    process.stderr.write(data);
+  });
+  devProcess.on("error", (error) => {
+    logger.error(`Failed to start dev server: ${error.message}`);
+    process.exit(1);
+  });
+}
+async function scaffoldVite(projectPath, chatSourceDir, projectName, serverUrl, reactVersion) {
+  copyDir(path3.join(chatSourceDir, "src"), path3.join(projectPath, "src"), []);
+  logger.success("Copied src/");
+  const viteDir = path3.join(chatSourceDir, "vite");
+  let indexHtml = fs3.readFileSync(path3.join(viteDir, "index.html"), "utf-8");
+  indexHtml = indexHtml.replace('src="/main.tsx"', 'src="/src/main.tsx"');
+  fs3.writeFileSync(path3.join(projectPath, "index.html"), indexHtml, "utf-8");
+  logger.success("Created index.html");
+  fs3.copyFileSync(path3.join(viteDir, "main.tsx"), path3.join(projectPath, "src", "main.tsx"));
+  logger.success("Created src/main.tsx");
+  let viteConfig = fs3.readFileSync(path3.join(viteDir, "vite.config.ts"), "utf-8");
+  viteConfig = `import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
+
+export default defineConfig({
+  plugins: [
+    react(),
+    tailwindcss(),
+  ],
+})
+`;
+  fs3.writeFileSync(path3.join(projectPath, "vite.config.ts"), viteConfig, "utf-8");
+  logger.success("Created vite.config.ts");
+  fs3.copyFileSync(path3.join(chatSourceDir, "tsconfig.json"), path3.join(projectPath, "tsconfig.json"));
+  const tsconfig = JSON.parse(fs3.readFileSync(path3.join(projectPath, "tsconfig.json"), "utf-8"));
+  tsconfig.include = ["src"];
+  delete tsconfig.compilerOptions?.paths;
+  fs3.writeFileSync(path3.join(projectPath, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n", "utf-8");
+  logger.success("Created tsconfig.json");
+  fs3.copyFileSync(path3.join(chatSourceDir, "package.json"), path3.join(projectPath, "package.json"));
+  const pkg2 = JSON.parse(fs3.readFileSync(path3.join(projectPath, "package.json"), "utf-8"));
+  pkg2.name = projectName;
+  pkg2.scripts = {
+    dev: "vite",
+    build: "vite build",
+    preview: "vite preview"
+  };
+  delete pkg2.private;
+  if (pkg2.dependencies?.["@standardagents/react"]) {
+    pkg2.dependencies["@standardagents/react"] = reactVersion;
+  }
+  delete pkg2.dependencies?.["next"];
+  delete pkg2.devDependencies?.["@tailwindcss/postcss"];
+  delete pkg2.devDependencies?.["postcss"];
+  fs3.writeFileSync(path3.join(projectPath, "package.json"), JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  logger.success("Created package.json");
+  const envContent = `# Agentbuilder connection
+VITE_AGENTBUILDER_URL=${serverUrl}
+`;
+  fs3.writeFileSync(path3.join(projectPath, ".env"), envContent, "utf-8");
+  logger.success("Created .env");
+  fs3.writeFileSync(path3.join(projectPath, ".gitignore"), `node_modules
+dist
+.env
+`, "utf-8");
+  logger.success("Created .gitignore");
+  let mainTsx = fs3.readFileSync(path3.join(projectPath, "src", "main.tsx"), "utf-8");
+  mainTsx = mainTsx.replace(/from '\.\.\/src\//g, "from './").replace(/import '\.\.\/src\//g, "import './");
+  fs3.writeFileSync(path3.join(projectPath, "src", "main.tsx"), mainTsx, "utf-8");
+  if (fs3.existsSync(path3.join(viteDir, "favicon.svg"))) {
+    fs3.copyFileSync(path3.join(viteDir, "favicon.svg"), path3.join(projectPath, "favicon.svg"));
+    logger.success("Created favicon.svg");
+  }
+}
+async function scaffoldNextjs(projectPath, chatSourceDir, projectName, serverUrl, reactVersion) {
+  copyDir(path3.join(chatSourceDir, "src"), path3.join(projectPath, "src"), []);
+  logger.success("Copied src/");
+  const nextDir = path3.join(chatSourceDir, "next");
+  copyDir(path3.join(nextDir, "app"), path3.join(projectPath, "app"), []);
+  logger.success("Copied app/");
+  fs3.copyFileSync(path3.join(nextDir, "next.config.ts"), path3.join(projectPath, "next.config.ts"));
+  logger.success("Created next.config.ts");
+  fs3.copyFileSync(path3.join(nextDir, "postcss.config.mjs"), path3.join(projectPath, "postcss.config.mjs"));
+  logger.success("Created postcss.config.mjs");
+  const tsconfig = {
+    compilerOptions: {
+      target: "ES2017",
+      lib: ["dom", "dom.iterable", "esnext"],
+      allowJs: true,
+      skipLibCheck: true,
+      strict: true,
+      noEmit: true,
+      esModuleInterop: true,
+      module: "esnext",
+      moduleResolution: "bundler",
+      resolveJsonModule: true,
+      isolatedModules: true,
+      jsx: "preserve",
+      incremental: true,
+      plugins: [{ name: "next" }],
+      paths: {
+        "@/*": ["./src/*"]
+      }
+    },
+    include: ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+    exclude: ["node_modules"]
+  };
+  fs3.writeFileSync(path3.join(projectPath, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n", "utf-8");
+  logger.success("Created tsconfig.json");
+  const pkg2 = JSON.parse(fs3.readFileSync(path3.join(chatSourceDir, "package.json"), "utf-8"));
+  pkg2.name = projectName;
+  pkg2.scripts = {
+    dev: "next dev",
+    build: "next build",
+    start: "next start"
+  };
+  delete pkg2.private;
+  if (pkg2.dependencies?.["@standardagents/react"]) {
+    pkg2.dependencies["@standardagents/react"] = reactVersion;
+  }
+  delete pkg2.devDependencies?.["@tailwindcss/vite"];
+  delete pkg2.devDependencies?.["@vitejs/plugin-react"];
+  delete pkg2.devDependencies?.["vite"];
+  fs3.writeFileSync(path3.join(projectPath, "package.json"), JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  logger.success("Created package.json");
+  const envContent = `# Agentbuilder connection
+NEXT_PUBLIC_AGENTBUILDER_URL=${serverUrl}
+`;
+  fs3.writeFileSync(path3.join(projectPath, ".env.local"), envContent, "utf-8");
+  logger.success("Created .env.local");
+  fs3.writeFileSync(path3.join(projectPath, ".gitignore"), `node_modules
+.next
+out
+.env.local
+`, "utf-8");
+  logger.success("Created .gitignore");
+  let layoutTsx = fs3.readFileSync(path3.join(projectPath, "app", "layout.tsx"), "utf-8");
+  layoutTsx = layoutTsx.replace(/from '\.\.\/\.\.\/src\//g, "from '../src/");
+  fs3.writeFileSync(path3.join(projectPath, "app", "layout.tsx"), layoutTsx, "utf-8");
+  let pageTsx = fs3.readFileSync(path3.join(projectPath, "app", "page.tsx"), "utf-8");
+  pageTsx = pageTsx.replace(/from '\.\.\/\.\.\/src\//g, "from '../src/");
+  fs3.writeFileSync(path3.join(projectPath, "app", "page.tsx"), pageTsx, "utf-8");
+}
 
 // src/index.ts
 var __dirname$1 = dirname(fileURLToPath(import.meta.url));
@@ -1751,6 +2374,7 @@ var program = new Command();
 program.name("agents").description("CLI tool for Standard Agents / AgentBuilder").version(pkg.version);
 program.command("init [project-name]").description("Create a new Standard Agents project (runs create vite, then scaffold)").option("-y, --yes", "Skip prompts and use defaults").option("--template <template>", "Vite template to use", "vanilla-ts").action(init);
 program.command("scaffold").description("Add Standard Agents to an existing Vite project").option("--force", "Overwrite existing configuration").action(scaffold);
+program.command("init-chat [project-name]").description("Scaffold a frontend chat application").option("-y, --yes", "Skip prompts and use defaults").option("--framework <framework>", "Framework to use (vite or nextjs)").action(initChat);
 program.parse();
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map