@standardagents/builder 0.8.1

package/dist/plugin.js

@@ -0,0 +1,3183 @@
+import fs2 from 'fs';
+import path3 from 'path';
+import { fileURLToPath } from 'url';
+
+// src/plugin.ts
+var TSCONFIG_CONTENT = `{
+  "compilerOptions": {
+    "composite": true,
+    "declaration": true,
+    "declarationMap": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "moduleResolution": "bundler",
+    "module": "ESNext",
+    "target": "ESNext"
+  },
+  "include": ["types.d.ts", "virtual-module.d.ts"]
+}
+`;
+function scanForNames(dir, useFilename = false) {
+  const names = [];
+  if (!fs2.existsSync(dir)) {
+    return names;
+  }
+  try {
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".ts")) {
+        const filePath = path3.join(dir, entry.name);
+        const content = fs2.readFileSync(filePath, "utf-8");
+        if (useFilename) {
+          const toolName = entry.name.replace(/\.ts$/, "");
+          if (content.includes("defineTool")) {
+            names.push(toolName);
+          }
+        } else {
+          const nameMatch = content.match(/name:\s*['"]([^'"]+)['"]/);
+          if (nameMatch) {
+            names.push(nameMatch[1]);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    console.error(`Error scanning directory ${dir}:`, error);
+  }
+  return names;
+}
+function generateRegistryProperties(names) {
+  if (names.length === 0) {
+    return "";
+  }
+  return names.map((n) => `'${n}': true;`).join("\n      ");
+}
+function generateTypesContent(config) {
+  const models = scanForNames(config.modelsDir);
+  const prompts = scanForNames(config.promptsDir);
+  const agents = scanForNames(config.agentsDir);
+  const tools = scanForNames(config.toolsDir, true);
+  const callables = [...prompts, ...agents, ...tools];
+  return `// Auto-generated by @standardagents/builder - DO NOT EDIT
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+//
+// This file augments the AgentBuilder namespace declared in @standardagents/builder
+// to provide type-safe references for your models, prompts, agents, and tools.
+
+/**
+ * Augment the global AgentBuilder namespace with your project's specific types.
+ * This provides autocomplete and type checking for model, prompt, agent, and tool references.
+ *
+ * Uses interface declaration merging with property keys to create union types.
+ * Example: interface ModelRegistry { 'gpt-4o': true; } gives type Models = 'gpt-4o'
+ */
+declare global {
+  namespace AgentBuilder {
+    /** Model names from agents/models/ */
+    interface ModelRegistry {
+      ${generateRegistryProperties(models)}
+    }
+
+    /** Prompt names from agents/prompts/ */
+    interface PromptRegistry {
+      ${generateRegistryProperties(prompts)}
+    }
+
+    /** Agent names from agents/agents/ */
+    interface AgentRegistry {
+      ${generateRegistryProperties(agents)}
+    }
+
+    /** Tool names from agents/tools/ */
+    interface ToolRegistry {
+      ${generateRegistryProperties(tools)}
+    }
+
+    /** All callable items (prompts, agents, tools) that can be used as tools */
+    interface CallableRegistry {
+      ${generateRegistryProperties(callables)}
+    }
+  }
+}
+
+// This export is required for TypeScript to treat this as a module
+// and allow the declare global to work properly
+export {};
+`;
+}
+function generateVirtualModuleContent() {
+  return `// Auto-generated by @standardagents/builder - DO NOT EDIT
+//
+// Type declarations for the virtual:@standardagents/builder module.
+// This file must NOT have any exports to work as an ambient module declaration.
+
+/**
+ * Type declarations for the consolidated virtual module.
+ * This module provides DurableThread and DurableAgentBuilder classes
+ * with all virtual module methods (tools, hooks, models, prompts, agents)
+ * already implemented, plus the router function.
+ */
+declare module 'virtual:@standardagents/builder' {
+  import type { DurableThread as BaseDurableThread } from '@standardagents/builder/runtime';
+  import type { DurableAgentBuilder as BaseDurableAgentBuilder } from '@standardagents/builder/runtime';
+  import type { ThreadEnv } from '@standardagents/builder/runtime';
+
+  // ============================================================
+  // Message Types
+  // ============================================================
+
+  export interface ThreadMessage {
+    id: string;
+    role: string;
+    content: string | null;
+    name: string | null;
+    tool_calls: string | null;
+    tool_call_id: string | null;
+    tool_status: 'success' | 'error' | null;
+    log_id: string | null;
+    created_at: number;
+    silent: boolean;
+    parent_id: string | null;
+    depth: number;
+    status: 'pending' | 'completed' | 'failed' | null;
+    reasoning_content: string | null;
+    reasoning_details: string | null;
+  }
+
+  export interface GetMessagesResult {
+    messages: ThreadMessage[];
+    total: number;
+    hasMore: boolean;
+  }
+
+  // ============================================================
+  // Log Types
+  // ============================================================
+
+  export interface ThreadLog {
+    id: string;
+    message_id: string;
+    provider: string;
+    model: string;
+    model_name: string | null;
+    prompt_name: string | null;
+    tools_called: string | null;
+    parent_log_id: string | null;
+    retry_of_log_id: string | null;
+    error: string | null;
+    cost_total: number | null;
+    is_complete: boolean;
+    created_at: number;
+    request_body: string | null;
+  }
+
+  export interface GetLogsResult {
+    logs: ThreadLog[];
+    total: number;
+    hasMore: boolean;
+  }
+
+  export interface ThreadLogDetails extends ThreadLog {
+    endpoint: string | null;
+    request_headers: string | null;
+    response_body: string | null;
+    response_headers: string | null;
+    status_code: number | null;
+    reasoning_content: string | null;
+    input_tokens: number | null;
+    cached_tokens: number | null;
+    output_tokens: number | null;
+    reasoning_tokens: number | null;
+    total_tokens: number | null;
+    latency_ms: number | null;
+    time_to_first_token_ms: number | null;
+    finish_reason: string | null;
+    error_type: string | null;
+    cost_input: number | null;
+    cost_output: number | null;
+    message_history_length: number | null;
+    tools_available: number | null;
+    tools_schema: string | null;
+    message_history: string | null;
+    system_prompt: string | null;
+    errors: string | null;
+    tool_results: string | null;
+  }
+
+  // ============================================================
+  // Thread Metadata Types
+  // ============================================================
+
+  export interface ThreadMetaResult {
+    thread: {
+      id: string;
+      agent_id: string;
+      user_id: string | null;
+      tags: string[];
+      created_at: number;
+    };
+    agent: {
+      id: string;
+      title: string;
+      type: string;
+      side_a_label?: string;
+      side_b_label?: string;
+    } | null;
+    stats: {
+      message_count: number;
+      log_count: number;
+    };
+  }
+
+  // ============================================================
+  // DurableThread Class
+  // ============================================================
+
+  /**
+   * DurableThread with all virtual module methods pre-implemented.
+   * Extend this class in your agents/Thread.ts file.
+   *
+   * @example
+   * \`\`\`typescript
+   * import { DurableThread } from 'virtual:@standardagents/builder'
+   *
+   * export class Thread extends DurableThread {}
+   * \`\`\`
+   */
+  export class DurableThread extends BaseDurableThread {
+    // Virtual module registry methods
+    tools(): Record<string, () => Promise<any>>;
+    hooks(): Record<string, () => Promise<any>>;
+    models(): Record<string, () => Promise<any>>;
+    prompts(): Record<string, () => Promise<any>>;
+    agents(): Record<string, () => Promise<any>>;
+
+    // Lookup methods
+    loadModel(name: string): Promise<any>;
+    getModelNames(): string[];
+    loadPrompt(name: string): Promise<any>;
+    getPromptNames(): string[];
+    loadAgent(name: string): Promise<any>;
+    getAgentNames(): string[];
+
+    // Execution methods
+    execute(
+      threadId: string,
+      agentId: string,
+      initial_messages?: any[],
+      data?: any
+    ): Promise<Response>;
+    sendMessage(
+      threadId: string,
+      content: string,
+      role?: string
+    ): Promise<Response>;
+    stop(): Promise<Response>;
+    shouldStop(): Promise<boolean>;
+
+    // Message methods
+    getMessages(
+      limit?: number,
+      offset?: number,
+      order?: 'ASC' | 'DESC',
+      includeSilent?: boolean,
+      maxDepth?: number
+    ): Promise<GetMessagesResult>;
+    deleteMessage(messageId: string): Promise<{ success: boolean; error?: string }>;
+    seedMessages(args: {
+      messages: Array<{
+        id: string;
+        role: string;
+        content: string;
+        created_at: number;
+      }>;
+    }): Promise<{ success: boolean; count?: number; error?: string }>;
+
+    // Log methods
+    getLogs(
+      limit?: number,
+      offset?: number,
+      order?: 'ASC' | 'DESC'
+    ): Promise<GetLogsResult>;
+    getLogDetails(logId: string): Promise<ThreadLogDetails>;
+
+    // Thread management methods
+    getThreadMeta(threadId: string): Promise<ThreadMetaResult>;
+    updateThreadMeta(
+      threadId: string,
+      params: UpdateThreadParams
+    ): Promise<{
+      success: boolean;
+      error?: string;
+      thread?: {
+        id: string;
+        agent_id: string;
+        user_id: string | null;
+        tags: string[];
+        created_at: number;
+      };
+    }>;
+    deleteThread(): Promise<{ success: boolean; message: string }>;
+
+    // WebSocket/fetch handler
+    fetch(request: Request): Promise<Response>;
+  }
+
+  // ============================================================
+  // DurableAgentBuilder Types
+  // ============================================================
+
+  export interface ThreadRegistryEntry {
+    id: string;
+    agent_name: string;
+    user_id: string | null;
+    tags: string[] | null;
+    created_at: number;
+  }
+
+  export interface UpdateThreadParams {
+    agent_name?: string;
+    user_id?: string | null;
+    tags?: string[] | null;
+  }
+
+  export interface User {
+    id: string;
+    username: string;
+    password_hash: string;
+    role: 'admin';
+    created_at: number;
+    updated_at: number;
+  }
+
+  export interface Provider {
+    name: string;
+    sdk: string;
+    api_key: string;
+  }
+
+  // ============================================================
+  // DurableAgentBuilder Class
+  // ============================================================
+
+  /**
+   * DurableAgentBuilder with all virtual module methods pre-implemented.
+   * Extend this class in your agents/AgentBuilder.ts file.
+   *
+   * @example
+   * \`\`\`typescript
+   * import { DurableAgentBuilder } from 'virtual:@standardagents/builder'
+   *
+   * export class AgentBuilder extends DurableAgentBuilder {}
+   * \`\`\`
+   */
+  export class DurableAgentBuilder extends BaseDurableAgentBuilder {
+    // Virtual module registry methods
+    tools(): Record<string, () => Promise<any>>;
+    hooks(): Record<string, () => Promise<any>>;
+    models(): Record<string, () => Promise<any>>;
+    prompts(): Record<string, () => Promise<any>>;
+    agents(): Record<string, () => Promise<any>>;
+
+    // Lookup methods
+    loadModel(name: string): Promise<any>;
+    getModelNames(): string[];
+    loadPrompt(name: string): Promise<any>;
+    getPromptNames(): string[];
+    loadAgent(name: string): Promise<any>;
+    getAgentNames(): string[];
+
+    // Thread registry methods
+    createThread(params: {
+      agent_name: string;
+      user_id?: string;
+      tags?: string[];
+    }): Promise<ThreadRegistryEntry>;
+    getThread(id: string): Promise<ThreadRegistryEntry | null>;
+    listThreads(params?: {
+      agent_name?: string;
+      user_id?: string;
+      limit?: number;
+      offset?: number;
+    }): Promise<{ threads: ThreadRegistryEntry[]; total: number }>;
+    deleteThread(id: string): Promise<boolean>;
+    updateThreadAgent(id: string, agent_name: string): Promise<boolean>;
+    updateThread(id: string, params: UpdateThreadParams): Promise<ThreadRegistryEntry | null>;
+    getThreadStub(threadId: string): DurableObjectStub;
+
+    // Provider methods
+    getProvider(name: string): Promise<Provider | null>;
+    setProvider(provider: Provider): Promise<void>;
+    listProviders(): Promise<Provider[]>;
+    deleteProvider(name: string): Promise<boolean>;
+
+    // User methods
+    getUserByUsername(username: string): Promise<User | null>;
+    getUserById(id: string): Promise<User | null>;
+    createUser(params: {
+      username: string;
+      password_hash: string;
+      role?: 'admin';
+    }): Promise<User>;
+    hasUsers(): Promise<boolean>;
+    listUsers(): Promise<Array<{
+      id: string;
+      username: string;
+      role: 'admin';
+      created_at: number;
+      updated_at: number;
+    }>>;
+    updateUser(
+      id: string,
+      params: {
+        username?: string;
+        password_hash?: string;
+        role?: 'admin';
+      }
+    ): Promise<User | null>;
+    deleteUser(id: string): Promise<boolean>;
+
+    // Session methods
+    createSession(params: {
+      user_id: string;
+      token_hash: string;
+      expires_at: number;
+    }): Promise<string>;
+    validateSession(tokenHash: string): Promise<{ user_id: string; expires_at: number } | null>;
+    cleanupSessions(): Promise<number>;
+    deleteSession(tokenHash: string): Promise<void>;
+
+    // API key methods
+    createApiKey(params: {
+      name: string;
+      key_hash: string;
+      key_prefix: string;
+      last_five: string;
+      user_id: string;
+    }): Promise<string>;
+    validateApiKey(keyHash: string): Promise<{ user_id: string; id: string } | null>;
+    listApiKeys(userId: string): Promise<Array<{
+      id: string;
+      name: string;
+      key_prefix: string;
+      last_five: string;
+      created_at: number;
+      last_used_at: number | null;
+    }>>;
+    deleteApiKey(id: string, userId: string): Promise<boolean>;
+
+    // OAuth methods
+    linkOAuthAccount(params: {
+      user_id: string;
+      provider: 'github' | 'google';
+      provider_user_id: string;
+      provider_username?: string;
+    }): Promise<void>;
+    findUserByOAuth(
+      provider: 'github' | 'google',
+      providerUserId: string
+    ): Promise<User | null>;
+
+    // Edit lock methods (for GitHub integration)
+    acquireEditLock(params: {
+      locked_by: string;
+      lock_reason: string;
+    }): Promise<boolean>;
+    releaseEditLock(lockedBy: string): Promise<boolean>;
+    getEditLockState(): Promise<{
+      locked: boolean;
+      locked_by: string | null;
+      locked_at: number | null;
+      lock_reason: string | null;
+      pending_changes: string | null;
+    }>;
+    setPendingChanges(changes: string): Promise<void>;
+
+    // WebSocket/fetch handler
+    fetch(request: Request): Promise<Response>;
+  }
+
+  // ============================================================
+  // Router Function
+  // ============================================================
+
+  /**
+   * Main router function for handling incoming requests.
+   * Routes requests to the appropriate API endpoint or serves the UI.
+   *
+   * @example
+   * \`\`\`typescript
+   * import { router } from 'virtual:@standardagents/builder'
+   *
+   * export default {
+   *   async fetch(request: Request, env: Env) {
+   *     const response = await router(request, env);
+   *     return response ?? new Response('Not Found', { status: 404 });
+   *   }
+   * }
+   * \`\`\`
+   */
+  export function router<Env extends ThreadEnv = ThreadEnv>(
+    request: Request,
+    env: Env
+  ): Promise<Response | null>;
+}
+
+/**
+ * Legacy alias for the router module.
+ * @deprecated Use \`import { router } from 'virtual:@standardagents/builder'\` instead.
+ */
+declare module 'virtual:@standardagents/router' {
+  import type { ThreadEnv } from '@standardagents/builder/runtime';
+
+  export function router<Env extends ThreadEnv = ThreadEnv>(
+    request: Request,
+    env: Env
+  ): Promise<Response | null>;
+
+  export { DurableThread } from 'virtual:@standardagents/builder';
+}
+`;
+}
+function ensureDir(dir) {
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+}
+function generateTypes(config) {
+  ensureDir(config.outputDir);
+  const typesContent = generateTypesContent(config);
+  fs2.writeFileSync(path3.join(config.outputDir, "types.d.ts"), typesContent);
+  const virtualModuleContent = generateVirtualModuleContent();
+  fs2.writeFileSync(path3.join(config.outputDir, "virtual-module.d.ts"), virtualModuleContent);
+  fs2.writeFileSync(path3.join(config.outputDir, "tsconfig.json"), TSCONFIG_CONTENT);
+  fs2.writeFileSync(path3.join(config.outputDir, ".gitignore"), "*\n");
+}
+function needsRegeneration(config) {
+  const typesPath = path3.join(config.outputDir, "types.d.ts");
+  if (!fs2.existsSync(typesPath)) {
+    return true;
+  }
+  const typesMtime = fs2.statSync(typesPath).mtime;
+  const dirs = [config.modelsDir, config.promptsDir, config.agentsDir, config.toolsDir];
+  for (const dir of dirs) {
+    if (!fs2.existsSync(dir)) {
+      continue;
+    }
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".ts")) {
+        const filePath = path3.join(dir, entry.name);
+        const fileMtime = fs2.statSync(filePath).mtime;
+        if (fileMtime > typesMtime) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+// src/sdk/generators/generateModelFile.ts
+function generateModelFile(data) {
+  const lines = [
+    `import { defineModel } from '@standardagents/builder';`,
+    "",
+    `export default defineModel({`,
+    `  name: '${escapeString(data.name)}',`,
+    `  provider: '${escapeString(data.provider)}',`,
+    `  model: '${escapeString(data.model)}',`
+  ];
+  if (data.includedProviders && data.includedProviders.length > 0) {
+    lines.push(`  includedProviders: ${JSON.stringify(data.includedProviders)},`);
+  }
+  if (data.fallbacks && data.fallbacks.length > 0) {
+    lines.push(`  fallbacks: ${JSON.stringify(data.fallbacks)},`);
+  }
+  if (data.inputPrice !== void 0) {
+    lines.push(`  inputPrice: ${data.inputPrice},`);
+  }
+  if (data.outputPrice !== void 0) {
+    lines.push(`  outputPrice: ${data.outputPrice},`);
+  }
+  if (data.cachedPrice !== void 0) {
+    lines.push(`  cachedPrice: ${data.cachedPrice},`);
+  }
+  lines.push(`});`);
+  lines.push("");
+  return lines.join("\n");
+}
+function escapeString(str) {
+  return str.replace(/'/g, "\\'").replace(/\\/g, "\\\\");
+}
+
+// src/sdk/generators/jsonSchemaToZod.ts
+function jsonSchemaToZod(schema, indent = 0) {
+  if (!schema || Object.keys(schema).length === 0) {
+    return "z.any()";
+  }
+  if (schema.anyOf && schema.anyOf.length > 0) {
+    const types = schema.anyOf.map((s) => jsonSchemaToZod(s, indent));
+    if (types.length === 1) {
+      return types[0];
+    }
+    return `z.union([${types.join(", ")}])`;
+  }
+  if (schema.oneOf && schema.oneOf.length > 0) {
+    const types = schema.oneOf.map((s) => jsonSchemaToZod(s, indent));
+    if (types.length === 1) {
+      return types[0];
+    }
+    return `z.union([${types.join(", ")}])`;
+  }
+  if (schema.allOf && schema.allOf.length > 0) {
+    const types = schema.allOf.map((s) => jsonSchemaToZod(s, indent));
+    if (types.length === 1) {
+      return types[0];
+    }
+    return types.reduce((acc, t) => `${acc}.and(${t})`);
+  }
+  if (schema.const !== void 0) {
+    return `z.literal(${JSON.stringify(schema.const)})`;
+  }
+  if (schema.enum && schema.enum.length > 0) {
+    const values = schema.enum.map((v) => JSON.stringify(v));
+    if (values.length === 1) {
+      return `z.literal(${values[0]})`;
+    }
+    return `z.enum([${values.join(", ")}])`;
+  }
+  switch (schema.type) {
+    case "string":
+      return buildStringSchema(schema);
+    case "number":
+    case "integer":
+      return buildNumberSchema(schema);
+    case "boolean":
+      return addDescription("z.boolean()", schema.description);
+    case "null":
+      return addDescription("z.null()", schema.description);
+    case "array":
+      return buildArraySchema(schema, indent);
+    case "object":
+      return buildObjectSchema(schema, indent);
+    default:
+      return "z.any()";
+  }
+}
+function buildStringSchema(schema) {
+  let code = "z.string()";
+  if (schema.minLength !== void 0) {
+    code += `.min(${schema.minLength})`;
+  }
+  if (schema.maxLength !== void 0) {
+    code += `.max(${schema.maxLength})`;
+  }
+  if (schema.pattern) {
+    code += `.regex(/${escapeRegex(schema.pattern)}/)`;
+  }
+  if (schema.format) {
+    switch (schema.format) {
+      case "email":
+        code += ".email()";
+        break;
+      case "uri":
+      case "url":
+        code += ".url()";
+        break;
+      case "uuid":
+        code += ".uuid()";
+        break;
+      case "date-time":
+        code += ".datetime()";
+        break;
+      case "date":
+        code += ".date()";
+        break;
+      case "time":
+        code += ".time()";
+        break;
+      case "ipv4":
+        code += '.ip({ version: "v4" })';
+        break;
+      case "ipv6":
+        code += '.ip({ version: "v6" })';
+        break;
+    }
+  }
+  return addDescription(code, schema.description);
+}
+function buildNumberSchema(schema) {
+  let code = schema.type === "integer" ? "z.number().int()" : "z.number()";
+  if (schema.minimum !== void 0) {
+    code += `.min(${schema.minimum})`;
+  }
+  if (schema.maximum !== void 0) {
+    code += `.max(${schema.maximum})`;
+  }
+  return addDescription(code, schema.description);
+}
+function buildArraySchema(schema, indent) {
+  const itemsSchema = schema.items ? jsonSchemaToZod(schema.items, indent) : "z.any()";
+  let code = `z.array(${itemsSchema})`;
+  return addDescription(code, schema.description);
+}
+function buildObjectSchema(schema, indent) {
+  if (!schema.properties || Object.keys(schema.properties).length === 0) {
+    if (schema.additionalProperties === false) {
+      return addDescription("z.object({})", schema.description);
+    }
+    return addDescription("z.record(z.any())", schema.description);
+  }
+  const required = new Set(schema.required || []);
+  const spaces = "  ".repeat(indent + 1);
+  const closingSpaces = "  ".repeat(indent);
+  const props = Object.entries(schema.properties).map(([key, propSchema]) => {
+    let propCode = jsonSchemaToZod(propSchema, indent + 1);
+    if (propSchema.nullable) {
+      propCode += ".nullable()";
+    }
+    if (!required.has(key)) {
+      propCode += ".optional()";
+    }
+    if (propSchema.default !== void 0) {
+      propCode += `.default(${JSON.stringify(propSchema.default)})`;
+    }
+    return `${spaces}${safePropertyKey(key)}: ${propCode}`;
+  });
+  const propsStr = props.join(",\n");
+  let code = `z.object({
+${propsStr}
+${closingSpaces}})`;
+  if (schema.additionalProperties === false) {
+    code += ".strict()";
+  }
+  return addDescription(code, schema.description);
+}
+function addDescription(code, description) {
+  if (description) {
+    return `${code}.describe(${JSON.stringify(description)})`;
+  }
+  return code;
+}
+function escapeRegex(pattern) {
+  return pattern.replace(/\//g, "\\/");
+}
+function safePropertyKey(key) {
+  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)) {
+    return key;
+  }
+  return JSON.stringify(key);
+}
+function isEmptySchema(schema) {
+  if (!schema) return true;
+  if (Object.keys(schema).length === 0) return true;
+  if (schema.type === "object" && (!schema.properties || Object.keys(schema.properties).length === 0) && (!schema.required || schema.required.length === 0)) {
+    return true;
+  }
+  return false;
+}
+
+// src/sdk/generators/generatePromptFile.ts
+function generatePromptFile(data) {
+  const hasSchema = data.requiredSchema && !isEmptySchema(data.requiredSchema);
+  const lines = [`import { definePrompt } from '@standardagents/builder';`];
+  if (hasSchema) {
+    lines.push(`import { z } from 'zod';`);
+  }
+  lines.push("");
+  lines.push(`export default definePrompt({`);
+  lines.push(`  name: '${escapeString2(data.name)}',`);
+  if (data.toolDescription) {
+    lines.push(`  toolDescription: '${escapeString2(data.toolDescription)}',`);
+  }
+  if (data.prompt !== void 0) {
+    const promptCode = formatPromptContent(data.prompt);
+    lines.push(`  prompt: ${promptCode},`);
+  }
+  lines.push(`  model: '${escapeString2(data.model)}',`);
+  if (data.includeChat !== void 0) {
+    lines.push(`  includeChat: ${data.includeChat},`);
+  }
+  if (data.includePastTools !== void 0) {
+    lines.push(`  includePastTools: ${data.includePastTools},`);
+  }
+  if (data.parallelToolCalls !== void 0) {
+    lines.push(`  parallelToolCalls: ${data.parallelToolCalls},`);
+  }
+  if (data.toolChoice && data.toolChoice !== "auto") {
+    lines.push(`  toolChoice: '${data.toolChoice}',`);
+  }
+  if (data.tools && data.tools.length > 0) {
+    const toolsCode = formatToolsArray(data.tools);
+    lines.push(`  tools: ${toolsCode},`);
+  }
+  if (data.handoffAgents && data.handoffAgents.length > 0) {
+    const agentsStr = data.handoffAgents.map((a) => `'${escapeString2(a)}'`).join(", ");
+    lines.push(`  handoffAgents: [${agentsStr}],`);
+  }
+  if (data.beforeTool) {
+    lines.push(`  beforeTool: '${escapeString2(data.beforeTool)}',`);
+  }
+  if (data.afterTool) {
+    lines.push(`  afterTool: '${escapeString2(data.afterTool)}',`);
+  }
+  if (data.reasoning && hasNonNullProperties(data.reasoning)) {
+    const reasoningCode = formatReasoningConfig(data.reasoning);
+    lines.push(`  reasoning: ${reasoningCode},`);
+  }
+  if (hasSchema) {
+    const zodCode = jsonSchemaToZod(data.requiredSchema, 1);
+    lines.push(`  requiredSchema: ${zodCode},`);
+  }
+  lines.push(`});`);
+  lines.push("");
+  return lines.join("\n");
+}
+function hasNonNullProperties(obj) {
+  return Object.values(obj).some((v) => v !== null && v !== void 0);
+}
+function formatToolsArray(tools) {
+  const formatted = tools.map((tool) => {
+    if (typeof tool === "string") {
+      return `'${escapeString2(tool)}'`;
+    }
+    return formatToolConfig(tool);
+  });
+  if (formatted.length === 1) {
+    return `[${formatted[0]}]`;
+  }
+  const indented = formatted.map((t) => `    ${t}`).join(",\n");
+  return `[
+${indented}
+  ]`;
+}
+function formatToolConfig(config) {
+  const parts = [];
+  parts.push(`name: '${escapeString2(config.name)}'`);
+  if (config.include_text_response !== void 0 && config.include_text_response !== true) {
+    parts.push(`includeTextResponse: ${config.include_text_response}`);
+  }
+  if (config.include_tool_calls !== void 0 && config.include_tool_calls !== true) {
+    parts.push(`includeToolCalls: ${config.include_tool_calls}`);
+  }
+  if (config.include_errors !== void 0 && config.include_errors !== true) {
+    parts.push(`includeErrors: ${config.include_errors}`);
+  }
+  if (config.init_user_message_property !== void 0 && config.init_user_message_property !== null) {
+    parts.push(`initUserMessageProperty: '${escapeString2(config.init_user_message_property)}'`);
+  }
+  return `{ ${parts.join(", ")} }`;
+}
+function formatReasoningConfig(reasoning) {
+  if (!reasoning) return "{}";
+  const parts = [];
+  if (reasoning.effort !== void 0 && reasoning.effort !== null) {
+    parts.push(`effort: '${reasoning.effort}'`);
+  }
+  if (reasoning.maxTokens !== void 0 && reasoning.maxTokens !== null) {
+    parts.push(`maxTokens: ${reasoning.maxTokens}`);
+  }
+  if (reasoning.exclude !== void 0 && reasoning.exclude !== null) {
+    parts.push(`exclude: ${reasoning.exclude}`);
+  }
+  if (reasoning.include !== void 0 && reasoning.include !== null) {
+    parts.push(`include: ${reasoning.include}`);
+  }
+  if (parts.length === 0) {
+    return "{}";
+  }
+  return `{ ${parts.join(", ")} }`;
+}
+function escapeString2(str) {
+  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function escapeTemplateLiteral(str) {
+  return str.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\${/g, "\\${");
+}
+function parsePromptContent(prompt) {
+  if (!prompt) return null;
+  if (Array.isArray(prompt)) {
+    return prompt;
+  }
+  if (typeof prompt === "string") {
+    try {
+      const parsed = JSON.parse(prompt);
+      if (Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function formatPromptContent(prompt) {
+  if (!prompt) return "''";
+  const parts = parsePromptContent(prompt);
+  if (parts !== null) {
+    return formatStructuredPrompt(parts);
+  }
+  if (typeof prompt === "string") {
+    if (prompt.includes("\n")) {
+      return `\`${escapeTemplateLiteral(prompt)}\``;
+    }
+    return `'${escapeString2(prompt)}'`;
+  }
+  return "''";
+}
+function formatStructuredPrompt(parts) {
+  if (parts.length === 0) {
+    return "[]";
+  }
+  const normalizedParts = parts.map(normalizePart);
+  if (normalizedParts.length === 1 && normalizedParts[0].type === "text") {
+    const content = normalizedParts[0].content || "";
+    if (!content.includes("\n") && content.length < 50) {
+      return `[{ type: 'text', content: '${escapeString2(content)}' }]`;
+    }
+  }
+  const formattedParts = normalizedParts.map((part) => {
+    if (part.type === "text") {
+      const content = part.content || "";
+      if (content.includes("\n")) {
+        return `    { type: 'text', content: \`${escapeTemplateLiteral(content)}\` }`;
+      }
+      return `    { type: 'text', content: '${escapeString2(content)}' }`;
+    } else if (part.type === "include") {
+      const promptName = part.prompt || "";
+      return `    { type: 'include', prompt: '${escapeString2(promptName)}' }`;
+    }
+    return `    // Unknown part type: ${part.type}`;
+  });
+  return `[
+${formattedParts.join(",\n")},
+  ]`;
+}
+function normalizePart(part) {
+  if (part.type === "text") {
+    return { type: "text", content: part.content || "" };
+  }
+  if (part.type === "include") {
+    return { type: "include", prompt: part.prompt || "" };
+  }
+  if (part.type === "string") {
+    return { type: "text", content: part.value || "" };
+  }
+  if (part.type === "prompt") {
+    return { type: "include", prompt: part.id || "" };
+  }
+  if (part.type === "variable") {
+    return { type: "text", content: `{{${part.value || ""}}}` };
+  }
+  return { type: "text", content: "" };
+}
+
+// src/sdk/generators/generateAgentFile.ts
+function generateAgentFile(data) {
+  const lines = [
+    `import { defineAgent } from '@standardagents/builder';`,
+    "",
+    `export default defineAgent({`,
+    `  name: '${escapeString3(data.name)}',`
+  ];
+  if (data.title) {
+    lines.push(`  title: '${escapeString3(data.title)}',`);
+  }
+  if (data.type && data.type !== "ai_human") {
+    lines.push(`  type: '${data.type}',`);
+  }
+  if (data.maxSessionTurns !== void 0) {
+    lines.push(`  maxSessionTurns: ${data.maxSessionTurns},`);
+  }
+  lines.push(`  sideA: ${formatSideConfig(data.sideA)},`);
+  if (data.sideB) {
+    lines.push(`  sideB: ${formatSideConfig(data.sideB)},`);
+  }
+  if (data.exposeAsTool !== void 0) {
+    lines.push(`  exposeAsTool: ${data.exposeAsTool},`);
+  }
+  if (data.toolDescription) {
+    lines.push(`  toolDescription: '${escapeString3(data.toolDescription)}',`);
+  }
+  if (data.tags && data.tags.length > 0) {
+    lines.push(`  tags: ${JSON.stringify(data.tags)},`);
+  }
+  lines.push(`});`);
+  lines.push("");
+  return lines.join("\n");
+}
+function formatSideConfig(config) {
+  const parts = ["{"];
+  if (config.label) {
+    parts.push(`    label: '${escapeString3(config.label)}',`);
+  }
+  parts.push(`    prompt: '${escapeString3(config.prompt)}',`);
+  if (config.stopOnResponse !== void 0) {
+    parts.push(`    stopOnResponse: ${config.stopOnResponse},`);
+  }
+  if (config.stopTool) {
+    parts.push(`    stopTool: '${escapeString3(config.stopTool)}',`);
+  }
+  if (config.stopToolResponseProperty) {
+    parts.push(`    stopToolResponseProperty: '${escapeString3(config.stopToolResponseProperty)}',`);
+  }
+  if (config.maxTurns !== void 0) {
+    parts.push(`    maxTurns: ${config.maxTurns},`);
+  }
+  if (config.endConversationTool) {
+    parts.push(`    endConversationTool: '${escapeString3(config.endConversationTool)}',`);
+  }
+  if (config.manualStopCondition !== void 0) {
+    parts.push(`    manualStopCondition: ${config.manualStopCondition},`);
+  }
+  parts.push("  }");
+  return parts.join("\n");
+}
+function escapeString3(str) {
+  return str.replace(/'/g, "\\'").replace(/\\/g, "\\\\");
+}
+
+// src/sdk/persistence/index.ts
+function nameToFilename(name) {
+  return name.replace(/[/\\]/g, "__").replace(/[:*?"<>|]/g, "_").replace(/-/g, "_");
+}
+function getModelFilePath(modelsDir, name) {
+  const filename = nameToFilename(name);
+  return path3.join(modelsDir, `${filename}.ts`);
+}
+function modelExists(modelsDir, name) {
+  const filePath = getModelFilePath(modelsDir, name);
+  return fs2.existsSync(filePath);
+}
+async function saveModel(modelsDir, data, overwrite = false) {
+  try {
+    if (!fs2.existsSync(modelsDir)) {
+      fs2.mkdirSync(modelsDir, { recursive: true });
+    }
+    const filePath = getModelFilePath(modelsDir, data.name);
+    if (!overwrite && fs2.existsSync(filePath)) {
+      return {
+        success: false,
+        error: `Model file already exists: ${filePath}. Use update to modify existing models.`
+      };
+    }
+    const content = generateModelFile(data);
+    await fs2.promises.writeFile(filePath, content, "utf-8");
+    return {
+      success: true,
+      filePath
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message || "Failed to save model"
+    };
+  }
+}
+async function deleteModel(modelsDir, name) {
+  try {
+    const filePath = getModelFilePath(modelsDir, name);
+    if (!fs2.existsSync(filePath)) {
+      return {
+        success: false,
+        error: `Model file not found: ${filePath}`
+      };
+    }
+    await fs2.promises.unlink(filePath);
+    return {
+      success: true,
+      filePath
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message || "Failed to delete model"
+    };
+  }
+}
+function transformModelData(data) {
+  const transformed = {};
+  const isOpenRouter = data.provider === "openrouter";
+  const fieldMappings = {
+    included_providers: "includedProviders",
+    input_price: "inputPrice",
+    output_price: "outputPrice",
+    cached_price: "cachedPrice"
+  };
+  const openRouterSkipFields = ["inputPrice", "outputPrice", "cachedPrice", "input_price", "output_price", "cached_price"];
+  for (const [key, value] of Object.entries(data)) {
+    if (key === "id") continue;
+    if (isOpenRouter && openRouterSkipFields.includes(key)) continue;
+    if (fieldMappings[key]) {
+      const transformedKey = fieldMappings[key];
+      if (isOpenRouter && openRouterSkipFields.includes(transformedKey)) continue;
+      transformed[transformedKey] = value;
+    } else {
+      transformed[key] = value;
+    }
+  }
+  return transformed;
+}
+function validateModelData(data) {
+  if (!data.name || typeof data.name !== "string") {
+    return "Model name is required and must be a string";
+  }
+  if (!data.provider || typeof data.provider !== "string") {
+    return "Model provider is required and must be a string";
+  }
+  const validProviders = ["openai", "openrouter", "anthropic", "google"];
+  if (!validProviders.includes(data.provider)) {
+    return `Invalid provider '${data.provider}'. Must be one of: ${validProviders.join(", ")}`;
+  }
+  if (!data.model || typeof data.model !== "string") {
+    return "Model ID is required and must be a string";
+  }
+  if (data.inputPrice !== void 0 && typeof data.inputPrice !== "number") {
+    return "inputPrice must be a number";
+  }
+  if (data.outputPrice !== void 0 && typeof data.outputPrice !== "number") {
+    return "outputPrice must be a number";
+  }
+  if (data.cachedPrice !== void 0 && typeof data.cachedPrice !== "number") {
+    return "cachedPrice must be a number";
+  }
+  if (data.fallbacks !== void 0) {
+    if (!Array.isArray(data.fallbacks)) {
+      return "fallbacks must be an array";
+    }
+    for (const fallback of data.fallbacks) {
+      if (typeof fallback !== "string") {
+        return "Each fallback must be a string (model name)";
+      }
+    }
+  }
+  if (data.includedProviders !== void 0) {
+    if (!Array.isArray(data.includedProviders)) {
+      return "includedProviders must be an array";
+    }
+    for (const provider of data.includedProviders) {
+      if (typeof provider !== "string") {
+        return "Each includedProvider must be a string";
+      }
+    }
+  }
+  return null;
+}
+function transformPromptData(data) {
+  const transformed = {};
+  const fieldMappings = {
+    model_id: "model",
+    tool_description: "toolDescription",
+    expose_as_tool: "exposeAsTool",
+    required_schema: "requiredSchema",
+    include_chat: "includeChat",
+    include_past_tools: "includePastTools",
+    before_tool: "beforeTool",
+    after_tool: "afterTool",
+    parallel_tool_calls: "parallelToolCalls",
+    tool_choice: "toolChoice",
+    handoff_agents: "handoffAgents",
+    reasoning_effort: "reasoningEffort",
+    reasoning_max_tokens: "reasoningMaxTokens",
+    reasoning_exclude: "reasoningExclude",
+    include_reasoning: "includeReasoning"
+  };
+  for (const [key, value] of Object.entries(data)) {
+    if (key === "id") continue;
+    if (fieldMappings[key]) {
+      transformed[fieldMappings[key]] = value;
+    } else {
+      transformed[key] = value;
+    }
+  }
+  if (transformed.reasoningEffort !== void 0 || transformed.reasoningMaxTokens !== void 0 || transformed.reasoningExclude !== void 0 || transformed.includeReasoning !== void 0) {
+    transformed.reasoning = {};
+    if (transformed.reasoningEffort) {
+      transformed.reasoning.effort = transformed.reasoningEffort;
+    }
+    if (transformed.reasoningMaxTokens) {
+      transformed.reasoning.maxTokens = transformed.reasoningMaxTokens;
+    }
+    if (transformed.reasoningExclude !== void 0) {
+      transformed.reasoning.exclude = transformed.reasoningExclude;
+    }
+    if (transformed.includeReasoning !== void 0) {
+      transformed.reasoning.include = transformed.includeReasoning;
+    }
+    delete transformed.reasoningEffort;
+    delete transformed.reasoningMaxTokens;
+    delete transformed.reasoningExclude;
+    delete transformed.includeReasoning;
+  }
+  return transformed;
+}
+function getPromptFilePath(promptsDir, name) {
+  const filename = nameToFilename(name);
+  return path3.join(promptsDir, `${filename}.ts`);
+}
+function promptExists(promptsDir, name) {
+  const filePath = getPromptFilePath(promptsDir, name);
+  return fs2.existsSync(filePath);
+}
+async function savePrompt(promptsDir, data, overwrite = false) {
+  try {
+    if (!fs2.existsSync(promptsDir)) {
+      fs2.mkdirSync(promptsDir, { recursive: true });
+    }
+    const filePath = getPromptFilePath(promptsDir, data.name);
+    if (!overwrite && fs2.existsSync(filePath)) {
+      return {
+        success: false,
+        error: `Prompt file already exists: ${filePath}. Use update to modify existing prompts.`
+      };
+    }
+    const content = generatePromptFile(data);
+    await fs2.promises.writeFile(filePath, content, "utf-8");
+    return {
+      success: true,
+      filePath
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message || "Failed to save prompt"
+    };
+  }
+}
+async function deletePrompt(promptsDir, name) {
+  try {
+    const filePath = getPromptFilePath(promptsDir, name);
+    if (!fs2.existsSync(filePath)) {
+      return {
+        success: false,
+        error: `Prompt file not found: ${filePath}`
+      };
+    }
+    await fs2.promises.unlink(filePath);
+    return {
+      success: true,
+      filePath
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message || "Failed to delete prompt"
+    };
+  }
+}
+async function renamePrompt(promptsDir, oldName, newName) {
+  try {
+    const oldFilePath = getPromptFilePath(promptsDir, oldName);
+    const newFilePath = getPromptFilePath(promptsDir, newName);
+    if (!fs2.existsSync(oldFilePath)) {
+      return {
+        success: false,
+        error: `Prompt file not found: ${oldFilePath}`
+      };
+    }
+    if (fs2.existsSync(newFilePath)) {
+      return {
+        success: false,
+        error: `Prompt file already exists: ${newFilePath}`
+      };
+    }
+    const content = await fs2.promises.readFile(oldFilePath, "utf-8");
+    const updatedContent = content.replace(
+      /name:\s*['"]([^'"]+)['"]/,
+      `name: '${newName}'`
+    );
+    await fs2.promises.writeFile(newFilePath, updatedContent, "utf-8");
+    await fs2.promises.unlink(oldFilePath);
+    return {
+      success: true,
+      filePath: newFilePath
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message || "Failed to rename prompt"
+    };
+  }
+}
+function validatePromptData(data) {
+  if (!data.name || typeof data.name !== "string") {
+    return "Prompt name is required and must be a string";
+  }
+  if (!data.model || typeof data.model !== "string") {
+    return "Prompt model is required and must be a string";
+  }
+  if (data.toolDescription !== void 0 && typeof data.toolDescription !== "string") {
+    return "toolDescription must be a string";
+  }
+  if (data.prompt !== void 0 && typeof data.prompt !== "string") {
+    return "prompt must be a string";
+  }
+  const booleanFields = ["includeChat", "includePastTools", "parallelToolCalls"];
+  for (const field of booleanFields) {
+    if (data[field] !== void 0 && typeof data[field] !== "boolean") {
+      return `${field} must be a boolean`;
+    }
+  }
+  if (data.toolChoice !== void 0) {
+    const validChoices = ["auto", "none", "required"];
+    if (!validChoices.includes(data.toolChoice)) {
+      return `Invalid toolChoice '${data.toolChoice}'. Must be one of: ${validChoices.join(", ")}`;
+    }
+  }
+  if (data.tools !== void 0 && !Array.isArray(data.tools)) {
+    return "tools must be an array";
+  }
+  if (data.handoffAgents !== void 0 && !Array.isArray(data.handoffAgents)) {
+    return "handoffAgents must be an array";
+  }
+  if (data.reasoning !== void 0) {
+    if (typeof data.reasoning !== "object") {
+      return "reasoning must be an object";
+    }
+    if (data.reasoning.effort !== void 0) {
+      const validEfforts = ["low", "medium", "high"];
+      if (!validEfforts.includes(data.reasoning.effort)) {
+        return `Invalid reasoning.effort '${data.reasoning.effort}'. Must be one of: ${validEfforts.join(", ")}`;
+      }
+    }
+    if (data.reasoning.maxTokens !== void 0 && typeof data.reasoning.maxTokens !== "number") {
+      return "reasoning.maxTokens must be a number";
+    }
+  }
+  return null;
+}
+function transformAgentData(data) {
+  const transformed = {
+    name: data.name
+  };
+  if (data.title) {
+    transformed.title = data.title;
+  }
+  if (data.type) {
+    transformed.type = data.type;
+  }
+  if (data.max_session_turns !== void 0) {
+    transformed.maxSessionTurns = data.max_session_turns;
+  }
+  transformed.sideA = {
+    prompt: data.side_a_agent_prompt
+  };
+  if (data.side_a_label) {
+    transformed.sideA.label = data.side_a_label;
+  }
+  if (data.side_a_stop_on_response !== void 0) {
+    transformed.sideA.stopOnResponse = data.side_a_stop_on_response;
+  }
+  if (data.side_a_stop_tool) {
+    transformed.sideA.stopTool = data.side_a_stop_tool;
+  }
+  if (data.side_a_stop_tool_response_property) {
+    transformed.sideA.stopToolResponseProperty = data.side_a_stop_tool_response_property;
+  }
+  if (data.side_a_max_turns !== void 0) {
+    transformed.sideA.maxTurns = data.side_a_max_turns;
+  }
+  if (data.side_a_end_conversation_tool) {
+    transformed.sideA.endConversationTool = data.side_a_end_conversation_tool;
+  }
+  if (data.side_a_manual_stop_condition !== void 0) {
+    transformed.sideA.manualStopCondition = data.side_a_manual_stop_condition;
+  }
+  if (data.side_b_agent_prompt) {
+    transformed.sideB = {
+      prompt: data.side_b_agent_prompt
+    };
+    if (data.side_b_label) {
+      transformed.sideB.label = data.side_b_label;
+    }
+    if (data.side_b_stop_on_response !== void 0) {
+      transformed.sideB.stopOnResponse = data.side_b_stop_on_response;
+    }
+    if (data.side_b_stop_tool) {
+      transformed.sideB.stopTool = data.side_b_stop_tool;
+    }
+    if (data.side_b_stop_tool_response_property) {
+      transformed.sideB.stopToolResponseProperty = data.side_b_stop_tool_response_property;
+    }
+    if (data.side_b_max_turns !== void 0) {
+      transformed.sideB.maxTurns = data.side_b_max_turns;
+    }
+    if (data.side_b_end_conversation_tool) {
+      transformed.sideB.endConversationTool = data.side_b_end_conversation_tool;
+    }
+    if (data.side_b_manual_stop_condition !== void 0) {
+      transformed.sideB.manualStopCondition = data.side_b_manual_stop_condition;
+    }
+  }
+  if (data.expose_as_tool !== void 0) {
+    transformed.exposeAsTool = data.expose_as_tool;
+  }
+  if (data.tool_description) {
+    transformed.toolDescription = data.tool_description;
+  }
+  if (data.tags) {
+    transformed.tags = data.tags;
+  }
+  return transformed;
+}
+function getAgentFilePath(agentsDir, name) {
+  const filename = nameToFilename(name);
+  return path3.join(agentsDir, `${filename}.ts`);
+}
+function agentExists(agentsDir, name) {
+  const filePath = getAgentFilePath(agentsDir, name);
+  return fs2.existsSync(filePath);
+}
+async function saveAgent(agentsDir, data, overwrite = false) {
+  try {
+    if (!fs2.existsSync(agentsDir)) {
+      fs2.mkdirSync(agentsDir, { recursive: true });
+    }
+    const filePath = getAgentFilePath(agentsDir, data.name);
+    if (!overwrite && fs2.existsSync(filePath)) {
+      return {
+        success: false,
+        error: `Agent file already exists: ${filePath}. Use update to modify existing agents.`
+      };
+    }
+    const content = generateAgentFile(data);
+    await fs2.promises.writeFile(filePath, content, "utf-8");
+    return {
+      success: true,
+      filePath
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message || "Failed to save agent"
+    };
+  }
+}
+async function deleteAgent(agentsDir, name) {
+  try {
+    const filePath = getAgentFilePath(agentsDir, name);
+    if (!fs2.existsSync(filePath)) {
+      return {
+        success: false,
+        error: `Agent file not found: ${filePath}`
+      };
+    }
+    await fs2.promises.unlink(filePath);
+    return {
+      success: true,
+      filePath
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message || "Failed to delete agent"
+    };
+  }
+}
+async function renameModel(modelsDir, oldName, newName) {
+  try {
+    const oldFilePath = getModelFilePath(modelsDir, oldName);
+    const newFilePath = getModelFilePath(modelsDir, newName);
+    if (!fs2.existsSync(oldFilePath)) {
+      return {
+        success: false,
+        error: `Model file not found: ${oldFilePath}`
+      };
+    }
+    if (fs2.existsSync(newFilePath)) {
+      return {
+        success: false,
+        error: `Model file already exists: ${newFilePath}`
+      };
+    }
+    const content = await fs2.promises.readFile(oldFilePath, "utf-8");
+    const updatedContent = content.replace(
+      /name:\s*['"]([^'"]+)['"]/,
+      `name: '${newName}'`
+    );
+    await fs2.promises.writeFile(newFilePath, updatedContent, "utf-8");
+    await fs2.promises.unlink(oldFilePath);
+    return {
+      success: true,
+      filePath: newFilePath
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message || "Failed to rename model"
+    };
+  }
+}
+async function updateModelReferencesInPrompts(promptsDir, oldModelName, newModelName) {
+  const updatedFiles = [];
+  if (!fs2.existsSync(promptsDir)) {
+    return updatedFiles;
+  }
+  const files = fs2.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
+  for (const file of files) {
+    const filePath = path3.join(promptsDir, file);
+    let content = await fs2.promises.readFile(filePath, "utf-8");
+    const modelRegex = new RegExp(`model:\\s*['"]${escapeRegExp(oldModelName)}['"]`, "g");
+    if (modelRegex.test(content)) {
+      content = content.replace(modelRegex, `model: '${newModelName}'`);
+      await fs2.promises.writeFile(filePath, content, "utf-8");
+      updatedFiles.push(filePath);
+    }
+  }
+  return updatedFiles;
+}
+async function updatePromptReferencesInPrompts(promptsDir, oldPromptName, newPromptName) {
+  const updatedFiles = [];
+  if (!fs2.existsSync(promptsDir)) {
+    return updatedFiles;
+  }
+  const files = fs2.readdirSync(promptsDir).filter((f) => f.endsWith(".ts"));
+  for (const file of files) {
+    const filePath = path3.join(promptsDir, file);
+    let content = await fs2.promises.readFile(filePath, "utf-8");
+    let modified = false;
+    const toolsArrayRegex = /tools:\s*\[([^\]]*)\]/gs;
+    const newContent = content.replace(toolsArrayRegex, (match) => {
+      const oldMatch = match;
+      const promptRefRegex = new RegExp(`['"]${escapeRegExp(oldPromptName)}['"]`, "g");
+      const replaced = match.replace(promptRefRegex, `'${newPromptName}'`);
+      if (replaced !== oldMatch) {
+        modified = true;
+      }
+      return replaced;
+    });
+    if (modified) {
+      await fs2.promises.writeFile(filePath, newContent, "utf-8");
+      updatedFiles.push(filePath);
+    }
+  }
+  return updatedFiles;
+}
+async function updatePromptReferencesInAgents(agentsDir, oldPromptName, newPromptName) {
+  const updatedFiles = [];
+  if (!fs2.existsSync(agentsDir)) {
+    return updatedFiles;
+  }
+  const files = fs2.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
+  for (const file of files) {
+    const filePath = path3.join(agentsDir, file);
+    let content = await fs2.promises.readFile(filePath, "utf-8");
+    const promptRegex = new RegExp(`prompt:\\s*['"]${escapeRegExp(oldPromptName)}['"]`, "g");
+    if (promptRegex.test(content)) {
+      content = content.replace(promptRegex, `prompt: '${newPromptName}'`);
+      await fs2.promises.writeFile(filePath, content, "utf-8");
+      updatedFiles.push(filePath);
+    }
+  }
+  return updatedFiles;
+}
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function validateAgentData(data) {
+  if (!data.name || typeof data.name !== "string") {
+    return "Agent name is required and must be a string";
+  }
+  if (data.title !== void 0 && typeof data.title !== "string") {
+    return "Agent title must be a string if provided";
+  }
+  if (data.type !== void 0) {
+    const validTypes = ["ai_human", "dual_ai"];
+    if (!validTypes.includes(data.type)) {
+      return `Invalid type '${data.type}'. Must be one of: ${validTypes.join(", ")}`;
+    }
+  }
+  if (!data.sideA || typeof data.sideA !== "object") {
+    return "sideA configuration is required";
+  }
+  if (!data.sideA.prompt || typeof data.sideA.prompt !== "string") {
+    return "sideA.prompt is required and must be a string";
+  }
+  if (data.sideA.label !== void 0 && typeof data.sideA.label !== "string") {
+    return "sideA.label must be a string";
+  }
+  if (data.sideA.stopOnResponse !== void 0 && typeof data.sideA.stopOnResponse !== "boolean") {
+    return "sideA.stopOnResponse must be a boolean";
+  }
+  if (data.sideA.stopTool !== void 0 && typeof data.sideA.stopTool !== "string") {
+    return "sideA.stopTool must be a string";
+  }
+  if (data.sideA.stopTool && !data.sideA.stopToolResponseProperty) {
+    return "sideA.stopToolResponseProperty is required when sideA.stopTool is set";
+  }
+  if (data.sideA.maxTurns !== void 0) {
+    if (typeof data.sideA.maxTurns !== "number" || data.sideA.maxTurns <= 0) {
+      return "sideA.maxTurns must be a positive number";
+    }
+  }
+  if (data.type === "dual_ai") {
+    if (!data.sideB || typeof data.sideB !== "object") {
+      return "sideB configuration is required for dual_ai type";
+    }
+    if (!data.sideB.prompt || typeof data.sideB.prompt !== "string") {
+      return "sideB.prompt is required for dual_ai type";
+    }
+    if (data.sideB.stopTool && !data.sideB.stopToolResponseProperty) {
+      return "sideB.stopToolResponseProperty is required when sideB.stopTool is set";
+    }
+    if (data.sideB.maxTurns !== void 0) {
+      if (typeof data.sideB.maxTurns !== "number" || data.sideB.maxTurns <= 0) {
+        return "sideB.maxTurns must be a positive number";
+      }
+    }
+  }
+  if (data.exposeAsTool && !data.toolDescription) {
+    return "toolDescription is required when exposeAsTool is true";
+  }
+  if (data.maxSessionTurns !== void 0) {
+    if (typeof data.maxSessionTurns !== "number" || data.maxSessionTurns <= 0) {
+      return "maxSessionTurns must be a positive number";
+    }
+  }
+  if (data.tags !== void 0) {
+    if (!Array.isArray(data.tags)) {
+      return "tags must be an array";
+    }
+    for (const tag of data.tags) {
+      if (typeof tag !== "string") {
+        return "Each tag must be a string";
+      }
+    }
+  }
+  return null;
+}
+
+// src/plugin.ts
+var VIRTUAL_TOOLS_ID = "virtual:@standardagents-tools";
+var RESOLVED_VIRTUAL_TOOLS_ID = "\0" + VIRTUAL_TOOLS_ID;
+var VIRTUAL_ROUTES_ID = "virtual:@standardagents-routes";
+var RESOLVED_VIRTUAL_ROUTES_ID = "\0" + VIRTUAL_ROUTES_ID;
+var VIRTUAL_ROUTER_ID = "virtual:@standardagents/router";
+var RESOLVED_VIRTUAL_ROUTER_ID = "\0" + VIRTUAL_ROUTER_ID;
+var VIRTUAL_HOOKS_ID = "virtual:@standardagents-hooks";
+var RESOLVED_VIRTUAL_HOOKS_ID = "\0" + VIRTUAL_HOOKS_ID;
+var VIRTUAL_CONFIG_ID = "virtual:@standardagents-config";
+var RESOLVED_VIRTUAL_CONFIG_ID = "\0" + VIRTUAL_CONFIG_ID;
+var VIRTUAL_THREAD_API_ID = "virtual:@standardagents-thread-api";
+var RESOLVED_VIRTUAL_THREAD_API_ID = "\0" + VIRTUAL_THREAD_API_ID;
+var VIRTUAL_MODELS_ID = "virtual:@standardagents-models";
+var RESOLVED_VIRTUAL_MODELS_ID = "\0" + VIRTUAL_MODELS_ID;
+var VIRTUAL_PROMPTS_ID = "virtual:@standardagents-prompts";
+var RESOLVED_VIRTUAL_PROMPTS_ID = "\0" + VIRTUAL_PROMPTS_ID;
+var VIRTUAL_AGENTS_ID = "virtual:@standardagents-agents";
+var RESOLVED_VIRTUAL_AGENTS_ID = "\0" + VIRTUAL_AGENTS_ID;
+var VIRTUAL_BUILDER_ID = "virtual:@standardagents/builder";
+var RESOLVED_VIRTUAL_BUILDER_ID = "\0" + VIRTUAL_BUILDER_ID;
+function scanApiDirectory(dir, baseRoute = "") {
+  const routes = [];
+  if (!fs2.existsSync(dir)) {
+    return routes;
+  }
+  try {
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path3.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const convertedDirName = entry.name.replace(/\[([^\]]+)\]/g, ":$1");
+        const subRoute = baseRoute + "/" + convertedDirName;
+        routes.push(...scanApiDirectory(fullPath, subRoute));
+      } else if (entry.isFile() && entry.name.endsWith(".ts")) {
+        const fileName = entry.name.replace(/\.ts$/, "");
+        let method = "GET";
+        let routePath = baseRoute;
+        if (fileName.includes(".")) {
+          const parts = fileName.split(".");
+          const methodPart = parts[parts.length - 1].toUpperCase();
+          if (["GET", "POST", "PUT", "DELETE", "PATCH"].includes(methodPart)) {
+            method = methodPart;
+            const pathPart = parts.slice(0, -1).join(".");
+            if (pathPart !== "index") {
+              const convertedPath = pathPart.replace(/\[([^\]]+)\]/g, ":$1");
+              routePath += "/" + convertedPath;
+            }
+          } else {
+            if (fileName !== "index") {
+              const convertedPath = fileName.replace(/\[([^\]]+)\]/g, ":$1");
+              routePath += "/" + convertedPath;
+            }
+          }
+        } else {
+          if (fileName !== "index") {
+            const convertedPath = fileName.replace(/\[([^\]]+)\]/g, ":$1");
+            routePath += "/" + convertedPath;
+          }
+        }
+        const importPath = "./" + path3.relative(process.cwd(), fullPath).replace(/\\/g, "/");
+        routes.push({
+          method,
+          route: routePath || "/",
+          importPath
+        });
+      }
+    }
+    return routes;
+  } catch (error) {
+    console.error(`Error scanning API directory ${dir}:`, error);
+    return [];
+  }
+}
+function isSnakeCase(str) {
+  return /^[a-z][a-z0-9_]*[a-z0-9]$/.test(str) || /^[a-z]$/.test(str);
+}
+function validateToolFile(filePath, fileName) {
+  try {
+    const content = fs2.readFileSync(filePath, "utf-8");
+    const hasDefaultExport = /export\s+default\s+defineTool/.test(content);
+    if (!hasDefaultExport) {
+      return `Tool file '${fileName}.ts' must have a default export using defineTool()`;
+    }
+    return null;
+  } catch (error) {
+    return `Failed to read tool file '${fileName}.ts'`;
+  }
+}
+async function scanToolsDirectory(dir) {
+  const tools = [];
+  if (!fs2.existsSync(dir)) {
+    return tools;
+  }
+  const entries = await fs2.promises.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith(".ts")) {
+      const fileName = entry.name.replace(".ts", "");
+      const filePath = path3.join(dir, entry.name);
+      const importPath = "./" + path3.relative(process.cwd(), filePath).replace(/\\/g, "/");
+      let toolError;
+      const validationError = validateToolFile(filePath, fileName);
+      if (validationError) {
+        toolError = validationError;
+        console.error(`
+\u274C Tool validation error: ${validationError}`);
+      }
+      if (!isSnakeCase(fileName)) {
+        const warning = `Tool name should be in snake_case format (e.g., 'log_name', 'send_email')`;
+        if (toolError) {
+          toolError += ` | ${warning}`;
+        } else {
+          toolError = warning;
+        }
+        console.warn(
+          `
+\u26A0\uFE0F  Tool naming warning: '${fileName}' should be in snake_case format (e.g., 'log_name', 'send_email')`
+        );
+      }
+      tools.push({ name: fileName, importPath, error: toolError });
+    }
+  }
+  return tools;
+}
+async function scanHooksDirectory(dir) {
+  const hooks = [];
+  if (!fs2.existsSync(dir)) {
+    return hooks;
+  }
+  const entries = await fs2.promises.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith(".ts")) {
+      const fileName = entry.name.replace(".ts", "");
+      const filePath = path3.join(dir, entry.name);
+      const importPath = "./" + path3.relative(process.cwd(), filePath).replace(/\\/g, "/");
+      hooks.push({ name: fileName, importPath });
+    }
+  }
+  return hooks;
+}
+async function scanConfigDirectory(dir, definePattern) {
+  const items = [];
+  if (!fs2.existsSync(dir)) {
+    return items;
+  }
+  const entries = await fs2.promises.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith(".ts")) {
+      const filePath = path3.join(dir, entry.name);
+      const importPath = "./" + path3.relative(process.cwd(), filePath).replace(/\\/g, "/");
+      try {
+        const content = fs2.readFileSync(filePath, "utf-8");
+        const hasDefaultExport = definePattern.test(content);
+        if (!hasDefaultExport) {
+          items.push({
+            name: entry.name.replace(".ts", ""),
+            importPath,
+            error: `File must have a default export using the define function`
+          });
+          continue;
+        }
+        const nameMatch = content.match(/name:\s*['"]([^'"]+)['"]/);
+        if (nameMatch) {
+          items.push({ name: nameMatch[1], importPath });
+        } else {
+          items.push({
+            name: entry.name.replace(".ts", ""),
+            importPath,
+            error: `Could not extract name from definition`
+          });
+        }
+      } catch (error) {
+        items.push({
+          name: entry.name.replace(".ts", ""),
+          importPath,
+          error: `Failed to read file: ${error}`
+        });
+      }
+    }
+  }
+  return items;
+}
+async function scanModelsDirectory(dir) {
+  return scanConfigDirectory(dir, /export\s+default\s+defineModel/);
+}
+async function scanPromptsDirectory(dir) {
+  return scanConfigDirectory(dir, /export\s+default\s+definePrompt/);
+}
+async function scanAgentsDirectory(dir) {
+  return scanConfigDirectory(dir, /export\s+default\s+defineAgent/);
+}
+function parseRequestBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      try {
+        resolve(body ? JSON.parse(body) : {});
+      } catch (e) {
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function agentbuilder(options = {}) {
+  let mountPoint = options.mountPoint || "/agents";
+  if (!mountPoint.startsWith("/")) {
+    mountPoint = "/" + mountPoint;
+  }
+  if (mountPoint.endsWith("/") && mountPoint.length > 1) {
+    mountPoint = mountPoint.slice(0, -1);
+  }
+  const toolsDir = options.toolsDir ? path3.resolve(process.cwd(), options.toolsDir) : path3.resolve(process.cwd(), "agents/tools");
+  const hooksDir = options.hooksDir ? path3.resolve(process.cwd(), options.hooksDir) : path3.resolve(process.cwd(), "agents/hooks");
+  const threadApiDir = options.apiDir ? path3.resolve(process.cwd(), options.apiDir) : path3.resolve(process.cwd(), "agents/api");
+  const modelsDir = options.modelsDir ? path3.resolve(process.cwd(), options.modelsDir) : path3.resolve(process.cwd(), "agents/models");
+  const promptsDir = options.promptsDir ? path3.resolve(process.cwd(), options.promptsDir) : path3.resolve(process.cwd(), "agents/prompts");
+  const agentsDir = options.agentsDir ? path3.resolve(process.cwd(), options.agentsDir) : path3.resolve(process.cwd(), "agents/agents");
+  const outputDir = path3.resolve(process.cwd(), ".agents");
+  const typeGenConfig = {
+    modelsDir,
+    promptsDir,
+    agentsDir,
+    toolsDir,
+    outputDir
+  };
+  function regenerateTypes() {
+    if (needsRegeneration(typeGenConfig)) {
+      console.log("[vite-plugin-agent] Regenerating types...");
+      generateTypes(typeGenConfig);
+      console.log("[vite-plugin-agent] Types regenerated at .agents/types.d.ts");
+    }
+  }
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path3.dirname(__filename);
+  const rou3Path = path3.join(__dirname, "../dist/rou3.js");
+  let rou3Code = "";
+  try {
+    rou3Code = fs2.readFileSync(rou3Path, "utf-8").replace(/^export \{[^}]+\};?\s*$/gm, "").replace(/\/\/# sourceMappingURL=.+$/gm, "").trim();
+  } catch (err) {
+    console.warn("[vite-plugin-agent] Could not read rou3.js for inlining:", err);
+  }
+  let routesVersion = Math.random().toString(36).substring(7);
+  function getWorkerEnvironment(server) {
+    const envNames = Object.keys(server.environments);
+    const workerEnvName = envNames.find((name) => name !== "client");
+    if (!workerEnvName) {
+      console.warn("[vite-plugin-agent] Could not find worker environment");
+      return null;
+    }
+    return server.environments[workerEnvName];
+  }
+  function reloadToolsModule(server) {
+    const workerEnv = getWorkerEnvironment(server);
+    if (!workerEnv) return false;
+    const toolsModule = workerEnv.moduleGraph.getModuleById(
+      RESOLVED_VIRTUAL_TOOLS_ID
+    );
+    if (toolsModule) {
+      workerEnv.reloadModule(toolsModule);
+      server.ws.send({
+        type: "custom",
+        event: "agent:tools-updated",
+        data: { timestamp: Date.now() }
+      });
+      return true;
+    }
+    return false;
+  }
+  function reloadRoutesModule(server) {
+    const workerEnv = getWorkerEnvironment(server);
+    if (!workerEnv) return false;
+    const routesModule = workerEnv.moduleGraph.getModuleById(
+      RESOLVED_VIRTUAL_ROUTES_ID
+    );
+    if (routesModule) {
+      routesVersion = Math.random().toString(36).substring(7);
+      workerEnv.reloadModule(routesModule);
+      server.ws.send({
+        type: "custom",
+        event: "agent:routes-updated",
+        data: { timestamp: Date.now() }
+      });
+      return true;
+    }
+    return false;
+  }
+  function reloadHooksModule(server) {
+    const workerEnv = getWorkerEnvironment(server);
+    if (!workerEnv) return false;
+    const hooksModule = workerEnv.moduleGraph.getModuleById(
+      RESOLVED_VIRTUAL_HOOKS_ID
+    );
+    if (hooksModule) {
+      workerEnv.reloadModule(hooksModule);
+      server.ws.send({
+        type: "custom",
+        event: "agent:hooks-updated",
+        data: { timestamp: Date.now() }
+      });
+      return true;
+    }
+    return false;
+  }
+  async function reloadModelsModule(server) {
+    const workerEnv = getWorkerEnvironment(server);
+    if (!workerEnv) return false;
+    const modelsModule = workerEnv.moduleGraph.getModuleById(
+      RESOLVED_VIRTUAL_MODELS_ID
+    );
+    if (modelsModule) {
+      await workerEnv.reloadModule(modelsModule);
+      server.ws.send({
+        type: "custom",
+        event: "agent:models-updated",
+        data: { timestamp: Date.now() }
+      });
+      return true;
+    }
+    return false;
+  }
+  async function reloadPromptsModule(server) {
+    const workerEnv = getWorkerEnvironment(server);
+    if (!workerEnv) return false;
+    const promptsModule = workerEnv.moduleGraph.getModuleById(
+      RESOLVED_VIRTUAL_PROMPTS_ID
+    );
+    if (promptsModule) {
+      await workerEnv.reloadModule(promptsModule);
+      server.ws.send({
+        type: "custom",
+        event: "agent:prompts-updated",
+        data: { timestamp: Date.now() }
+      });
+      return true;
+    }
+    return false;
+  }
+  async function reloadAgentsModule(server) {
+    const workerEnv = getWorkerEnvironment(server);
+    if (!workerEnv) return false;
+    const agentsModule = workerEnv.moduleGraph.getModuleById(
+      RESOLVED_VIRTUAL_AGENTS_ID
+    );
+    if (agentsModule) {
+      await workerEnv.reloadModule(agentsModule);
+      server.ws.send({
+        type: "custom",
+        event: "agent:agents-updated",
+        data: { timestamp: Date.now() }
+      });
+      return true;
+    }
+    return false;
+  }
+  async function reloadRouterModule(server) {
+    const workerEnv = getWorkerEnvironment(server);
+    if (!workerEnv) return false;
+    const routerModule = workerEnv.moduleGraph.getModuleById(
+      RESOLVED_VIRTUAL_ROUTER_ID
+    );
+    if (routerModule) {
+      await workerEnv.reloadModule(routerModule);
+      return true;
+    }
+    return false;
+  }
+  function handleFileChange(file, server, action) {
+    const isToolFile = file.startsWith(toolsDir) && file.endsWith(".ts");
+    const isThreadApiFile = file.startsWith(threadApiDir) && file.endsWith(".ts");
+    const isHookFile = file.startsWith(hooksDir) && file.endsWith(".ts");
+    const isModelFile = file.startsWith(modelsDir) && file.endsWith(".ts");
+    const isPromptFile = file.startsWith(promptsDir) && file.endsWith(".ts");
+    const isAgentFile = file.startsWith(agentsDir) && file.endsWith(".ts");
+    const isConfigFile = isModelFile || isPromptFile || isAgentFile;
+    if (!isToolFile && !isThreadApiFile && !isHookFile && !isConfigFile) return;
+    const fileType = isToolFile ? "tool" : isThreadApiFile ? "thread-api" : isHookFile ? "hook" : isModelFile ? "model" : isPromptFile ? "prompt" : "agent";
+    console.log(
+      `[vite-plugin-agent] ${action} ${fileType}: ${path3.relative(
+        process.cwd(),
+        file
+      )}`
+    );
+    if (isConfigFile || isToolFile) {
+      regenerateTypes();
+    }
+    if (isToolFile) {
+      reloadToolsModule(server);
+    }
+    if (isModelFile) {
+      reloadModelsModule(server);
+    }
+    if (isPromptFile) {
+      reloadPromptsModule(server);
+    }
+    if (isAgentFile) {
+      reloadAgentsModule(server);
+    }
+    if (isThreadApiFile) {
+      reloadRoutesModule(server);
+    }
+    if (isHookFile) {
+      reloadHooksModule(server);
+    }
+  }
+  return {
+    name: "vite-plugin-agent",
+    config() {
+      return {
+        optimizeDeps: {
+          // Exclude @standardagents/builder/mcp from pre-bundling (used for MCP server, not needed in worker)
+          exclude: [
+            "@standardagents/builder/mcp"
+          ]
+        },
+        ssr: {
+          // Mark as external for SSR/worker builds to prevent bundling
+          // Note: @standardagents/builder, @standardagents/builder/runtime, built-in-routes, and rou3
+          // are NOT external - they must be bundled into the worker for Cloudflare Workers runtime
+          external: [
+            "@standardagents/builder/mcp"
+          ]
+        },
+        build: {
+          rollupOptions: {
+            // Also mark as external for Rollup/build (used by Cloudflare Workers plugin)
+            // Note: @standardagents/builder, @standardagents/builder/runtime, built-in-routes, and rou3
+            // are NOT external - they must be bundled into the worker for Cloudflare Workers runtime
+            external: [
+              "@standardagents/builder/mcp"
+            ]
+          }
+        }
+      };
+    },
+    resolveId(id) {
+      if (id.includes("virtual:") || id.includes("agent")) {
+        console.log("[plugin.resolveId]", id);
+      }
+      if (id === VIRTUAL_TOOLS_ID) {
+        console.log("[plugin.resolveId] \u2713 Resolving tools");
+        return RESOLVED_VIRTUAL_TOOLS_ID;
+      }
+      if (id === VIRTUAL_ROUTES_ID || id === VIRTUAL_ROUTER_ID) {
+        console.log("[plugin.resolveId] \u2713 Resolving routes");
+        return RESOLVED_VIRTUAL_ROUTES_ID;
+      }
+      if (id === VIRTUAL_HOOKS_ID) {
+        console.log("[plugin.resolveId] \u2713 Resolving hooks");
+        return RESOLVED_VIRTUAL_HOOKS_ID;
+      }
+      if (id === VIRTUAL_CONFIG_ID) {
+        console.log("[plugin.resolveId] \u2713 Resolving config");
+        return RESOLVED_VIRTUAL_CONFIG_ID;
+      }
+      if (id === VIRTUAL_THREAD_API_ID) {
+        console.log("[plugin.resolveId] \u2713 Resolving thread API");
+        return RESOLVED_VIRTUAL_THREAD_API_ID;
+      }
+      if (id === VIRTUAL_MODELS_ID) {
+        console.log("[plugin.resolveId] \u2713 Resolving models");
+        return RESOLVED_VIRTUAL_MODELS_ID;
+      }
+      if (id === VIRTUAL_PROMPTS_ID) {
+        console.log("[plugin.resolveId] \u2713 Resolving prompts");
+        return RESOLVED_VIRTUAL_PROMPTS_ID;
+      }
+      if (id === VIRTUAL_AGENTS_ID) {
+        console.log("[plugin.resolveId] \u2713 Resolving agents");
+        return RESOLVED_VIRTUAL_AGENTS_ID;
+      }
+      if (id === VIRTUAL_BUILDER_ID) {
+        console.log("[plugin.resolveId] \u2713 Resolving consolidated builder module");
+        return RESOLVED_VIRTUAL_BUILDER_ID;
+      }
+    },
+    async load(id) {
+      if (id.includes("\0virtual:") || id.includes("agent")) {
+        console.log("[plugin.load]", id);
+      }
+      if (id === RESOLVED_VIRTUAL_TOOLS_ID) {
+        const tools = await scanToolsDirectory(toolsDir);
+        const toolsCode = tools.map(({ name, importPath, error }) => {
+          if (error) {
+            const escapedError = error.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+            return `  "${name}": async () => ["${escapedError}", null, async () => ({ status: "error", error: "Tool validation failed" })],`;
+          } else {
+            return `  "${name}": async () => {
+              try {
+                return (await import("${importPath}")).default;
+              } catch (error) {
+                console.error('Failed to import tool ${name}:', error);
+                return ["Failed to load tool: " + error.message, null, async () => ({ status: "error", error: "Import failed" })];
+              }
+            },`;
+          }
+        }).join("\n");
+        const moduleCode = `// Virtual agent tools module
+export const tools = {
+${toolsCode}
+};`;
+        return moduleCode;
+      }
+      if (id === RESOLVED_VIRTUAL_ROUTES_ID) {
+        const threadRoutes = scanApiDirectory(threadApiDir);
+        const threadRouteCode = threadRoutes.map(({ method, route, importPath }) => {
+          const apiRoute = `/api/threads/:id${route}`;
+          return `  addRoute(
+    router,
+    "${method}",
+    "${apiRoute}",
+    /* v${routesVersion} */ async () => (await import("${importPath}")).default
+  );`;
+        }).join("\n");
+        return `// Inline rou3 router code (no external imports)
+${rou3Code}
+
+import { registerBuiltInRoutes } from "@standardagents/builder/built-in-routes";
+import { config } from "virtual:@standardagents-config";
+import { tools } from "virtual:@standardagents-tools";
+import { hooks } from "virtual:@standardagents-hooks";
+import { models, modelNames } from "virtual:@standardagents-models";
+import { prompts, promptNames } from "virtual:@standardagents-prompts";
+import { agents, agentNames } from "virtual:@standardagents-agents";
+import { DurableThread as _DurableThread } from "@standardagents/builder/runtime";
+import { requireAuth } from "@standardagents/builder/runtime";
+
+console.log('[Router] Virtual modules loaded - tools:', Object.keys(tools || {}), 'hooks:', Object.keys(hooks || {}), 'models:', modelNames, 'prompts:', promptNames, 'agents:', agentNames);
+
+const MOUNT_POINT = "${mountPoint}";
+
+// Routes that don't require authentication
+const PUBLIC_ROUTES = [
+  '/api/auth/login',
+  '/api/auth/config',
+  '/api/auth/oauth/github',
+  '/api/auth/oauth/google',
+  '/api/auth/oauth/github/callback',
+  '/api/auth/oauth/google/callback'
+];
+
+// Check if a route is public (no auth required)
+function isPublicRoute(routePath) {
+  // Exact match for auth routes
+  if (PUBLIC_ROUTES.includes(routePath)) {
+    return true;
+  }
+
+  // Thread routes are always public
+  if (routePath.startsWith('/api/threads/') || routePath === '/api/threads') {
+    return true;
+  }
+
+  return false;
+}
+
+export async function router(request, env) {
+  const url = new URL(request.url);
+  const pathname = url.pathname;
+
+  // Check if request is under mount point
+  if (!pathname.startsWith(MOUNT_POINT)) {
+    return null;
+  }
+
+  // Strip mount point prefix for route matching, ensuring we keep the leading slash
+  let routePath = pathname.slice(MOUNT_POINT.length) || "/";
+  if (!routePath.startsWith('/')) {
+    routePath = '/' + routePath;
+  }
+
+  // Handle API routes
+  const router = createRouter();
+
+  // Register built-in API routes with runtime data
+  registerBuiltInRoutes(router, { config, tools, models, modelNames, prompts, promptNames, agents, agentNames });
+
+  // Register user thread API routes
+${threadRouteCode}
+
+  const routeMatch = findRoute(
+    router,
+    request.method.toUpperCase(),
+    routePath
+  );
+
+  if (routeMatch) {
+    // Check if authentication is required for this route
+    const publicRoute = isPublicRoute(routePath);
+    const isApiRoute = routePath.startsWith('/api/');
+
+    let authContext = null;
+
+    // Require authentication for all API routes except public ones
+    if (isApiRoute && !publicRoute) {
+      const authResult = await requireAuth(request, env);
+
+      // If requireAuth returns a Response, it's an error (401)
+      if (authResult instanceof Response) {
+        return authResult;
+      }
+
+      authContext = authResult;
+    }
+
+    const controller = await routeMatch.data();
+    const context = {
+      req: request,
+      params: routeMatch.params || {},
+      env: env,
+      url: url,
+      config,
+      tools,
+      auth: authContext, // Add auth context to controller context
+    };
+    const result = await controller(context);
+
+    if (result instanceof Response) {
+      return result;
+    }
+    if (typeof result === "string") {
+      return new Response(result, {
+        headers: {
+          "Content-Type": "text/plain",
+        },
+      });
+    }
+    return Response.json(result);
+  }
+
+  // Serve UI for all other routes (SPA fallback)
+  return serveUI(routePath, env);
+}
+
+async function serveUI(pathname, env) {
+  try {
+    // Use Cloudflare Workers Assets binding (automatically created from wrangler assets config)
+    if (env.ASSETS) {
+      try {
+        // Create a proper request for the asset path
+        // Use a dummy origin since we only care about the path
+        // Re-add mount point since pathname was stripped by router
+        const assetUrl = \`http://localhost\${MOUNT_POINT}\${pathname}\`;
+        let response = await env.ASSETS.fetch(assetUrl);
+
+        // If not found, fall back to index.html for SPA routing
+        const isIndexHtml = response.status === 404 || pathname === "/" || !pathname.includes(".");
+        if (isIndexHtml) {
+          response = await env.ASSETS.fetch(\`http://localhost\${MOUNT_POINT}/index.html\`);
+
+          // Transform HTML to use configured mount point
+          if (response.status === 200) {
+            const html = await response.text();
+            // Replace default /agentbuilder/ paths with configured mount point
+            const modifiedHtml = html.replace(/\\/agentbuilder\\//g, \`\${MOUNT_POINT}/\`);
+            return new Response(modifiedHtml, {
+              headers: {
+                "Content-Type": "text/html; charset=utf-8",
+              },
+            });
+          }
+        }
+
+        return response;
+      } catch (assetError) {
+        console.error("Error fetching from ASSETS:", assetError);
+      }
+    }
+
+    // Fallback: proxy to UI dev server if explicitly configured
+    if (env.UI_DEV_SERVER) {
+      const assetPath = pathname === "/" ? "/index.html" : pathname;
+      const response = await fetch(\`\${env.UI_DEV_SERVER}\${assetPath}\`);
+      return response;
+    }
+
+    // In production/dev, assets should be served by Cloudflare Workers automatically
+    // This function only handles fallback cases
+    return null;
+  } catch (error) {
+    console.error("Error serving UI:", error);
+    return null;
+  }
+}
+
+// Export DurableThread so users can re-export it from virtual module
+export { _DurableThread as DurableThread };
+`;
+      }
+      if (id === RESOLVED_VIRTUAL_HOOKS_ID) {
+        console.log("[plugin.load] \u2713 Loading HOOKS virtual module");
+        console.log("[plugin.load] hooksDir:", hooksDir);
+        const hooks = await scanHooksDirectory(hooksDir);
+        console.log(`[plugin.load] Scanned hooks directory, found ${hooks.length} hooks:`, hooks.map((h) => h.name));
+        const hooksCode = hooks.map(({ name, importPath }) => {
+          return `  "${name}": async () => {
+    try {
+      return (await import("${importPath}")).default;
+    } catch (error) {
+      console.error('[Hooks] Failed to import hook ${name}:', error);
+      return null;
+    }
+  },`;
+        }).join("\n");
+        return `// Virtual agent hooks module
+console.log('[virtual:agent-hooks] Module loaded with hooks:', Object.keys({${hooks.map((h) => `'${h.name}': null`).join(", ")}}));
+export const hooks = {
+${hooksCode}
+};`;
+      }
+      if (id === RESOLVED_VIRTUAL_CONFIG_ID) {
+        const relativeToolsDir = path3.relative(process.cwd(), toolsDir).replace(/\\/g, "/");
+        const relativeHooksDir = path3.relative(process.cwd(), hooksDir).replace(/\\/g, "/");
+        const relativeApiDir = path3.relative(process.cwd(), threadApiDir).replace(/\\/g, "/");
+        const relativeModelsDir = path3.relative(process.cwd(), modelsDir).replace(/\\/g, "/");
+        const relativePromptsDir = path3.relative(process.cwd(), promptsDir).replace(/\\/g, "/");
+        const relativeAgentsDir = path3.relative(process.cwd(), agentsDir).replace(/\\/g, "/");
+        return `// Virtual agent config module
+export const config = {
+  toolsDir: "${relativeToolsDir}",
+  hooksDir: "${relativeHooksDir}",
+  apiDir: "${relativeApiDir}",
+  modelsDir: "${relativeModelsDir}",
+  promptsDir: "${relativePromptsDir}",
+  agentsDir: "${relativeAgentsDir}",
+  mountPoint: "${mountPoint}",
+};`;
+      }
+      if (id === RESOLVED_VIRTUAL_MODELS_ID) {
+        const models = await scanModelsDirectory(modelsDir);
+        const modelsCode = models.map(({ name, importPath, error }) => {
+          if (error) {
+            const escapedError = error.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+            return `  "${name}": async () => { throw new Error("${escapedError}"); },`;
+          } else {
+            return `  "${name}": async () => {
+    try {
+      return (await import("${importPath}")).default;
+    } catch (error) {
+      console.error('Failed to import model ${name}:', error);
+      throw error;
+    }
+  },`;
+          }
+        }).join("\n");
+        return `// Virtual agent models module
+export const models = {
+${modelsCode}
+};
+
+export const modelNames = ${JSON.stringify(models.filter((m) => !m.error).map((m) => m.name))};
+`;
+      }
+      if (id === RESOLVED_VIRTUAL_PROMPTS_ID) {
+        const prompts = await scanPromptsDirectory(promptsDir);
+        const promptsCode = prompts.map(({ name, importPath, error }) => {
+          if (error) {
+            const escapedError = error.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+            return `  "${name}": async () => { throw new Error("${escapedError}"); },`;
+          } else {
+            return `  "${name}": async () => {
+    try {
+      return (await import("${importPath}")).default;
+    } catch (error) {
+      console.error('Failed to import prompt ${name}:', error);
+      throw error;
+    }
+  },`;
+          }
+        }).join("\n");
+        return `// Virtual agent prompts module
+export const prompts = {
+${promptsCode}
+};
+
+export const promptNames = ${JSON.stringify(prompts.filter((p) => !p.error).map((p) => p.name))};
+`;
+      }
+      if (id === RESOLVED_VIRTUAL_AGENTS_ID) {
+        const agents = await scanAgentsDirectory(agentsDir);
+        const agentsCode = agents.map(({ name, importPath, error }) => {
+          if (error) {
+            const escapedError = error.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+            return `  "${name}": async () => { throw new Error("${escapedError}"); },`;
+          } else {
+            return `  "${name}": async () => {
+    try {
+      return (await import("${importPath}")).default;
+    } catch (error) {
+      console.error('Failed to import agent ${name}:', error);
+      throw error;
+    }
+  },`;
+          }
+        }).join("\n");
+        return `// Virtual agent agents module
+export const agents = {
+${agentsCode}
+};
+
+export const agentNames = ${JSON.stringify(agents.filter((a) => !a.error).map((a) => a.name))};
+`;
+      }
+      if (id === RESOLVED_VIRTUAL_BUILDER_ID) {
+        const tools = await scanToolsDirectory(toolsDir);
+        const hooks = await scanHooksDirectory(hooksDir);
+        const models = await scanModelsDirectory(modelsDir);
+        const prompts = await scanPromptsDirectory(promptsDir);
+        const agents = await scanAgentsDirectory(agentsDir);
+        const toAbsolutePath = (relativePath) => {
+          if (relativePath.startsWith("./")) {
+            return path3.resolve(process.cwd(), relativePath).replace(/\\/g, "/");
+          }
+          return relativePath;
+        };
+        const toolsCode = tools.map(({ name, importPath, error }) => {
+          const absPath = toAbsolutePath(importPath);
+          if (error) {
+            const escapedError = error.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+            return `  "${name}": async () => ["${escapedError}", null, async () => ({ status: "error", error: "Tool validation failed" })],`;
+          } else {
+            return `  "${name}": async () => {
+    try {
+      return (await import("${absPath}")).default;
+    } catch (error) {
+      console.error('Failed to import tool ${name}:', error);
+      return ["Failed to load tool: " + error.message, null, async () => ({ status: "error", error: "Import failed" })];
+    }
+  },`;
+          }
+        }).join("\n");
+        const hooksCode = hooks.map(({ name, importPath }) => {
+          const absPath = toAbsolutePath(importPath);
+          return `  "${name}": async () => {
+    try {
+      return (await import("${absPath}")).default;
+    } catch (error) {
+      console.error('[Hooks] Failed to import hook ${name}:', error);
+      return null;
+    }
+  },`;
+        }).join("\n");
+        const modelsCode = models.map(({ name, importPath, error }) => {
+          const absPath = toAbsolutePath(importPath);
+          if (error) {
+            const escapedError = error.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+            return `  "${name}": async () => { throw new Error("${escapedError}"); },`;
+          } else {
+            return `  "${name}": async () => {
+    try {
+      return (await import("${absPath}")).default;
+    } catch (error) {
+      console.error('Failed to import model ${name}:', error);
+      throw error;
+    }
+  },`;
+          }
+        }).join("\n");
+        const promptsCode = prompts.map(({ name, importPath, error }) => {
+          const absPath = toAbsolutePath(importPath);
+          if (error) {
+            const escapedError = error.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+            return `  "${name}": async () => { throw new Error("${escapedError}"); },`;
+          } else {
+            return `  "${name}": async () => {
+    try {
+      return (await import("${absPath}")).default;
+    } catch (error) {
+      console.error('Failed to import prompt ${name}:', error);
+      throw error;
+    }
+  },`;
+          }
+        }).join("\n");
+        const agentsCode = agents.map(({ name, importPath, error }) => {
+          const absPath = toAbsolutePath(importPath);
+          if (error) {
+            const escapedError = error.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+            return `  "${name}": async () => { throw new Error("${escapedError}"); },`;
+          } else {
+            return `  "${name}": async () => {
+    try {
+      return (await import("${absPath}")).default;
+    } catch (error) {
+      console.error('Failed to import agent ${name}:', error);
+      throw error;
+    }
+  },`;
+          }
+        }).join("\n");
+        return `// Consolidated virtual module: virtual:@standardagents/builder
+// Provides DurableThread, DurableAgentBuilder, and router
+import { DurableThread as _BaseDurableThread } from '@standardagents/builder/runtime';
+import { DurableAgentBuilder as _BaseDurableAgentBuilder } from '@standardagents/builder/runtime';
+
+// Re-export router from virtual:@standardagents-routes
+export { router } from 'virtual:@standardagents-routes';
+
+// Registry objects
+const _tools = {
+${toolsCode}
+};
+
+const _hooks = {
+${hooksCode}
+};
+
+const _models = {
+${modelsCode}
+};
+
+const _prompts = {
+${promptsCode}
+};
+
+const _agents = {
+${agentsCode}
+};
+
+/**
+ * DurableThread with all virtual module methods already implemented.
+ * Simply extend this class in your agents/Thread.ts file.
+ */
+export class DurableThread extends _BaseDurableThread {
+  tools() {
+    return _tools;
+  }
+
+  hooks() {
+    return _hooks;
+  }
+
+  models() {
+    return _models;
+  }
+
+  prompts() {
+    return _prompts;
+  }
+
+  agents() {
+    return _agents;
+  }
+}
+
+/**
+ * DurableAgentBuilder with all virtual module methods already implemented.
+ * Simply extend this class in your agents/AgentBuilder.ts file.
+ */
+export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
+  tools() {
+    return _tools;
+  }
+
+  hooks() {
+    return _hooks;
+  }
+
+  models() {
+    return _models;
+  }
+
+  prompts() {
+    return _prompts;
+  }
+
+  agents() {
+    return _agents;
+  }
+}
+`;
+      }
+    },
+    buildStart() {
+      regenerateTypes();
+      this.addWatchFile(toolsDir);
+      this.addWatchFile(threadApiDir);
+      this.addWatchFile(hooksDir);
+      this.addWatchFile(modelsDir);
+      this.addWatchFile(promptsDir);
+      this.addWatchFile(agentsDir);
+    },
+    configureServer(server) {
+      server.watcher.on("add", async (file) => {
+        handleFileChange(file, server, "New file detected");
+      });
+      server.watcher.on("unlink", (file) => {
+        handleFileChange(file, server, "File removed");
+      });
+      server.middlewares.use(async (req, res, next) => {
+        const url = req.url;
+        if (!url || !url.startsWith(mountPoint)) {
+          next();
+          return;
+        }
+        let pathWithoutMount = url.slice(mountPoint.length) || "/";
+        if (!pathWithoutMount.startsWith("/")) {
+          pathWithoutMount = "/" + pathWithoutMount;
+        }
+        const method = req.method?.toUpperCase();
+        if (pathWithoutMount === "/api/models" && method === "GET") {
+          try {
+            const fs4 = await import('fs');
+            const files = fs4.existsSync(modelsDir) ? fs4.readdirSync(modelsDir).filter((f) => f.endsWith(".ts")) : [];
+            const modelList = files.map((file) => {
+              try {
+                const filePath = path3.join(modelsDir, file);
+                const content = fs4.readFileSync(filePath, "utf-8");
+                const getName = (c) => c.match(/name:\s*['"]([^'"]+)['"]/)?.[1];
+                const getProvider = (c) => c.match(/provider:\s*['"]([^'"]+)['"]/)?.[1];
+                const getModel = (c) => c.match(/model:\s*['"]([^'"]+)['"]/)?.[1];
+                const getInputPrice = (c) => {
+                  const match = c.match(/inputPrice:\s*([\d.]+)/);
+                  return match ? parseFloat(match[1]) : void 0;
+                };
+                const getOutputPrice = (c) => {
+                  const match = c.match(/outputPrice:\s*([\d.]+)/);
+                  return match ? parseFloat(match[1]) : void 0;
+                };
+                const getCachedPrice = (c) => {
+                  const match = c.match(/cachedPrice:\s*([\d.]+)/);
+                  return match ? parseFloat(match[1]) : void 0;
+                };
+                const getIncludedProviders = (c) => {
+                  const match = c.match(/includedProviders:\s*\[([^\]]*)\]/);
+                  if (!match) return void 0;
+                  const items = match[1].match(/['"]([^'"]+)['"]/g);
+                  return items ? items.map((s) => s.replace(/['"]/g, "")) : [];
+                };
+                const getFallbacks = (c) => {
+                  const match = c.match(/fallbacks:\s*\[([^\]]*)\]/);
+                  if (!match) return [];
+                  const items = match[1].match(/['"]([^'"]+)['"]/g);
+                  return items ? items.map((s) => s.replace(/['"]/g, "")) : [];
+                };
+                const name = getName(content);
+                if (!name) return null;
+                const fallbacks = getFallbacks(content);
+                const fallbackObjects = fallbacks.map((fallbackName, index) => ({
+                  id: fallbackName,
+                  name: fallbackName,
+                  order: index
+                }));
+                return {
+                  id: name,
+                  name,
+                  provider: getProvider(content),
+                  model: getModel(content),
+                  input_price: getInputPrice(content),
+                  output_price: getOutputPrice(content),
+                  cached_price: getCachedPrice(content),
+                  included_providers: getIncludedProviders(content),
+                  fallbacks: fallbackObjects,
+                  created_at: Math.floor(Date.now() / 1e3)
+                };
+              } catch (error) {
+                console.error(`Error loading model ${file}:`, error);
+                return null;
+              }
+            });
+            const validModels = modelList.filter(Boolean);
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ models: validModels }));
+            return;
+          } catch (error) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: error.message || "Failed to list models" }));
+            return;
+          }
+        }
+        if (pathWithoutMount === "/api/models" && method === "POST") {
+          try {
+            const rawBody = await parseRequestBody(req);
+            const body = transformModelData(rawBody);
+            const validationError = validateModelData(body);
+            if (validationError) {
+              res.statusCode = 400;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: validationError }));
+              return;
+            }
+            if (modelExists(modelsDir, body.name)) {
+              res.statusCode = 409;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: `Model '${body.name}' already exists. Use PUT to update.` }));
+              return;
+            }
+            const result = await saveModel(modelsDir, body, false);
+            if (result.success) {
+              await reloadModelsModule(server);
+              await reloadRouterModule(server);
+              res.statusCode = 201;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({
+                success: true,
+                model: body,
+                filePath: result.filePath
+              }));
+            } else {
+              res.statusCode = 500;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: result.error }));
+            }
+            return;
+          } catch (error) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: error.message || "Failed to create model" }));
+            return;
+          }
+        }
+        const modelPutMatch = pathWithoutMount.match(/^\/api\/models\/(.+)$/);
+        if (modelPutMatch && method === "PUT") {
+          try {
+            const urlModelName = decodeURIComponent(modelPutMatch[1]);
+            const rawBody = await parseRequestBody(req);
+            const body = transformModelData(rawBody);
+            const newName = body.name;
+            const isNameChange = newName && newName !== urlModelName;
+            const validationError = validateModelData(body);
+            if (validationError) {
+              res.statusCode = 400;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: validationError }));
+              return;
+            }
+            let updatedPrompts = [];
+            if (isNameChange) {
+              const renameResult = await renameModel(modelsDir, urlModelName, newName);
+              if (!renameResult.success) {
+                res.statusCode = 400;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ error: renameResult.error }));
+                return;
+              }
+              updatedPrompts = await updateModelReferencesInPrompts(promptsDir, urlModelName, newName);
+            }
+            const result = await saveModel(modelsDir, body, true);
+            if (result.success) {
+              await reloadModelsModule(server);
+              if (updatedPrompts.length > 0) {
+                await reloadPromptsModule(server);
+              }
+              await reloadRouterModule(server);
+              await new Promise((resolve) => setTimeout(resolve, 100));
+              res.statusCode = 200;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({
+                success: true,
+                model: body,
+                filePath: result.filePath,
+                ...isNameChange && { renamed: { from: urlModelName, to: newName }, updatedPrompts }
+              }));
+            } else {
+              res.statusCode = 500;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: result.error }));
+            }
+            return;
+          } catch (error) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: error.message || "Failed to update model" }));
+            return;
+          }
+        }
+        const modelDeleteMatch = pathWithoutMount.match(/^\/api\/models\/(.+)$/);
+        if (modelDeleteMatch && method === "DELETE") {
+          try {
+            const modelName = decodeURIComponent(modelDeleteMatch[1]);
+            const result = await deleteModel(modelsDir, modelName);
+            if (result.success) {
+              await reloadModelsModule(server);
+              await reloadRouterModule(server);
+              res.statusCode = 200;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({
+                success: true,
+                deleted: modelName,
+                filePath: result.filePath
+              }));
+            } else {
+              res.statusCode = 404;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: result.error }));
+            }
+            return;
+          } catch (error) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: error.message || "Failed to delete model" }));
+            return;
+          }
+        }
+        if (pathWithoutMount === "/api/prompts" && method === "POST") {
+          try {
+            const rawBody = await parseRequestBody(req);
+            const body = transformPromptData(rawBody);
+            const validationError = validatePromptData(body);
+            if (validationError) {
+              res.statusCode = 400;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: validationError }));
+              return;
+            }
+            if (promptExists(promptsDir, body.name)) {
+              res.statusCode = 409;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: `Prompt '${body.name}' already exists. Use PUT to update.` }));
+              return;
+            }
+            const result = await savePrompt(promptsDir, body, false);
+            if (result.success) {
+              await reloadPromptsModule(server);
+              await reloadRouterModule(server);
+              res.statusCode = 201;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({
+                success: true,
+                prompt: body,
+                filePath: result.filePath
+              }));
+            } else {
+              res.statusCode = 500;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: result.error }));
+            }
+            return;
+          } catch (error) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: error.message || "Failed to create prompt" }));
+            return;
+          }
+        }
+        const promptPutMatch = pathWithoutMount.match(/^\/api\/prompts\/([^/]+)$/);
+        if (promptPutMatch && method === "PUT") {
+          try {
+            const urlPromptName = decodeURIComponent(promptPutMatch[1]);
+            const rawBody = await parseRequestBody(req);
+            const body = transformPromptData(rawBody);
+            const newName = body.name;
+            const isNameChange = newName && newName !== urlPromptName;
+            const validationError = validatePromptData(body);
+            if (validationError) {
+              res.statusCode = 400;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: validationError }));
+              return;
+            }
+            let updatedPrompts = [];
+            let updatedAgents = [];
+            if (isNameChange) {
+              const renameResult = await renamePrompt(promptsDir, urlPromptName, newName);
+              if (!renameResult.success) {
+                res.statusCode = 400;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ error: renameResult.error }));
+                return;
+              }
+              updatedPrompts = await updatePromptReferencesInPrompts(promptsDir, urlPromptName, newName);
+              updatedAgents = await updatePromptReferencesInAgents(agentsDir, urlPromptName, newName);
+            }
+            const result = await savePrompt(promptsDir, body, true);
+            if (result.success) {
+              await reloadPromptsModule(server);
+              if (updatedAgents.length > 0) {
+                await reloadAgentsModule(server);
+              }
+              await reloadRouterModule(server);
+              res.statusCode = 200;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({
+                success: true,
+                prompt: body,
+                filePath: result.filePath,
+                ...isNameChange && { renamed: { from: urlPromptName, to: newName }, updatedPrompts, updatedAgents }
+              }));
+            } else {
+              res.statusCode = 500;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: result.error }));
+            }
+            return;
+          } catch (error) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: error.message || "Failed to update prompt" }));
+            return;
+          }
+        }
+        const promptDeleteMatch = pathWithoutMount.match(/^\/api\/prompts\/([^/]+)$/);
+        if (promptDeleteMatch && method === "DELETE") {
+          try {
+            const promptName = decodeURIComponent(promptDeleteMatch[1]);
+            const result = await deletePrompt(promptsDir, promptName);
+            if (result.success) {
+              await reloadPromptsModule(server);
+              await reloadRouterModule(server);
+              res.statusCode = 200;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({
+                success: true,
+                deleted: promptName,
+                filePath: result.filePath
+              }));
+            } else {
+              res.statusCode = 404;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: result.error }));
+            }
+            return;
+          } catch (error) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: error.message || "Failed to delete prompt" }));
+            return;
+          }
+        }
+        if (pathWithoutMount === "/api/agents" && method === "POST") {
+          try {
+            const rawBody = await parseRequestBody(req);
+            const body = transformAgentData(rawBody);
+            const validationError = validateAgentData(body);
+            if (validationError) {
+              res.statusCode = 400;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: validationError }));
+              return;
+            }
+            if (agentExists(agentsDir, body.name)) {
+              res.statusCode = 409;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: `Agent '${body.name}' already exists. Use PUT to update.` }));
+              return;
+            }
+            const result = await saveAgent(agentsDir, body, false);
+            if (result.success) {
+              await reloadAgentsModule(server);
+              await reloadRouterModule(server);
+              res.statusCode = 201;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({
+                success: true,
+                agent: body,
+                filePath: result.filePath
+              }));
+            } else {
+              res.statusCode = 500;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: result.error }));
+            }
+            return;
+          } catch (error) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: error.message || "Failed to create agent" }));
+            return;
+          }
+        }
+        const agentPutMatch = pathWithoutMount.match(/^\/api\/agents\/([^/]+)$/);
+        if (agentPutMatch && method === "PUT") {
+          try {
+            const agentName = decodeURIComponent(agentPutMatch[1]);
+            const rawBody = await parseRequestBody(req);
+            const body = transformAgentData(rawBody);
+            body.name = agentName;
+            const validationError = validateAgentData(body);
+            if (validationError) {
+              res.statusCode = 400;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: validationError }));
+              return;
+            }
+            const result = await saveAgent(agentsDir, body, true);
+            if (result.success) {
+              await reloadAgentsModule(server);
+              await reloadRouterModule(server);
+              res.statusCode = 200;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({
+                success: true,
+                agent: body,
+                filePath: result.filePath
+              }));
+            } else {
+              res.statusCode = 500;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: result.error }));
+            }
+            return;
+          } catch (error) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: error.message || "Failed to update agent" }));
+            return;
+          }
+        }
+        const agentDeleteMatch = pathWithoutMount.match(/^\/api\/agents\/([^/]+)$/);
+        if (agentDeleteMatch && method === "DELETE") {
+          try {
+            const agentName = decodeURIComponent(agentDeleteMatch[1]);
+            const result = await deleteAgent(agentsDir, agentName);
+            if (result.success) {
+              await reloadAgentsModule(server);
+              await reloadRouterModule(server);
+              res.statusCode = 200;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({
+                success: true,
+                deleted: agentName,
+                filePath: result.filePath
+              }));
+            } else {
+              res.statusCode = 404;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: result.error }));
+            }
+            return;
+          } catch (error) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: error.message || "Failed to delete agent" }));
+            return;
+          }
+        }
+        if (pathWithoutMount.startsWith("/api/")) {
+          next();
+          return;
+        }
+        const isStaticAsset = pathWithoutMount.startsWith("/assets/") || pathWithoutMount.startsWith("/vendor.js") || pathWithoutMount.startsWith("/vue.js") || pathWithoutMount.startsWith("/monaco.js") || pathWithoutMount.startsWith("/index.js") || pathWithoutMount.startsWith("/index.css") || pathWithoutMount.match(/\.(js|css|png|jpg|jpeg|gif|svg|woff|woff2|ttf|eot|ico)$/);
+        {
+          const currentDir = path3.dirname(fileURLToPath(import.meta.url));
+          const isInDist = currentDir.endsWith("dist");
+          const clientDir = path3.resolve(
+            currentDir,
+            isInDist ? "./client" : "../dist/client"
+          );
+          let filePath;
+          if (isStaticAsset) {
+            const cleanUrl = pathWithoutMount.split("?")[0];
+            filePath = path3.join(clientDir, cleanUrl);
+          } else {
+            filePath = path3.join(clientDir, "index.html");
+          }
+          try {
+            if (fs2.existsSync(filePath)) {
+              let content = fs2.readFileSync(filePath);
+              const ext = path3.extname(filePath).toLowerCase();
+              if (ext === ".html") {
+                const configScript = `<script>window.__AGENTBUILDER_CONFIG__ = { mountPoint: "${mountPoint}" };</script>`;
+                let htmlContent = content.toString();
+                const assetPrefix = mountPoint === "/" ? "/" : `${mountPoint}/`;
+                htmlContent = htmlContent.replace(/\/agentbuilder\//g, assetPrefix);
+                htmlContent = htmlContent.replace("</head>", `${configScript}</head>`);
+                content = Buffer.from(htmlContent);
+              }
+              const mimeTypes = {
+                ".html": "text/html",
+                ".js": "application/javascript",
+                ".css": "text/css",
+                ".ttf": "font/ttf",
+                ".woff": "font/woff",
+                ".woff2": "font/woff2",
+                ".svg": "image/svg+xml",
+                ".png": "image/png",
+                ".jpg": "image/jpeg"
+              };
+              const contentType = mimeTypes[ext] || "application/octet-stream";
+              res.setHeader("Content-Type", contentType);
+              res.end(content);
+              return;
+            }
+          } catch (error) {
+            console.error("Error serving AgentBuilder UI:", error);
+          }
+        }
+        next();
+      });
+    },
+    handleHotUpdate({ file, server }) {
+      handleFileChange(file, server, "File modified");
+    },
+    writeBundle(options2, bundle) {
+      const outDir = options2.dir || "dist";
+      const mountPath = mountPoint.slice(1);
+      const mountDir = mountPath ? path3.join(outDir, "../client", mountPath) : path3.join(outDir, "../client");
+      const currentDir = path3.dirname(fileURLToPath(import.meta.url));
+      const isInDist = currentDir.endsWith("dist");
+      const clientDir = path3.resolve(
+        currentDir,
+        isInDist ? "./client" : "../dist/client"
+      );
+      if (!fs2.existsSync(clientDir)) {
+        console.warn(`[agentbuilder] Client directory not found at ${clientDir}`);
+        return;
+      }
+      fs2.mkdirSync(mountDir, { recursive: true });
+      function copyRecursive(src, dest) {
+        const entries = fs2.readdirSync(src, { withFileTypes: true });
+        for (const entry of entries) {
+          const srcPath = path3.join(src, entry.name);
+          const destPath = path3.join(dest, entry.name);
+          if (entry.isDirectory()) {
+            fs2.mkdirSync(destPath, { recursive: true });
+            copyRecursive(srcPath, destPath);
+          } else {
+            let content = fs2.readFileSync(srcPath);
+            if (entry.name === "index.html") {
+              const configScript = `<script>window.__AGENTBUILDER_CONFIG__ = { mountPoint: "${mountPoint}" };</script>`;
+              let htmlContent = content.toString();
+              const assetPrefix = mountPoint === "/" ? "/" : `${mountPoint}/`;
+              htmlContent = htmlContent.replace(/\/agentbuilder\//g, assetPrefix);
+              htmlContent = htmlContent.replace("</head>", `${configScript}</head>`);
+              content = Buffer.from(htmlContent);
+            }
+            fs2.writeFileSync(destPath, content);
+          }
+        }
+      }
+      copyRecursive(clientDir, mountDir);
+      console.log(`[agentbuilder] Copied client files to ${mountDir}`);
+    }
+  };
+}
+
+export { agentbuilder };
+//# sourceMappingURL=plugin.js.map
+//# sourceMappingURL=plugin.js.map