@standardagents/cli 0.9.2 → 0.9.3

package/dist/index.js

@@ -1,53 +1,15 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import path3 from 'path';
-import fs from 'fs';
-import { parse, modify, applyEdits } from 'jsonc-parser';
+import fs, { readFileSync } from 'fs';
+import path, { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import readline from 'readline';
+import { spawn } from 'child_process';
 import chalk from 'chalk';
+import { parse, modify, applyEdits } from 'jsonc-parser';
+import { loadFile, writeFile, generateCode } from 'magicast';
+import { addVitePlugin } from 'magicast/helpers';
 
-function findWranglerConfig(cwd) {
-  const jsonc = path3.join(cwd, "wrangler.jsonc");
-  const json = path3.join(cwd, "wrangler.json");
-  if (fs.existsSync(jsonc)) {
-    return jsonc;
-  }
-  if (fs.existsSync(json)) {
-    return json;
-  }
-  return null;
-}
-function readWranglerConfig(filePath) {
-  const text = fs.readFileSync(filePath, "utf-8");
-  const config = parse(text);
-  return { config, text };
-}
-function updateWranglerConfig(filePath, text, updates) {
-  let result = text;
-  if (updates.durable_objects) {
-    const edits = modify(result, ["durable_objects"], updates.durable_objects, {});
-    result = applyEdits(result, edits);
-  }
-  if (updates.migrations) {
-    const edits = modify(result, ["migrations"], updates.migrations, {});
-    result = applyEdits(result, edits);
-  }
-  if (updates.env) {
-    for (const [envName, envConfig] of Object.entries(updates.env)) {
-      if (envConfig.durable_objects) {
-        const edits = modify(result, ["env", envName, "durable_objects"], envConfig.durable_objects, {});
-        result = applyEdits(result, edits);
-      }
-      if (envConfig.migrations) {
-        const edits = modify(result, ["env", envName, "migrations"], envConfig.migrations, {});
-        result = applyEdits(result, edits);
-      }
-    }
-  }
-  return result;
-}
-function writeWranglerConfig(filePath, content) {
-  fs.writeFileSync(filePath, content, "utf-8");
-}
 var logger = {
   success: (message) => {
     console.log(chalk.green("\u2713"), message);
@@ -65,24 +27,21 @@ var logger = {
     console.log(message);
   }
 };
-
-// src/commands/init.ts
-async function init(options = {}) {
-  var _a, _b, _c, _d, _e;
-  const cwd = process.cwd();
-  logger.info("Initializing Standard Agents configuration...");
-  const configPath = findWranglerConfig(cwd);
-  if (!configPath) {
-    logger.error("No wrangler.jsonc or wrangler.json found in current directory");
-    logger.log("\nTo use Standard Agents, you need a Cloudflare Workers project with wrangler configuration.");
-    logger.log("\nExample wrangler.jsonc:");
-    logger.log(`
-{
-  "name": "my-agent",
-  "main": "server/index.ts",
-  "compatibility_date": "2025-08-13",
+var WRANGLER_TEMPLATE = (name) => `{
+  "$schema": "node_modules/wrangler/config-schema.json",
+  "name": "${name}",
+  "main": "worker/index.ts",
+  "compatibility_date": "2025-01-01",
   "compatibility_flags": ["nodejs_compat"],
-
+  "observability": {
+    "enabled": true
+  },
+  "assets": {
+    "directory": "dist",
+    "not_found_handling": "single-page-application",
+    "binding": "ASSETS",
+    "run_worker_first": ["/**"]
+  },
   "durable_objects": {
     "bindings": [
       {
@@ -95,103 +54,39 @@ async function init(options = {}) {
       }
     ]
   },
-
   "migrations": [
     {
       "tag": "v1",
-      "new_sqlite_classes": ["DurableThread", "DurableAgentBuilder"]
+      "new_sqlite_classes": ["DurableThread"]
+    },
+    {
+      "tag": "v2",
+      "new_sqlite_classes": ["DurableAgentBuilder"]
     }
   ]
 }
-`);
-    process.exit(1);
-  }
-  logger.success(`Found configuration: ${path3.relative(cwd, configPath)}`);
-  const { config, text } = readWranglerConfig(configPath);
-  const hasAgentBuilderThread = (_b = (_a = config.durable_objects) == null ? void 0 : _a.bindings) == null ? void 0 : _b.some(
-    (binding) => binding.name === "AGENT_BUILDER_THREAD"
-  );
-  const hasAgentBuilder = (_d = (_c = config.durable_objects) == null ? void 0 : _c.bindings) == null ? void 0 : _d.some(
-    (binding) => binding.name === "AGENT_BUILDER"
-  );
-  if (hasAgentBuilderThread && hasAgentBuilder && !options.force) {
-    logger.success("Standard Agents is already configured!");
-    logger.info("Use --force to overwrite existing configuration");
-    return;
-  }
-  const updates = {};
-  updates.durable_objects = config.durable_objects || { bindings: [] };
-  if (options.force) {
-    updates.durable_objects.bindings = updates.durable_objects.bindings.filter(
-      (binding) => binding.name !== "AGENT_BUILDER_THREAD" && binding.name !== "AGENT_BUILDER"
-    );
-  }
-  if (!hasAgentBuilderThread || options.force) {
-    updates.durable_objects.bindings.push({
-      name: "AGENT_BUILDER_THREAD",
-      class_name: "DurableThread"
-    });
-    logger.info("Added AGENT_BUILDER_THREAD binding");
-  }
-  if (!hasAgentBuilder || options.force) {
-    updates.durable_objects.bindings.push({
-      name: "AGENT_BUILDER",
-      class_name: "DurableAgentBuilder"
-    });
-    logger.info("Added AGENT_BUILDER binding");
-  }
-  if (!config.migrations || config.migrations.length === 0) {
-    updates.migrations = [
-      {
-        tag: "v1",
-        new_sqlite_classes: ["DurableThread", "DurableAgentBuilder"]
-      }
-    ];
-    logger.info("Added Durable Object migrations");
-  }
-  if ((_e = config.env) == null ? void 0 : _e.test) {
-    updates.env = updates.env || {};
-    updates.env.test = config.env.test;
-    if (!updates.env.test.durable_objects) {
-      updates.env.test.durable_objects = { bindings: [] };
-    }
-    const hasTestThread = updates.env.test.durable_objects.bindings.some(
-      (binding) => binding.name === "AGENT_BUILDER_THREAD"
-    );
-    const hasTestBuilder = updates.env.test.durable_objects.bindings.some(
-      (binding) => binding.name === "AGENT_BUILDER"
-    );
-    if (!hasTestThread) {
-      updates.env.test.durable_objects.bindings.push({
-        name: "AGENT_BUILDER_THREAD",
-        class_name: "DurableThread"
-      });
-      logger.info("Added test environment AGENT_BUILDER_THREAD binding");
-    }
-    if (!hasTestBuilder) {
-      updates.env.test.durable_objects.bindings.push({
-        name: "AGENT_BUILDER",
-        class_name: "DurableAgentBuilder"
-      });
-      logger.info("Added test environment AGENT_BUILDER binding");
-    }
-    if (!updates.env.test.migrations) {
-      updates.env.test.migrations = [
-        {
-          tag: "v1",
-          new_sqlite_classes: ["DurableThread", "DurableAgentBuilder"]
-        }
-      ];
-      logger.info("Added test environment Durable Object migrations");
-    }
-  }
-  const updatedText = updateWranglerConfig(configPath, text, updates);
-  writeWranglerConfig(configPath, updatedText);
-  logger.success("Configuration updated successfully!");
-  logger.log("\nNext steps:");
-  logger.log("1. Create your agent definitions in agents/agents/");
-  logger.log("2. Start your development server");
-}
+`;
+var THREAD_TS = `import { DurableThread } from 'virtual:@standardagents/builder'
+
+export default class Thread extends DurableThread {}
+`;
+var AGENT_BUILDER_TS = `import { DurableAgentBuilder } from 'virtual:@standardagents/builder'
+
+export default class AgentBuilder extends DurableAgentBuilder {}
+`;
+var WORKER_INDEX = `import { router } from "virtual:@standardagents/builder"
+import DurableThread from '../agents/Thread';
+import DurableAgentBuilder from '../agents/AgentBuilder';
+
+export default {
+  async fetch(request, env) {
+    const res = await router(request, env)
+    return res ?? new Response(null, { status: 404 })
+  },
+} satisfies ExportedHandler<Env>
+
+export { DurableThread, DurableAgentBuilder }
+`;
 var TOOLS_CLAUDE_MD = `# Custom Tools
 
 This directory contains custom tools that your AI agents can call during execution.
@@ -206,216 +101,28 @@ Tools are functions that extend your agent's capabilities beyond text generation
 
 ## Creating a Tool
 
-Create a new file in this directory following the naming convention:
-
-\`\`\`
-agents/tools/
-\u251C\u2500\u2500 my_tool.ts           # \u2713 snake_case recommended
-\u251C\u2500\u2500 another_tool.ts      # \u2713 Valid
-\u2514\u2500\u2500 CamelCaseTool.ts     # \u26A0 Works but triggers warning
-\`\`\`
-
-### Tool File Structure
-
-Each tool file should export a default function created with \`defineTool\`:
+Create a new file in this directory:
 
 \`\`\`typescript
 import { defineTool } from '@standardagents/builder';
 import { z } from 'zod';
 
-// With arguments
 export default defineTool(
   'Description of what this tool does',
   z.object({
     param1: z.string().describe('Description of param1'),
-    param2: z.number().optional().describe('Optional parameter'),
   }),
   async (flow, args) => {
     // Tool implementation
-    const result = await doSomething(args.param1, args.param2);
-
-    return {
-      status: 'success',
-      result: JSON.stringify(result)
-    };
-  }
-);
-
-// Without arguments
-export default defineTool(
-  'Simple tool with no parameters',
-  async (flow) => {
     return {
       status: 'success',
-      result: 'Done!'
+      result: JSON.stringify({ data: 'result' })
     };
   }
 );
 \`\`\`
 
-### FlowState Object
-
-The \`flow\` parameter provides execution context:
-
-\`\`\`typescript
-interface FlowState {
-  env: Env;                    // Cloudflare bindings (KV, R2, etc.)
-  storage: DurableObjectStorage; // Thread's SQLite storage
-  threadId: string;            // Current thread ID
-  agentId: string;             // Current agent ID
-  currentSide: 'a' | 'b';      // Which side is executing
-  turnCount: number;           // Current turn number
-  context: Record<string, any>; // Arbitrary state data
-  // ... and more
-}
-\`\`\`
-
-### Return Value
-
-Tools must return a ToolResult object:
-
-\`\`\`typescript
-interface ToolResult {
-  status: 'success' | 'error';
-  result?: string;    // Success data
-  error?: string;     // Error message
-}
-\`\`\`
-
-## Tool Discovery
-
-Tools are **auto-discovered** at runtime. No manual registration needed!
-
-1. Vite plugin scans this directory on startup
-2. Generates virtual module with dynamic imports
-3. Tools become available to all agents
-4. HMR (Hot Module Replacement) works in development
-
-## Examples
-
-### API Fetch Tool
-
-\`\`\`typescript
-import { defineTool } from '@standardagents/builder';
-import { z } from 'zod';
-
-export default defineTool(
-  'Fetch weather data for a city',
-  z.object({
-    city: z.string().describe('City name'),
-    units: z.enum(['metric', 'imperial']).optional(),
-  }),
-  async (flow, args) => {
-    try {
-      const response = await fetch(
-        \`https://api.weather.com/\${args.city}\`
-      );
-      const data = await response.json();
-
-      return {
-        status: 'success',
-        result: JSON.stringify(data),
-      };
-    } catch (error) {
-      return {
-        status: 'error',
-        error: error.message,
-      };
-    }
-  }
-);
-\`\`\`
-
-### Thread Storage Tool
-
-\`\`\`typescript
-import { defineTool } from '@standardagents/builder';
-import { z } from 'zod';
-
-export default defineTool(
-  'Get custom data from thread storage',
-  z.object({
-    key: z.string().describe('Storage key to look up'),
-  }),
-  async (flow, args) => {
-    try {
-      // Use thread's SQLite storage
-      const result = await flow.storage.sql.exec(
-        \`SELECT value FROM custom_data WHERE key = ?\`,
-        args.key
-      ).toArray();
-
-      if (result.length === 0) {
-        return {
-          status: 'error',
-          error: 'Data not found',
-        };
-      }
-
-      return {
-        status: 'success',
-        result: JSON.stringify(result[0]),
-      };
-    } catch (error) {
-      return {
-        status: 'error',
-        error: error.message,
-      };
-    }
-  }
-);
-\`\`\`
-
-## Best Practices
-
-1. **Descriptive Names**: Use clear, action-oriented names (e.g., \`fetch_weather\`, not \`weather\`)
-2. **Detailed Descriptions**: The description helps the LLM understand when to use the tool
-3. **Zod Descriptions**: Add \`.describe()\` to all schema fields for better LLM understanding
-4. **Error Handling**: Always wrap in try/catch and return proper error status
-5. **Type Safety**: Use Zod for runtime validation and TypeScript inference
-6. **Keep It Simple**: Each tool should do one thing well
-7. **Stateless**: Don't rely on global state; use FlowState for context
-
-## Debugging
-
-- Check console output for tool execution logs
-- Tool errors appear in the logs table
-- Use \`console.log\` within tools (visible in dev mode)
-- Check message history to see tool calls and responses
-
-## Testing
-
-Tools can be tested independently:
-
-\`\`\`typescript
-import myTool from './my_tool';
-
-const [description, schema, handler] = myTool;
-
-// Mock FlowState
-const mockFlow = {
-  env: mockEnv,
-  storage: mockStorage,
-  threadId: 'test-123',
-  // ...
-};
-
-const result = await handler(mockFlow, { param1: 'test' });
-console.log(result);
-\`\`\`
-
-## Limitations
-
-- No nested directories (tools must be directly in this folder)
-- Tool execution is **sequential** (no parallel execution)
-- Tool results must be JSON-serializable strings
-- Maximum execution time limited by Workers CPU time
-
-## Related
-
-- **Hooks**: \`agents/hooks/CLAUDE.md\` - Lifecycle hooks
-- **APIs**: \`agents/api/CLAUDE.md\` - Thread-specific endpoints
-- **Documentation**: Project root \`CLAUDE.md\` for architecture overview
+Tools are auto-discovered at runtime. No manual registration needed!
 `;
 var HOOKS_CLAUDE_MD = `# Lifecycle Hooks
 
@@ -428,901 +135,637 @@ Hooks are optional functions that run at specific points during agent execution:
 - **After** LLM responses (post-process messages)
 - At other lifecycle events (message creation, tool execution, etc.)
 
-Unlike tools (which agents explicitly call), hooks run **automatically** when their trigger point occurs.
-
-## Using defineHook for Type Safety
-
-All hooks should use the \`defineHook\` utility for strict typing:
-
-\`\`\`typescript
-import { defineHook } from '@standardagents/builder';
-
-export default defineHook('filter_messages', async (state, rows) => {
-  // TypeScript knows exactly what state and rows are!
-  return rows;
-});
-\`\`\`
-
-The \`defineHook\` function provides:
-- **Strict typing** for hook parameters based on the hook name
-- **IntelliSense** support in your editor
-- **Type checking** to catch errors before runtime
-- **Better documentation** through type hints
-
-## Available Hooks
-
-### \`filter_messages\`
-
-**When**: Before message history is transformed to chat completion format
-**Purpose**: Filter or modify SQL row data with access to ALL database columns
-
-\`\`\`typescript
-import { defineHook, type MessageRow } from '@standardagents/builder';
-
-export default defineHook('filter_messages', async (state, rows) => {
-  // rows contains ALL columns from messages table:
-  // id, role, content, name, tool_calls, tool_call_id, log_id,
-  // created_at, request_sent_at, response_completed_at, status,
-  // silent, tool_status
-
-  // Your filtering logic here
-  return rows;
-});
-\`\`\`
-
-**Common Use Cases**:
-- Filter out failed tool messages (\`tool_status = 'error'\`)
-- Remove messages older than a certain time
-- Filter by status (pending, completed, failed)
-- Access columns not available in chat format
-- Filter based on database-specific metadata
-
-**Example - Filter Out Failed Tools**:
-\`\`\`typescript
-export default defineHook('filter_messages', async (state, rows) => {
-  // Remove tool messages that failed execution
-  return rows.filter(row => {
-    if (row.role === 'tool' && row.tool_status === 'error') {
-      return false;
-    }
-    return true;
-  });
-});
-\`\`\`
-
-**Important**: This hook runs **before** messages are transformed to Message objects and receives raw SQL data. Use this when you need access to database columns like \`tool_status\`, \`silent\`, or \`status\`.
-
-### \`prefilter_llm_history\`
-
-**When**: Immediately after message transformation, before sending to LLM
-**Purpose**: Modify, filter, or limit message history in chat completion format
+## Creating a Hook
 
 \`\`\`typescript
 import { defineHook } from '@standardagents/builder';
 
 export default defineHook('prefilter_llm_history', async (state, messages) => {
-  // messages are in chat completion format (already transformed from SQL rows)
-  // Available fields: role, content, tool_calls, tool_call_id, name
-
-  // Your filtering logic here
+  // Filter or modify messages before sending to LLM
   return messages;
 });
 \`\`\`
 
-**Common Use Cases**:
-- Limit conversation history to last N messages
-- Remove old tool messages to reduce token usage
-- Summarize old messages before sending
-- Add dynamic context based on message patterns
-- Filter out sensitive information
+Hook files must be named exactly as the hook type (e.g., \`prefilter_llm_history.ts\`).
+`;
+var API_CLAUDE_MD = `# Thread-Specific API Endpoints
 
-**Example - Limit to Last 10 Messages**:
-\`\`\`typescript
-import { defineHook } from '@standardagents/builder';
+This directory contains custom API endpoints that operate on specific threads.
 
-export default defineHook('prefilter_llm_history', async (state, messages) => {
-  // Keep all system messages
-  const systemMessages = messages.filter(m => m.role === 'system');
+## What Are Thread Endpoints?
 
-  // Take only last 10 non-system messages
-  const otherMessages = messages
-    .filter(m => m.role !== 'system')
-    .slice(-10);
+Thread endpoints are API routes that:
+- Automatically receive a specific thread's Durable Object instance
+- Can access thread-local SQLite storage
+- Perform operations in the context of a conversation
+- Use file-based routing for automatic discovery
 
-  return [...systemMessages, ...otherMessages];
-});
-\`\`\`
+## Creating an Endpoint
 
-**Example - Remove Old Tool Messages**:
 \`\`\`typescript
-import { defineHook } from '@standardagents/builder';
-
-export default defineHook('prefilter_llm_history', async (state, messages) => {
-  // Keep messages from last 5 turns, remove old tool messages
-  const recentThreshold = messages.length - 10;
+// agents/api/summary.get.ts -> GET /agents/api/threads/:id/summary
+import { defineThreadEndpoint } from '@standardagents/builder';
 
-  return messages.filter((m, index) => {
-    if (m.role === 'tool' && index < recentThreshold) {
-      return false; // Remove old tool messages
-    }
-    return true;
+export default defineThreadEndpoint(async (thread, request, env) => {
+  const messages = await thread.getMessages();
+  return new Response(JSON.stringify({ count: messages.length }), {
+    headers: { 'Content-Type': 'application/json' }
   });
 });
 \`\`\`
 
-**Important**: The **filtered messages are logged**, so you can see exactly what was sent to the LLM in the logs table.
-
-### \`post_process_message\`
-
-**When**: After receiving a response from the LLM
-**Purpose**: Modify or enhance the assistant's message
-
-\`\`\`typescript
-import { defineHook } from '@standardagents/builder';
+Pattern: \`{name}.{method}.ts\` (e.g., \`summary.get.ts\`, \`export.post.ts\`)
+`;
+var AGENTS_CLAUDE_MD = `# Agent Definitions
 
-export default defineHook('post_process_message', async (state, message) => {
-  // Your post-processing logic here
-  return message;
-});
-\`\`\`
+This directory contains your AI agent definitions.
 
-**Common Use Cases**:
-- Format or clean up LLM output
-- Add metadata or tracking information
-- Inject additional context into responses
-- Transform tool call formats
+## Creating an Agent
 
-**Example - Add Metadata**:
 \`\`\`typescript
-import { defineHook } from '@standardagents/builder';
+import { defineAgent } from '@standardagents/builder';
 
-export default defineHook('post_process_message', async (state, message) => {
-  if (message.content) {
-    message.content += \`\\n\\n_Generated at turn \${state.turnCount}_\`;
-  }
-  return message;
+export default defineAgent({
+  name: 'my-agent',
+  type: 'ai_human',
+  title: 'My Agent',
+  defaultPrompt: 'my-prompt',
+  defaultModel: 'gpt-4o',
+  tools: ['my_tool'],
 });
 \`\`\`
 
-**Note**: This hook is currently defined but **not yet invoked** in FlowEngine. It will be activated in a future update.
-
-### Message Lifecycle Hooks
-
-The following hooks run for **ANY** message being created or updated in the database, whether it's an agent message, tool message, user message, or system message.
-
-#### \`before_create_message\`
-
-**When**: Immediately before a message is inserted into the database
-**Purpose**: Modify message data before it's stored
-
-\`\`\`typescript
-import { defineHook } from '@standardagents/builder';
-
-export default defineHook('before_create_message', async (state, message) => {
-  // Your modification logic here
-  return message;
-});
-\`\`\`
+Agent types:
+- \`ai_human\`: Human interacts with AI agent
+- \`dual_ai\`: Two AI agents interact with each other
+`;
+var PROMPTS_CLAUDE_MD = `# Prompt Definitions
 
-**Message Structure**:
-\`\`\`typescript
-{
-    id: string;
-    role: string;
-    content: string | null;
-    tool_calls?: string | null;
-    tool_call_id?: string | null;
-    name?: string | null;
-    created_at: number;
-    status?: string;
-    silent?: boolean;
-}
-\`\`\`
+This directory contains your prompt/system message definitions.
 
-**Common Use Cases**:
-- Add prefixes or metadata to message content
-- Modify message based on agent configuration
-- Add tracking IDs or identifiers
-- Transform message format before storage
+## Creating a Prompt
 
-**Example - Add Metadata**:
 \`\`\`typescript
-import { defineHook } from '@standardagents/builder';
+import { definePrompt } from '@standardagents/builder';
 
-export default defineHook('before_create_message', async (state, message) => {
-  // Add agent ID to all messages
-  if (message.content && message.role === 'assistant') {
-    message.name = state.agentConfig.title;
-  }
-  return message;
+export default definePrompt({
+  name: 'my-prompt',
+  model: 'gpt-4o',
+  systemPrompt: 'You are a helpful assistant...',
+  tools: ['search', 'calculate'],
 });
 \`\`\`
+`;
+var MODELS_CLAUDE_MD = `# Model Definitions
 
-#### \`after_create_message\`
+This directory contains your AI model configurations.
 
-**When**: Immediately after a message is inserted into the database
-**Purpose**: Perform actions based on newly created messages
+## Creating a Model
 
 \`\`\`typescript
-import { defineHook } from '@standardagents/builder';
+import { defineModel } from '@standardagents/builder';
 
-export default defineHook('after_create_message', async (state, message) => {
-  // Your post-creation logic here
-  // No return value needed
+export default defineModel({
+  name: 'gpt-4o',
+  model: 'gpt-4o',
+  provider: 'openai',
+  inputPrice: 2.5,
+  outputPrice: 10,
 });
 \`\`\`
 
-**Common Use Cases**:
-- Log messages to external systems
-- Trigger webhooks or notifications
-- Update analytics or metrics
-- Send real-time updates to monitoring services
-
-**Example - Log to External Service**:
-\`\`\`typescript
-import { defineHook } from '@standardagents/builder';
-
-export default defineHook('after_create_message', async (state, message) => {
-  // Log all assistant messages to analytics
-  if (message.role === 'assistant' && message.content) {
+Supported providers: \`openai\`, \`anthropic\`, \`openrouter\`, \`google\`
+`;
+function getProjectName(cwd) {
+  const packageJsonPath = path.join(cwd, "package.json");
+  if (fs.existsSync(packageJsonPath)) {
     try {
-      await fetch('https://analytics.example.com/message', {
-        method: 'POST',
-        body: JSON.stringify({
-          threadId: state.threadId,
-          messageId: message.id,
-          contentLength: message.content.length,
-        })
-      });
-    } catch (error) {
-      console.error('Analytics logging failed:', error);
+      const pkg2 = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+      if (pkg2.name) {
+        return pkg2.name.replace(/^@[^/]+\//, "");
+      }
+    } catch {
     }
   }
-});
-\`\`\`
-
-#### \`before_update_message\`
-
-**When**: Immediately before a message is updated in the database
-**Purpose**: Modify update data before it's applied
-
-\`\`\`typescript
-import { defineHook } from '@standardagents/builder';
-
-export default defineHook('before_update_message', async (state, messageId, updates) => {
-  // Your modification logic here
-  return updates;
-});
-\`\`\`
-
-**Common Use Cases**:
-- Validate or sanitize updated content
-- Add completion timestamps
-- Transform status values
-- Inject metadata into updates
-
-**Example - Add Completion Timestamp**:
-\`\`\`typescript
-import { defineHook } from '@standardagents/builder';
-
-export default defineHook('before_update_message', async (state, messageId, updates) => {
-  // Add custom completion timestamp for completed messages
-  if (updates.status === 'completed' && !updates.response_completed_at) {
-    updates.response_completed_at = Date.now() * 1000; // microseconds
+  return path.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)) {
+      return configPath;
+    }
   }
-  return updates;
-});
-\`\`\`
-
-#### \`after_update_message\`
-
-**When**: Immediately after a message is updated in the database
-**Purpose**: Perform actions based on message updates
-
-\`\`\`typescript
-import { defineHook } from '@standardagents/builder';
-
-export default defineHook('after_update_message', async (state, messageId, updates) => {
-  // Your post-update logic here
-  // No return value needed
-});
-\`\`\`
-
-**Common Use Cases**:
-- Track message status changes
-- Trigger notifications on completion
-- Update external systems
-- Log state transitions
-
-**Example - Notify on Failure**:
-\`\`\`typescript
-import { defineHook } from '@standardagents/builder';
-
-export default defineHook('after_update_message', async (state, messageId, updates) => {
-  // Send notification when message is marked as failed
-  if (updates.status === 'failed') {
-    console.log(\`[Alert] Message \${messageId} failed in thread \${state.threadId}\`);
-  }
-});
-\`\`\`
-
-**Important**:
-- \`before_*\` hooks must return the modified data object
-- \`after_*\` hooks don't need to return anything
-- All 4 hooks run for ANY message operation (agent, tool, user, system messages)
-- Updates passed to update hooks contain only the fields being updated
-
-## Creating a Hook
-
-1. Create a file named exactly as the hook (e.g., \`prefilter_llm_history.ts\`)
-2. Use \`defineHook\` to ensure correct typing
-3. Return the modified data (or original if no changes)
-
-\`\`\`typescript
-// agents/hooks/prefilter_llm_history.ts
-import { defineHook } from '@standardagents/builder';
-
-export default defineHook('prefilter_llm_history', async (state, messages) => {
-  console.log(\`Processing \${messages.length} messages\`);
-
-  // Your logic here
-
-  return messages; // Return modified or original
-});
-\`\`\`
-
-## Hook Lifecycle
-
-1. **Discovery**: Vite plugin scans this directory on startup
-2. **Virtual Module**: Generates \`virtual:@standardagents-hooks\` with lazy imports
-3. **Lazy Loading**: Hooks are loaded on first use (not at startup)
-4. **Caching**: Once loaded, hooks are cached for performance
-5. **HMR**: Changes trigger hot reload in development
-
-## Error Handling
-
-Hooks are designed to be **safe**:
-- If hook file doesn't exist \u2192 Silently skipped (no error)
-- If hook throws error \u2192 Logged to console, original data returned
-- If hook returns invalid data \u2192 Original data used as fallback
-
-This ensures hooks never break agent execution.
-
-## FlowState Object
-
-All hooks receive the FlowState context:
-
-\`\`\`typescript
-interface FlowState {
-  threadId: string;           // Current thread ID
-  flowId: string;             // Unique execution ID
-  agentConfig: Agent;         // Full agent configuration
-  currentSide: 'a' | 'b';     // Which side is executing (dual_ai)
-  turnCount: number;          // Current turn number
-  stopped: boolean;           // Whether execution should stop
-  messageHistory: Message[];  // Full conversation history
-  env: Env;                   // Cloudflare bindings
-  storage: DurableObjectStorage; // Thread's SQLite storage
-  context: Record<string, any>;  // Arbitrary state data
-  // ... and more
+  return null;
 }
-\`\`\`
-
-Use this to make context-aware decisions in your hooks.
-
-## Best Practices
-
-1. **Keep Hooks Fast**: They run on every execution, avoid heavy operations
-2. **Always Return Data**: Never return \`undefined\` or \`null\`
-3. **Log Thoughtfully**: Use \`console.log\` sparingly (visible in logs)
-4. **Handle Errors**: Wrap risky operations in try/catch
-5. **Document Behavior**: Add comments explaining what your hook does
-6. **Test Thoroughly**: Hooks affect ALL agent executions
-
-## Debugging
-
-- Check console output for hook loading/execution logs
-- Hook errors are logged with \`[Hooks] \u2717\` prefix
-- Inspect logs table to see filtered messages (for prefilter hook)
-- Use \`console.log\` within hooks for debugging
-
-## Performance Considerations
-
-Hooks run on **every turn**, so:
-- Avoid expensive operations (heavy computation, slow APIs)
-- Cache results when possible
-- Consider using FlowState context to skip unnecessary work
-- Use async operations efficiently
-
-## Message Data & Tool Status
-
-The \`filter_messages\` hook receives SQL row data with ALL columns from the messages table:
-
-\`\`\`typescript
-interface MessageRow {
-  id: string;
-  role: 'system' | 'user' | 'assistant' | 'tool';
-  content: string | null;
-  name: string | null;
-  tool_calls: string | null;          // JSON string of tool calls
-  tool_call_id: string | null;        // For role='tool' messages
-  log_id: string | null;              // Reference to logs table
-  created_at: number;                 // Microseconds timestamp
-  request_sent_at: number | null;     // When request was sent to LLM
-  response_completed_at: number | null; // When response completed
-  status: 'pending' | 'completed' | 'failed' | null;
-  silent: number | null;              // 1 if message should be hidden, 0/null otherwise
-  tool_status: 'success' | 'error' | null; // Status of tool execution (tool messages only)
+function findWranglerConfig(cwd) {
+  const candidates = ["wrangler.jsonc", "wrangler.json"];
+  for (const candidate of candidates) {
+    const configPath = path.join(cwd, candidate);
+    if (fs.existsSync(configPath)) {
+      return configPath;
+    }
+  }
+  return null;
 }
-\`\`\`
-
-The \`tool_status\` column is automatically set when tool messages are created:
-- \`'success'\` - Tool executed successfully
-- \`'error'\` - Tool execution failed or threw an error
-- \`null\` - Not a tool message (role !== 'tool')
-
-## Testing
-
-Example test for a hook:
-
-\`\`\`typescript
-import { defineHook } from '@standardagents/builder';
-import prefilterHook from './prefilter_llm_history';
-
-const mockState = {
-  turnCount: 5,
-  currentSide: 'a',
-  // ... other FlowState fields
-};
-
-const mockMessages = [
-  { role: 'system', content: 'You are helpful' },
-  { role: 'user', content: 'Hello' },
-  { role: 'assistant', content: 'Hi there!' },
-  // ... more messages
-];
-
-const result = await prefilterHook(mockState, mockMessages);
-console.log('Filtered:', result.length, 'messages');
-\`\`\`
-
-## Hook File Naming
-
-**Critical**: Hook files must be named **exactly** as expected:
-- \u2713 \`filter_messages.ts\`
-- \u2713 \`prefilter_llm_history.ts\`
-- \u2713 \`post_process_message.ts\`
-- \u2713 \`before_create_message.ts\`
-- \u2713 \`after_create_message.ts\`
-- \u2713 \`before_update_message.ts\`
-- \u2713 \`after_update_message.ts\`
-- \u2717 \`filterMessages.ts\` (wrong case)
-- \u2717 \`prefilterLLMHistory.ts\` (wrong case)
-- \u2717 \`before-create-message.ts\` (wrong separator)
-
-The file name determines which hook point it intercepts.
-
-## Available Hooks
-
-Currently implemented hooks:
-- \`filter_messages\` - Filter SQL row data before transformation to chat format (access to all DB columns including tool_status)
-- \`prefilter_llm_history\` - Filter messages before sending to LLM (after transformation to chat format)
-- \`before_create_message\` - Before inserting message into database
-- \`after_create_message\` - After message is created in database
-- \`before_update_message\` - Before updating message in database
-- \`after_update_message\` - After message is updated in database
-- \`after_tool_call_success\` - After successful tool execution (can modify result or return null to remove)
-- \`after_tool_call_failure\` - After failed tool execution (can modify error or return null to remove)
-
-## Related
-
-- **Tools**: \`agents/tools/CLAUDE.md\` - Custom tools
-- **APIs**: \`agents/api/CLAUDE.md\` - Thread endpoints
-- **Documentation**: Project root \`CLAUDE.md\` for architecture
-`;
-var API_CLAUDE_MD = `# Thread-Specific API Endpoints
-
-This directory contains custom API endpoints that operate on specific threads.
-
-## What Are Thread Endpoints?
-
-Thread endpoints are API routes that:
-- Automatically receive a specific thread's Durable Object instance
-- Can access thread-local SQLite storage
-- Perform operations in the context of a conversation
-- Use file-based routing for automatic discovery
-
-## File-Based Routing
-
-Create files following this naming convention:
-
-\`\`\`
-agents/api/
-\u251C\u2500\u2500 summary.get.ts          # GET /agents/api/threads/:id/summary
-\u251C\u2500\u2500 export.post.ts          # POST /agents/api/threads/:id/export
-\u251C\u2500\u2500 metadata.put.ts         # PUT /agents/api/threads/:id/metadata
-\u2514\u2500\u2500 archive.delete.ts       # DELETE /agents/api/threads/:id/archive
-\`\`\`
-
-**Pattern**: \`{name}.{method}.ts\`
-
-**Methods**: \`get\`, \`post\`, \`put\`, \`delete\`, \`patch\`
-
-**URL**: \`/agents/api/threads/:id/{name}\`
-
-## Creating a Thread Endpoint
-
-Use \`defineThreadEndpoint\` from \`@standardagents/builder\`:
-
-\`\`\`typescript
-import { defineThreadEndpoint } from '@standardagents/builder';
-
-export default defineThreadEndpoint(async (thread, request, env) => {
-  // thread is the DurableObject stub for the requested thread
-  // request is the incoming Request object
-  // env is the Cloudflare environment with bindings
-
-  // Access thread's storage directly
-  const messages = await thread.getMessages();
-
-  // Perform operations
-  const summary = generateSummary(messages);
-
-  // Return response
-  return new Response(JSON.stringify({ summary }), {
-    headers: { 'Content-Type': 'application/json' }
-  });
-});
-\`\`\`
-
-## Thread Object
-
-The \`thread\` parameter is a DurableObject stub with RPC methods:
-
-\`\`\`typescript
-interface DurableThread {
-  // Get messages from thread's SQLite storage
-  getMessages(limit?: number, offset?: number): Promise<Message[]>;
-
-  // Get execution logs
-  getLogs(limit?: number, offset?: number): Promise<Log[]>;
-
-  // Process a new message (starts agent execution)
-  processMessage(content: string, role?: string): Promise<Response>;
-
-  // Get thread metadata
-  getThreadMeta(threadId: string): Promise<ThreadMetadata>;
-
-  // Direct storage access (advanced)
-  storage: DurableObjectStorage;
+async function modifyViteConfig(configPath, force) {
+  try {
+    const mod = await loadFile(configPath);
+    const code = fs.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",
+        imported: "agentbuilder",
+        constructor: "agentbuilder",
+        options: { mountPoint: "/" }
+      });
+      logger.success("Added agentbuilder plugin to vite.config");
+    }
+    await writeFile(mod, configPath);
+    return true;
+  } catch (error) {
+    logger.warning(`Could not automatically modify vite.config: ${error}`);
+    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("");
+    logger.log(`  plugins: [cloudflare(), agentbuilder({ mountPoint: '/' })]`);
+    logger.log("");
+    return false;
+  }
 }
-\`\`\`
-
-## Examples
-
-### GET Summary Endpoint
-
-\`\`\`typescript
-// agents/api/summary.get.ts
-import { defineThreadEndpoint } from '@standardagents/builder';
-
-export default defineThreadEndpoint(async (thread, request, env) => {
-  // Fetch messages from thread
-  const messages = await thread.getMessages();
-
-  // Generate summary
-  const userMessages = messages.filter(m => m.role === 'user');
-  const assistantMessages = messages.filter(m => m.role === 'assistant');
-
-  return new Response(JSON.stringify({
-    total_messages: messages.length,
-    user_messages: userMessages.length,
-    assistant_messages: assistantMessages.length,
-    first_message: messages[0]?.content,
-    last_message: messages[messages.length - 1]?.content,
-  }), {
-    headers: { 'Content-Type': 'application/json' }
-  });
-});
-\`\`\`
-
-**Usage**: \`GET /agents/api/threads/{threadId}/summary\`
-
-### POST Export Endpoint
-
-\`\`\`typescript
-// agents/api/export.post.ts
-import { defineThreadEndpoint } from '@standardagents/builder';
-
-export default defineThreadEndpoint(async (thread, request, env) => {
-  const { format } = await request.json();
-
-  // Get messages
-  const messages = await thread.getMessages();
-
-  // Export based on format
-  let content: string;
-  let contentType: string;
-
-  if (format === 'json') {
-    content = JSON.stringify(messages, null, 2);
-    contentType = 'application/json';
-  } else if (format === 'markdown') {
-    content = messages
-      .map(m => \`**\${m.role}**: \${m.content}\`)
-      .join('\\n\\n');
-    contentType = 'text/markdown';
-  } else {
-    return new Response('Invalid format', { status: 400 });
+function createOrUpdateWranglerConfig(cwd, projectName, force) {
+  var _a, _b;
+  const existingConfig = findWranglerConfig(cwd);
+  if (existingConfig && !force) {
+    try {
+      const text = fs.readFileSync(existingConfig, "utf-8");
+      const config = parse(text);
+      const hasBindings = (_b = (_a = config.durable_objects) == null ? void 0 : _a.bindings) == null ? void 0 : _b.some(
+        (b) => b.name === "AGENT_BUILDER_THREAD" || b.name === "AGENT_BUILDER"
+      );
+      if (hasBindings) {
+        logger.info("wrangler.jsonc already configured for Standard Agents");
+        return true;
+      }
+      let result = text;
+      if (!config.durable_objects) {
+        const edits = modify(result, ["durable_objects"], {
+          bindings: [
+            { name: "AGENT_BUILDER_THREAD", class_name: "DurableThread" },
+            { name: "AGENT_BUILDER", class_name: "DurableAgentBuilder" }
+          ]
+        }, {});
+        result = applyEdits(result, edits);
+      } else {
+        const bindings = config.durable_objects.bindings || [];
+        bindings.push(
+          { name: "AGENT_BUILDER_THREAD", class_name: "DurableThread" },
+          { name: "AGENT_BUILDER", class_name: "DurableAgentBuilder" }
+        );
+        const edits = modify(result, ["durable_objects", "bindings"], bindings, {});
+        result = applyEdits(result, edits);
+      }
+      if (!config.migrations) {
+        const edits = modify(result, ["migrations"], [
+          { tag: "v1", new_sqlite_classes: ["DurableThread"] },
+          { tag: "v2", new_sqlite_classes: ["DurableAgentBuilder"] }
+        ], {});
+        result = applyEdits(result, edits);
+      }
+      if (!config.main || !config.main.includes("worker")) {
+        const edits = modify(result, ["main"], "worker/index.ts", {});
+        result = applyEdits(result, edits);
+      }
+      if (!config.assets) {
+        const edits = modify(result, ["assets"], {
+          directory: "dist",
+          not_found_handling: "single-page-application",
+          binding: "ASSETS",
+          run_worker_first: ["/**"]
+        }, {});
+        result = applyEdits(result, edits);
+      }
+      fs.writeFileSync(existingConfig, result, "utf-8");
+      logger.success("Updated wrangler.jsonc with Standard Agents configuration");
+      return true;
+    } catch (error) {
+      logger.warning(`Could not update wrangler config: ${error}`);
+      return false;
+    }
   }
-
-  return new Response(content, {
-    headers: {
-      'Content-Type': contentType,
-      'Content-Disposition': \`attachment; filename="thread-export.\${format}"\`
+  const wranglerPath = path.join(cwd, "wrangler.jsonc");
+  const sanitizedName = projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  fs.writeFileSync(wranglerPath, WRANGLER_TEMPLATE(sanitizedName), "utf-8");
+  logger.success("Created wrangler.jsonc");
+  return true;
+}
+function getWorkerEntryPoint(cwd) {
+  const wranglerConfig = findWranglerConfig(cwd);
+  if (wranglerConfig) {
+    try {
+      const text = fs.readFileSync(wranglerConfig, "utf-8");
+      const config = parse(text);
+      if (config.main) {
+        return path.join(cwd, config.main);
+      }
+    } catch {
     }
-  });
-});
-\`\`\`
-
-**Usage**: \`POST /agents/api/threads/{threadId}/export\`
-
-### Direct Storage Access
-
-\`\`\`typescript
-// agents/api/stats.get.ts
-import { defineThreadEndpoint } from '@standardagents/builder';
-
-export default defineThreadEndpoint(async (thread, request, env) => {
-  // Access SQLite storage directly
-  const storage = (thread as any).storage;
-
-  const cursor = await storage.sql.exec(\`
-    SELECT
-      COUNT(*) as count,
-      role,
-      AVG(LENGTH(content)) as avg_length
-    FROM messages
-    GROUP BY role
-  \`);
-
-  const stats = cursor.toArray();
-
-  return new Response(JSON.stringify({ stats }), {
-    headers: { 'Content-Type': 'application/json' }
-  });
-});
-\`\`\`
-
-## Request Handling
-
-### Reading Request Body
-
-\`\`\`typescript
-export default defineThreadEndpoint(async (thread, request, env) => {
-  // JSON
-  const body = await request.json();
-
-  // FormData
-  const formData = await request.formData();
-
-  // Text
-  const text = await request.text();
-
-  // ...
-});
-\`\`\`
-
-### Query Parameters
-
-\`\`\`typescript
-export default defineThreadEndpoint(async (thread, request, env) => {
-  const url = new URL(request.url);
-  const limit = url.searchParams.get('limit') || '10';
-
-  const messages = await thread.getMessages(parseInt(limit));
-
-  // ...
-});
-\`\`\`
-
-### Headers
-
-\`\`\`typescript
-export default defineThreadEndpoint(async (thread, request, env) => {
-  const authHeader = request.headers.get('Authorization');
-
-  if (!authHeader) {
-    return new Response('Unauthorized', { status: 401 });
   }
-
-  // ...
-});
-\`\`\`
-
-## Error Handling
-
-Always wrap in try/catch for robust error handling:
-
-\`\`\`typescript
-export default defineThreadEndpoint(async (thread, request, env) => {
+  return path.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`);
+  }
+  if (!fs.existsSync(entryPath)) {
+    fs.writeFileSync(entryPath, WORKER_INDEX, "utf-8");
+    logger.success(`Created ${path.relative(cwd, entryPath)}`);
+    return true;
+  }
+  const content = fs.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`);
+    return true;
+  }
   try {
-    // Your endpoint logic
-    const result = await doSomething();
-
-    return new Response(JSON.stringify(result), {
-      headers: { 'Content-Type': 'application/json' }
-    });
+    const mod = await loadFile(entryPath);
+    if (!content.includes("virtual:@standardagents/builder") || force) {
+      mod.imports.$add({
+        from: "virtual:@standardagents/builder",
+        imported: "router",
+        local: "router"
+      });
+    }
+    if (!content.includes("'../agents/Thread'") || force) {
+      mod.imports.$add({
+        from: "../agents/Thread",
+        imported: "default",
+        local: "DurableThread"
+      });
+    }
+    if (!content.includes("'../agents/AgentBuilder'") || force) {
+      mod.imports.$add({
+        from: "../agents/AgentBuilder",
+        imported: "default",
+        local: "DurableAgentBuilder"
+      });
+    }
+    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`);
+    }
+    return true;
   } catch (error) {
-    console.error('Endpoint error:', error);
-
-    return new Response(
-      JSON.stringify({
-        error: error.message
-      }),
-      {
-        status: 500,
-        headers: { 'Content-Type': 'application/json' }
-      }
-    );
+    if (force) {
+      fs.writeFileSync(entryPath, WORKER_INDEX, "utf-8");
+      logger.success(`Created ${path.relative(cwd, entryPath)}`);
+      return true;
+    }
+    logger.warning(`Could not automatically modify ${path.relative(cwd, entryPath)}`);
+    logger.log("");
+    logger.log("Please ensure your worker entry point includes:");
+    logger.log("");
+    logger.log(`  import { router } from "virtual:@standardagents/builder"`);
+    logger.log(`  import DurableThread from '../agents/Thread';`);
+    logger.log(`  import DurableAgentBuilder from '../agents/AgentBuilder';`);
+    logger.log("");
+    logger.log("  // In your fetch handler:");
+    logger.log("  const res = router(request, env)");
+    logger.log("  if (res) return res");
+    logger.log("");
+    logger.log("  // Export Durable Objects:");
+    logger.log("  export { DurableThread, DurableAgentBuilder }");
+    logger.log("");
+    return false;
   }
-});
-\`\`\`
-
-## Environment Bindings
-
-Access Cloudflare bindings via \`env\`:
-
-\`\`\`typescript
-export default defineThreadEndpoint(async (thread, request, env) => {
-  // Durable Objects
-  const agentBuilder = env.AGENT_BUILDER.get(env.AGENT_BUILDER.idFromName("singleton"));
-  const threadData = await agentBuilder.getThread(threadId);
-
-  // KV (if configured)
-  const cache = await env.MY_KV.get('cache-key');
-
-  // R2 (if configured)
-  const object = await env.MY_BUCKET.get('file.txt');
-
-  // ...
-});
-\`\`\`
-
-## Auto-Discovery
-
-Thread endpoints are **auto-discovered**:
-
-1. Vite plugin scans this directory on startup
-2. Generates virtual module with dynamic imports
-3. Routes registered in the main router
-4. HMR works in development
-
-No manual registration needed!
-
-## URL Structure
-
-All thread endpoints follow this pattern:
-
-\`\`\`
-/agents/api/threads/:id/{endpoint-name}
-\`\`\`
-
-Examples:
-- \`GET /agents/api/threads/abc-123/summary\`
-- \`POST /agents/api/threads/abc-123/export\`
-- \`PUT /agents/api/threads/abc-123/metadata\`
-
-The \`:id\` is automatically used to fetch the correct Durable Object.
-
-## Built-In Endpoints
-
-Standard Agents includes built-in thread endpoints (these are in the framework, not this directory):
-
-- \`GET /agents/api/threads/:id/messages\` - Get message history
-- \`POST /agents/api/threads/:id/messages\` - Send a message
-- \`DELETE /agents/api/threads/:id\` - Delete thread
-- \`GET /agents/api/threads/:id/logs\` - Get execution logs
-
-Your custom endpoints extend these built-in routes.
-
-## Best Practices
-
-1. **Descriptive Names**: Use clear endpoint names (e.g., \`summary\`, \`export\`)
-2. **Proper HTTP Methods**: Use GET for reads, POST for creates, etc.
-3. **Error Handling**: Always wrap in try/catch
-4. **Type Safety**: Use TypeScript interfaces for request/response
-5. **Performance**: Be mindful of SQLite query performance
-6. **Authentication**: Add auth checks if endpoints are sensitive
-7. **CORS**: Add CORS headers if accessed from browser
-
-## Testing
-
-Test endpoints with curl or any HTTP client:
-
-\`\`\`bash
-# GET summary
-curl http://localhost:8787/agents/api/threads/abc-123/summary
-
-# POST export
-curl -X POST http://localhost:8787/agents/api/threads/abc-123/export \\
-  -H "Content-Type: application/json" \\
-  -d '{"format": "json"}'
-\`\`\`
-
-## Limitations
-
-- No nested directories (endpoints must be directly in this folder)
-- Thread ID must be in URL path (handled automatically)
-- No support for multiple path parameters beyond thread ID
-- Response must be a Web API \`Response\` object
-
-## Related
-
-- **Tools**: \`agents/tools/CLAUDE.md\` - Custom tools
-- **Hooks**: \`agents/hooks/CLAUDE.md\` - Lifecycle hooks
-- **Built-in APIs**: \`packages/builder/src/api/\` - Framework endpoints
-- **Documentation**: Project root \`CLAUDE.md\` for architecture
-`;
-async function scaffold() {
-  const cwd = process.cwd();
-  logger.info("Scaffolding Standard Agents directories...");
+}
+function createDurableObjects(cwd) {
+  const agentsDir = path.join(cwd, "agents");
+  if (!fs.existsSync(agentsDir)) {
+    fs.mkdirSync(agentsDir, { recursive: true });
+  }
+  const threadPath = path.join(agentsDir, "Thread.ts");
+  if (!fs.existsSync(threadPath)) {
+    fs.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");
+    logger.success("Created agents/AgentBuilder.ts");
+  } else {
+    logger.info("agents/AgentBuilder.ts already exists");
+  }
+}
+function createDirectoriesAndDocs(cwd) {
   const directories = [
-    {
-      path: path3.join(cwd, "agents", "tools"),
-      claudeMd: TOOLS_CLAUDE_MD,
-      name: "tools"
-    },
-    {
-      path: path3.join(cwd, "agents", "hooks"),
-      claudeMd: HOOKS_CLAUDE_MD,
-      name: "hooks"
-    },
-    {
-      path: path3.join(cwd, "agents", "api"),
-      claudeMd: API_CLAUDE_MD,
-      name: "api"
-    }
+    { path: "agents/agents", doc: AGENTS_CLAUDE_MD },
+    { path: "agents/prompts", doc: PROMPTS_CLAUDE_MD },
+    { path: "agents/models", doc: MODELS_CLAUDE_MD },
+    { path: "agents/tools", doc: TOOLS_CLAUDE_MD },
+    { path: "agents/hooks", doc: HOOKS_CLAUDE_MD },
+    { path: "agents/api", doc: API_CLAUDE_MD }
   ];
-  let created = 0;
-  let skipped = 0;
   for (const dir of directories) {
-    if (!fs.existsSync(dir.path)) {
-      fs.mkdirSync(dir.path, { recursive: true });
-      logger.success(`Created directory: agents/${dir.name}`);
-      created++;
-    } else {
-      logger.info(`Directory already exists: agents/${dir.name}`);
+    const dirPath = path.join(cwd, dir.path);
+    const docPath = path.join(dirPath, "CLAUDE.md");
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+      logger.success(`Created ${dir.path}`);
+    }
+    if (!fs.existsSync(docPath)) {
+      fs.writeFileSync(docPath, dir.doc, "utf-8");
+      logger.success(`Created ${dir.path}/CLAUDE.md`);
+    }
+  }
+}
+function updateTsConfig(cwd) {
+  var _a;
+  const tsconfigPath = path.join(cwd, "tsconfig.json");
+  if (!fs.existsSync(tsconfigPath)) {
+    logger.info("No tsconfig.json found, skipping TypeScript configuration");
+    return;
+  }
+  try {
+    const text = fs.readFileSync(tsconfigPath, "utf-8");
+    const config = parse(text);
+    let result = text;
+    const types = ((_a = config.compilerOptions) == null ? void 0 : _a.types) || [];
+    const newTypes = [
+      "./worker-configuration.d.ts",
+      "./.agents/types.d.ts",
+      "./.agents/virtual-module.d.ts"
+    ].filter((t) => !types.includes(t));
+    if (newTypes.length > 0) {
+      const allTypes = [...types, ...newTypes];
+      const edits = modify(result, ["compilerOptions", "types"], allTypes, {});
+      result = applyEdits(result, edits);
     }
-    const claudeMdPath = path3.join(dir.path, "CLAUDE.md");
-    if (!fs.existsSync(claudeMdPath)) {
-      fs.writeFileSync(claudeMdPath, dir.claudeMd, "utf-8");
-      logger.success(`Created documentation: agents/${dir.name}/CLAUDE.md`);
-      created++;
+    const include = config.include || [];
+    const newIncludes = ["worker", "agents"].filter((i) => !include.includes(i));
+    if (newIncludes.length > 0) {
+      const allIncludes = [...include, ...newIncludes];
+      const edits = modify(result, ["include"], allIncludes, {});
+      result = applyEdits(result, edits);
+    }
+    if (newTypes.length > 0 || newIncludes.length > 0) {
+      fs.writeFileSync(tsconfigPath, result, "utf-8");
+      logger.success("Updated tsconfig.json with Standard Agents types");
     } else {
-      logger.info(`Documentation already exists: agents/${dir.name}/CLAUDE.md (not overwriting)`);
-      skipped++;
+      logger.info("tsconfig.json already configured");
+    }
+  } catch (error) {
+    logger.warning("Could not update tsconfig.json, you may need to add types manually");
+  }
+}
+function cleanupViteDefaults(cwd) {
+  const filesToRemove = [
+    "src/main.ts",
+    "src/style.css",
+    "src/counter.ts",
+    "src/typescript.svg",
+    "src/vite-env.d.ts",
+    "index.html",
+    "public/vite.svg"
+  ];
+  const dirsToRemove = ["src", "public"];
+  for (const file of filesToRemove) {
+    const filePath = path.join(cwd, file);
+    if (fs.existsSync(filePath)) {
+      try {
+        fs.unlinkSync(filePath);
+      } catch {
+      }
+    }
+  }
+  for (const dir of dirsToRemove) {
+    const dirPath = path.join(cwd, dir);
+    if (fs.existsSync(dirPath)) {
+      try {
+        const files = fs.readdirSync(dirPath);
+        if (files.length === 0) {
+          fs.rmdirSync(dirPath);
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function scaffold(options = {}) {
+  const cwd = process.cwd();
+  const projectName = getProjectName(cwd);
+  const force = options.force || false;
+  logger.info("Scaffolding Standard Agents...");
+  logger.log("");
+  const viteConfigPath = findViteConfig(cwd);
+  if (viteConfigPath) {
+    await modifyViteConfig(viteConfigPath, force);
+  } else {
+    logger.warning("No vite.config found. Please create one with cloudflare and agentbuilder plugins.");
+  }
+  createOrUpdateWranglerConfig(cwd, projectName, force);
+  await createOrUpdateWorkerEntry(cwd, force);
+  createDurableObjects(cwd);
+  createDirectoriesAndDocs(cwd);
+  updateTsConfig(cwd);
+  if (force) {
+    cleanupViteDefaults(cwd);
+  }
+  logger.log("");
+  logger.success("Standard Agents scaffolding complete!");
+  logger.log("");
+  logger.log("Your project structure:");
+  logger.log("");
+  logger.log("  agents/");
+  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");
+  logger.log("  \u251C\u2500\u2500 prompts/            # Prompt definitions");
+  logger.log("  \u251C\u2500\u2500 models/             # Model configurations");
+  logger.log("  \u251C\u2500\u2500 tools/              # Custom tools");
+  logger.log("  \u251C\u2500\u2500 hooks/              # Lifecycle hooks");
+  logger.log("  \u2514\u2500\u2500 api/                # Thread API endpoints");
+  logger.log("  worker/");
+  logger.log("  \u2514\u2500\u2500 index.ts            # Cloudflare Worker entry point");
+  logger.log("");
+}
+
+// src/commands/init.ts
+async function prompt(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 runCommand(command, args, cwd) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: "inherit",
+      shell: true
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve2();
+      } else {
+        reject(new Error(`Command failed with exit code ${code}`));
+      }
+    });
+    child.on("error", reject);
+  });
+}
+function detectPackageManager() {
+  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 (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";
+  return "npm";
+}
+async function init(projectNameArg, options = {}) {
+  const cwd = process.cwd();
+  const pm = detectPackageManager();
+  const template = options.template || "vanilla-ts";
+  logger.log("");
+  logger.info("Creating a new Standard Agents project...");
+  logger.log("");
+  let projectName = projectNameArg;
+  if (!projectName && !options.yes) {
+    projectName = await prompt("Project name: ");
+  }
+  if (!projectName) {
+    logger.error("Project name is required");
+    process.exit(1);
+  }
+  const projectPath = path.join(cwd, projectName);
+  if (fs.existsSync(projectPath)) {
+    logger.error(`Directory "${projectName}" already exists`);
+    process.exit(1);
+  }
+  logger.log("");
+  logger.info(`Step 1: Creating Vite project with ${template} template...`);
+  logger.log("");
+  try {
+    let createCmd;
+    let createArgs;
+    switch (pm) {
+      case "pnpm":
+        createCmd = "pnpm";
+        createArgs = ["create", "vite@latest", projectName, "--template", template, "--no-interactive"];
+        break;
+      case "yarn":
+        createCmd = "yarn";
+        createArgs = ["create", "vite@latest", projectName, "--template", template, "--no-interactive"];
+        break;
+      case "bun":
+        createCmd = "bun";
+        createArgs = ["create", "vite@latest", projectName, "--template", template, "--no-interactive"];
+        break;
+      default:
+        createCmd = "npm";
+        createArgs = ["create", "vite@latest", projectName, "--", "--template", template, "--no-interactive"];
     }
+    await runCommand(createCmd, createArgs, cwd);
+  } catch (error) {
+    logger.error("Failed to create Vite project");
+    process.exit(1);
   }
+  const viteConfigPath = path.join(projectPath, "vite.config.ts");
+  if (!fs.existsSync(viteConfigPath)) {
+    const viteConfigContent = `import { defineConfig } from 'vite'
+
+export default defineConfig({
+  plugins: [],
+})
+`;
+    fs.writeFileSync(viteConfigPath, viteConfigContent, "utf-8");
+    logger.success("Created vite.config.ts");
+  }
+  logger.log("");
+  logger.info("Step 2: Installing Standard Agents dependencies...");
   logger.log("");
-  if (created > 0) {
-    logger.success(`Scaffolding complete! Created ${created} file(s).`);
+  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"
+    ], projectPath);
+  } catch (error) {
+    logger.error("Failed to install dependencies");
+    process.exit(1);
   }
-  if (skipped > 0) {
-    logger.info(`Skipped ${skipped} existing file(s).`);
+  logger.log("");
+  logger.info("Step 3: Configuring Standard Agents...");
+  logger.log("");
+  process.chdir(projectPath);
+  await scaffold({ force: true });
+  logger.log("");
+  logger.info("Step 4: Generating Cloudflare types...");
+  logger.log("");
+  try {
+    await runCommand("npx", ["wrangler", "types"], projectPath);
+  } catch (error) {
+    logger.warning('Could not generate types automatically. Run "npx wrangler types" manually.');
   }
-  logger.log("\nNext steps:");
-  logger.log("1. Read the CLAUDE.md files in each directory for detailed documentation");
-  logger.log("2. Create your first tool in agents/tools/");
-  logger.log("3. Add lifecycle hooks in agents/hooks/ (optional)");
-  logger.log("4. Create custom thread endpoints in agents/api/ (optional)");
+  logger.log("");
+  logger.success("Project created successfully!");
+  logger.log("");
+  logger.log("Next steps:");
+  logger.log("");
+  logger.log(`  cd ${projectName}`);
+  logger.log(`  ${pm === "npm" ? "npm run" : pm} dev`);
+  logger.log("");
+  logger.log("For more information, visit: https://standardagents.ai/docs");
 }
 
 // src/index.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var pkg = JSON.parse(readFileSync(resolve(__dirname, "../package.json"), "utf-8"));
 var program = new Command();
-program.name("agentbuilder").description("CLI tool for AgentBuilder initialization").version("0.0.0");
-program.command("init").description("Initialize AgentBuilder configuration in wrangler.jsonc").option("--force", "Overwrite existing configuration").action(init);
-program.command("scaffold").description("Create agentbuilder directories (tools, hooks, api) with documentation").action(scaffold);
+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.parse();
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map