@standardagents/builder 0.8.1

package/dist/built-in-routes.js

@@ -0,0 +1,2333 @@
+import { z } from 'zod';
+
+// ../../node_modules/.pnpm/rou3@0.7.9/node_modules/rou3/dist/index.mjs
+var NullProtoObj = /* @__PURE__ */ (() => {
+  const e = function() {
+  };
+  return e.prototype = /* @__PURE__ */ Object.create(null), Object.freeze(e.prototype), e;
+})();
+function splitPath(path) {
+  const [_, ...s] = path.split("/");
+  return s[s.length - 1] === "" ? s.slice(0, -1) : s;
+}
+function addRoute(ctx, method = "", path, data) {
+  method = method.toUpperCase();
+  if (path.charCodeAt(0) !== 47) path = `/${path}`;
+  const segments = splitPath(path);
+  let node = ctx.root;
+  let _unnamedParamIndex = 0;
+  const paramsMap = [];
+  const paramsRegexp = [];
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    if (segment.startsWith("**")) {
+      if (!node.wildcard) node.wildcard = { key: "**" };
+      node = node.wildcard;
+      paramsMap.push([
+        -i,
+        segment.split(":")[1] || "_",
+        segment.length === 2
+      ]);
+      break;
+    }
+    if (segment === "*" || segment.includes(":")) {
+      if (!node.param) node.param = { key: "*" };
+      node = node.param;
+      if (segment === "*") paramsMap.push([
+        i,
+        `_${_unnamedParamIndex++}`,
+        true
+      ]);
+      else if (segment.includes(":", 1)) {
+        const regexp = getParamRegexp(segment);
+        paramsRegexp[i] = regexp;
+        node.hasRegexParam = true;
+        paramsMap.push([
+          i,
+          regexp,
+          false
+        ]);
+      } else paramsMap.push([
+        i,
+        segment.slice(1),
+        false
+      ]);
+      continue;
+    }
+    const child = node.static?.[segment];
+    if (child) node = child;
+    else {
+      const staticNode = { key: segment };
+      if (!node.static) node.static = new NullProtoObj();
+      node.static[segment] = staticNode;
+      node = staticNode;
+    }
+  }
+  const hasParams = paramsMap.length > 0;
+  if (!node.methods) node.methods = new NullProtoObj();
+  node.methods[method] ??= [];
+  node.methods[method].push({
+    data: data || null,
+    paramsRegexp,
+    paramsMap: hasParams ? paramsMap : void 0
+  });
+  if (!hasParams) ctx.static[path] = node;
+}
+function getParamRegexp(segment) {
+  const regex = segment.replace(/:(\w+)/g, (_, id) => `(?<${id}>[^/]+)`).replace(/\./g, "\\.");
+  return /* @__PURE__ */ new RegExp(`^${regex}$`);
+}
+
+// src/router/index.ts
+function defineController(controller) {
+  return controller;
+}
+
+// src/api/index.post.ts
+var index_post_default = defineController(() => {
+  const stream = new ReadableStream({
+    start(controller) {
+      const text = "hello world";
+      let index = 0;
+      const next = () => {
+        if (index < text.length) {
+          controller.enqueue(new TextEncoder().encode(text[index]));
+          index++;
+          setTimeout(next, 100);
+        } else {
+          controller.close();
+        }
+      };
+      next();
+    }
+  });
+  return new Response(stream);
+});
+
+// src/api/agents.get.ts
+var agents_get_default = defineController(async ({ agents, agentNames, prompts, promptNames }) => {
+  if (!agents || !agentNames) {
+    return Response.json({ agents: [] });
+  }
+  const promptMap = {};
+  if (prompts && promptNames) {
+    await Promise.all(
+      promptNames.map(async (name) => {
+        try {
+          const loader = prompts[name];
+          if (loader) {
+            promptMap[name] = await loader();
+          }
+        } catch (error) {
+        }
+      })
+    );
+  }
+  const agentList = await Promise.all(
+    agentNames.map(async (name) => {
+      try {
+        const loader = agents[name];
+        if (!loader) {
+          return null;
+        }
+        const definition = await loader();
+        const sideAPrompt = promptMap[definition.sideA?.prompt];
+        const sideBPrompt = definition.sideB ? promptMap[definition.sideB?.prompt] : null;
+        return {
+          id: definition.name,
+          name: definition.name,
+          title: definition.title,
+          type: definition.type || "ai_human",
+          // Side A configuration
+          side_a_label: definition.sideA?.label || null,
+          side_a_agent_prompt: definition.sideA?.prompt,
+          side_a_agent_prompt_name: sideAPrompt?.name || definition.sideA?.prompt,
+          side_a_stop_on_response: definition.sideA?.stopOnResponse !== void 0 ? definition.sideA.stopOnResponse : true,
+          side_a_stop_tool: definition.sideA?.stopTool || null,
+          side_a_stop_tool_response_property: definition.sideA?.stopToolResponseProperty || null,
+          side_a_max_turns: definition.sideA?.maxTurns || null,
+          side_a_end_conversation_tool: definition.sideA?.endConversationTool || null,
+          side_a_manual_stop_condition: definition.sideA?.manualStopCondition || false,
+          // Side B configuration (if dual_ai)
+          side_b_label: definition.sideB?.label || null,
+          side_b_agent_prompt: definition.sideB?.prompt || null,
+          side_b_agent_prompt_name: sideBPrompt?.name || definition.sideB?.prompt || null,
+          side_b_stop_on_response: definition.sideB?.stopOnResponse !== void 0 ? definition.sideB.stopOnResponse : true,
+          side_b_stop_tool: definition.sideB?.stopTool || null,
+          side_b_stop_tool_response_property: definition.sideB?.stopToolResponseProperty || null,
+          side_b_max_turns: definition.sideB?.maxTurns || null,
+          side_b_end_conversation_tool: definition.sideB?.endConversationTool || null,
+          side_b_manual_stop_condition: definition.sideB?.manualStopCondition || false,
+          // Session configuration
+          max_session_turns: definition.maxSessionTurns || null,
+          // Tool exposure
+          expose_as_tool: definition.exposeAsTool || false,
+          tool_description: definition.toolDescription || null,
+          // Tags
+          tags: definition.tags || [],
+          created_at: Math.floor(Date.now() / 1e3)
+        };
+      } catch (error) {
+        console.error(`Error loading agent ${name}:`, error);
+        return null;
+      }
+    })
+  );
+  const validAgents = agentList.filter(Boolean);
+  return Response.json({ agents: validAgents });
+});
+
+// src/utils/auth.ts
+function generateSecureToken(length = 32) {
+  const array = new Uint8Array(length);
+  crypto.getRandomValues(array);
+  return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function generateUserToken() {
+  return `agtuser_${generateSecureToken(32)}`;
+}
+function generateApiKey() {
+  return `agtbldr_${generateSecureToken(32)}`;
+}
+async function hashPassword(password) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(password);
+  const salt = crypto.getRandomValues(new Uint8Array(16));
+  const keyMaterial = await crypto.subtle.importKey(
+    "raw",
+    data,
+    { name: "PBKDF2" },
+    false,
+    ["deriveBits"]
+  );
+  const derivedBits = await crypto.subtle.deriveBits(
+    {
+      name: "PBKDF2",
+      salt,
+      iterations: 1e5,
+      hash: "SHA-256"
+    },
+    keyMaterial,
+    256
+  );
+  const hashArray = new Uint8Array(derivedBits);
+  const combined = new Uint8Array(salt.length + hashArray.length);
+  combined.set(salt);
+  combined.set(hashArray, salt.length);
+  return bufferToBase64(combined);
+}
+async function verifyPassword(password, hash) {
+  try {
+    const combined = base64ToBuffer(hash);
+    const salt = combined.slice(0, 16);
+    const storedHash = combined.slice(16);
+    const encoder = new TextEncoder();
+    const data = encoder.encode(password);
+    const keyMaterial = await crypto.subtle.importKey(
+      "raw",
+      data,
+      { name: "PBKDF2" },
+      false,
+      ["deriveBits"]
+    );
+    const derivedBits = await crypto.subtle.deriveBits(
+      {
+        name: "PBKDF2",
+        salt,
+        iterations: 1e5,
+        hash: "SHA-256"
+      },
+      keyMaterial,
+      256
+    );
+    const derivedHash = new Uint8Array(derivedBits);
+    if (derivedHash.length !== storedHash.length) {
+      return false;
+    }
+    let matches = true;
+    for (let i = 0; i < derivedHash.length; i++) {
+      if (derivedHash[i] !== storedHash[i]) {
+        matches = false;
+      }
+    }
+    return matches;
+  } catch (error) {
+    console.error("Error verifying password:", error);
+    return false;
+  }
+}
+async function hashToken(token) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(token);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = new Uint8Array(hashBuffer);
+  return Array.from(hashArray, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function getLastChars(str, count = 5) {
+  return str.slice(-count);
+}
+function getTokenPrefix(token) {
+  const match = token.match(/^([^_]+_)/);
+  return match ? match[1] : "";
+}
+function isValidUserToken(token) {
+  return token.startsWith("agtuser_") && token.length > 10;
+}
+function isValidApiKey(key) {
+  return key.startsWith("agtbldr_") && key.length > 10;
+}
+async function signToken(payload, encryptionKey) {
+  const encoder = new TextEncoder();
+  const keyData = encoder.encode(encryptionKey);
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    keyData,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const payloadData = encoder.encode(payload);
+  const signature = await crypto.subtle.sign("HMAC", cryptoKey, payloadData);
+  const payloadB64 = bufferToBase64(new Uint8Array(payloadData));
+  const signatureB64 = bufferToBase64(new Uint8Array(signature));
+  return `${payloadB64}.${signatureB64}`;
+}
+async function verifySignedToken(signedToken, encryptionKey) {
+  try {
+    const parts = signedToken.split(".");
+    if (parts.length !== 2) {
+      return null;
+    }
+    const [payloadB64, signatureB64] = parts;
+    const encoder = new TextEncoder();
+    const keyData = encoder.encode(encryptionKey);
+    const cryptoKey = await crypto.subtle.importKey(
+      "raw",
+      keyData,
+      { name: "HMAC", hash: "SHA-256" },
+      false,
+      ["verify"]
+    );
+    const payloadData = base64ToBuffer(payloadB64);
+    const signature = base64ToBuffer(signatureB64);
+    const isValid = await crypto.subtle.verify("HMAC", cryptoKey, signature, payloadData);
+    if (!isValid) {
+      return null;
+    }
+    const decoder = new TextDecoder();
+    return decoder.decode(payloadData);
+  } catch (error) {
+    console.error("Error verifying signed token:", error);
+    return null;
+  }
+}
+async function generateSuperAdminToken(encryptionKey) {
+  const timestamp = Date.now();
+  const nonce = generateSecureToken(16);
+  const payload = `super_admin:${timestamp}:${nonce}`;
+  return await signToken(payload, encryptionKey);
+}
+async function verifySuperAdminToken(token, encryptionKey) {
+  const payload = await verifySignedToken(token, encryptionKey);
+  if (!payload) {
+    return false;
+  }
+  const parts = payload.split(":");
+  if (parts.length !== 3 || parts[0] !== "super_admin") {
+    return false;
+  }
+  const timestamp = parseInt(parts[1], 10);
+  const age = Date.now() - timestamp;
+  const maxAge = 30 * 24 * 60 * 60 * 1e3;
+  if (age > maxAge) {
+    return false;
+  }
+  return true;
+}
+function bufferToBase64(buffer) {
+  let binary = "";
+  for (let i = 0; i < buffer.byteLength; i++) {
+    binary += String.fromCharCode(buffer[i]);
+  }
+  return btoa(binary);
+}
+function base64ToBuffer(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
+// src/middleware/auth.ts
+function extractBearerToken(request) {
+  const authHeader = request.headers.get("Authorization");
+  if (authHeader && authHeader.startsWith("Bearer ")) {
+    return authHeader.substring(7);
+  }
+  const isWebSocket = request.headers.get("upgrade")?.toLowerCase() === "websocket";
+  if (isWebSocket) {
+    try {
+      const url = new URL(request.url);
+      const token = url.searchParams.get("token");
+      if (token) {
+        return token;
+      }
+    } catch (err) {
+    }
+  }
+  return null;
+}
+function getAgentBuilder(env) {
+  const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+  return env.AGENT_BUILDER.get(agentBuilderId);
+}
+async function authenticate(request, env) {
+  const token = extractBearerToken(request);
+  if (!token) {
+    return null;
+  }
+  if (env.SUPER_ADMIN_PASSWORD && env.ENCRYPTION_KEY) {
+    if (token.includes(".")) {
+      const isValidSuperAdmin = await verifySuperAdminToken(
+        token,
+        env.ENCRYPTION_KEY
+      );
+      if (isValidSuperAdmin) {
+        return {
+          user: {
+            id: "super_admin",
+            username: "admin",
+            role: "admin"
+          },
+          authType: "super_admin"
+        };
+      }
+    }
+  }
+  if (isValidUserToken(token)) {
+    const tokenHash = await hashToken(token);
+    const agentBuilder = getAgentBuilder(env);
+    const session = await agentBuilder.validateSession(tokenHash);
+    if (session) {
+      const user = await agentBuilder.getUserById(session.user_id);
+      if (user) {
+        return {
+          user: {
+            id: user.id,
+            username: user.username,
+            role: user.role
+          },
+          authType: "session"
+        };
+      }
+    }
+  }
+  if (isValidApiKey(token)) {
+    const keyHash = await hashToken(token);
+    const agentBuilder = getAgentBuilder(env);
+    const apiKey = await agentBuilder.validateApiKey(keyHash);
+    if (apiKey) {
+      const user = await agentBuilder.getUserById(apiKey.user_id);
+      if (user) {
+        return {
+          user: {
+            id: user.id,
+            username: user.username,
+            role: user.role
+          },
+          authType: "api_key"
+        };
+      }
+    }
+  }
+  return null;
+}
+async function requireAuth(request, env) {
+  const authContext = await authenticate(request, env);
+  if (!authContext) {
+    return new Response(JSON.stringify({ error: "Unauthorized" }), {
+      status: 401,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  return authContext;
+}
+async function requireAdmin(request, env) {
+  const result = await requireAuth(request, env);
+  if (result instanceof Response) {
+    return result;
+  }
+  if (result.user.role !== "admin") {
+    return new Response(
+      JSON.stringify({ error: "Forbidden: Admin access required" }),
+      {
+        status: 403,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  }
+  return result;
+}
+
+// src/api/api-keys/index.get.ts
+var index_get_default = defineController(async ({ req, env }) => {
+  try {
+    const authResult = await requireAuth(req, env);
+    if (authResult instanceof Response) {
+      return authResult;
+    }
+    if (authResult.authType === "super_admin") {
+      return Response.json({ keys: [], message: "Super admin has no API keys. Create a user account to manage API keys." });
+    }
+    const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+    const keys = await agentBuilder.listApiKeys(authResult.user.id);
+    return Response.json({ keys });
+  } catch (error) {
+    console.error("List API keys error:", error);
+    return Response.json(
+      { error: error.message || "Failed to list API keys" },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/api-keys/index.post.ts
+var index_post_default2 = defineController(async ({ req, env }) => {
+  try {
+    const authResult = await requireAuth(req, env);
+    if (authResult instanceof Response) {
+      return authResult;
+    }
+    if (authResult.authType === "super_admin") {
+      return Response.json(
+        { error: "Super admin cannot create API keys. Please create a user account first." },
+        { status: 400 }
+      );
+    }
+    const body = await req.json();
+    const { name } = body;
+    if (!name || typeof name !== "string") {
+      return Response.json(
+        { error: "Name is required" },
+        { status: 400 }
+      );
+    }
+    if (name.length < 1 || name.length > 100) {
+      return Response.json(
+        { error: "Name must be between 1 and 100 characters" },
+        { status: 400 }
+      );
+    }
+    const apiKey = generateApiKey();
+    const keyHash = await hashToken(apiKey);
+    const keyPrefix = getTokenPrefix(apiKey);
+    const lastFive = getLastChars(apiKey, 5);
+    const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+    const id = await agentBuilder.createApiKey({
+      name,
+      key_hash: keyHash,
+      key_prefix: keyPrefix,
+      last_five: lastFive,
+      user_id: authResult.user.id
+    });
+    const now = Math.floor(Date.now() / 1e3);
+    return Response.json({
+      key: apiKey,
+      // Only returned once on creation
+      id,
+      name,
+      key_prefix: keyPrefix,
+      last_five: lastFive,
+      created_at: now
+    }, { status: 201 });
+  } catch (error) {
+    console.error("Create API key error:", error);
+    return Response.json(
+      { error: error.message || "Failed to create API key" },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/config.get.ts
+var config_get_default = defineController(async ({ config }) => {
+  return Response.json(config);
+});
+
+// src/api/diagnostics.get.ts
+var diagnostics_get_default = defineController(async ({ tools, prompts, promptNames, agents, agentNames }) => {
+  const warnings = [];
+  const toolNameSources = /* @__PURE__ */ new Map();
+  if (tools) {
+    const toolNames = Object.keys(tools);
+    for (const name of toolNames) {
+      const sources = toolNameSources.get(name) || /* @__PURE__ */ new Set();
+      sources.add("native tool");
+      toolNameSources.set(name, sources);
+    }
+  }
+  if (prompts && promptNames) {
+    for (const name of promptNames) {
+      const sources = toolNameSources.get(name) || /* @__PURE__ */ new Set();
+      sources.add("prompt");
+      toolNameSources.set(name, sources);
+    }
+  }
+  if (agents && agentNames) {
+    for (const name of agentNames) {
+      try {
+        const loader = agents[name];
+        if (loader) {
+          const definition = await loader();
+          if (definition.exposeAsTool) {
+            const sources = toolNameSources.get(name) || /* @__PURE__ */ new Set();
+            sources.add("agent");
+            toolNameSources.set(name, sources);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  for (const [name, sources] of toolNameSources) {
+    if (sources.size > 1) {
+      warnings.push({
+        type: "duplicate_tool_name",
+        message: `Duplicate tool name "${name}" detected`,
+        details: {
+          name,
+          sources: [...sources]
+        }
+      });
+    }
+  }
+  return Response.json({ warnings });
+});
+
+// src/api/events.get.ts
+var events_get_default = defineController(async ({ req, env }) => {
+  if (req.headers.get("upgrade")?.toLowerCase() !== "websocket") {
+    return Response.json(
+      { error: "This endpoint requires a WebSocket connection" },
+      { status: 400 }
+    );
+  }
+  try {
+    const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+    const stub = env.AGENT_BUILDER.get(agentBuilderId);
+    return await stub.fetch(req);
+  } catch (error) {
+    console.error("Error establishing events WebSocket:", error);
+    return Response.json(
+      { error: error.message || "Failed to establish WebSocket connection" },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/models.get.ts
+var models_get_default = defineController(async ({ models, modelNames }) => {
+  if (!models || !modelNames) {
+    return Response.json({ models: [] });
+  }
+  const modelList = await Promise.all(
+    modelNames.map(async (name) => {
+      try {
+        const loader = models[name];
+        if (!loader) {
+          return null;
+        }
+        const definition = await loader();
+        const fallbackObjects = (definition.fallbacks || []).map(
+          (fallbackName, index) => ({
+            id: fallbackName,
+            name: fallbackName,
+            order: index
+          })
+        );
+        return {
+          id: definition.name,
+          name: definition.name,
+          provider: definition.provider,
+          model: definition.model,
+          input_price: definition.inputPrice,
+          output_price: definition.outputPrice,
+          cached_price: definition.cachedPrice,
+          included_providers: definition.includedProviders,
+          fallbacks: fallbackObjects,
+          created_at: Math.floor(Date.now() / 1e3)
+          // Not persisted, use current time
+        };
+      } catch (error) {
+        console.error(`Error loading model ${name}:`, error);
+        return null;
+      }
+    })
+  );
+  const validModels = modelList.filter(Boolean);
+  return Response.json({ models: validModels });
+});
+
+// src/api/new-test.get.ts
+var new_test_get_default = defineController(async ({ req, params, env }) => {
+  return { message: "Modified new test API route", timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+});
+function toJSONSchema(schema) {
+  if (!schema) return null;
+  if (schema && typeof schema === "object" && ("~standard" in schema || "_def" in schema)) {
+    return z.toJSONSchema(schema);
+  }
+  return schema;
+}
+function normalizePromptContent(prompt) {
+  if (!prompt) return "";
+  if (Array.isArray(prompt)) {
+    return JSON.stringify(prompt);
+  }
+  return prompt;
+}
+var prompts_get_default = defineController(async ({ prompts, promptNames, models, modelNames }) => {
+  if (!prompts || !promptNames) {
+    return Response.json({ prompts: [] });
+  }
+  const modelMap = {};
+  if (models && modelNames) {
+    await Promise.all(
+      modelNames.map(async (name) => {
+        try {
+          const loader = models[name];
+          if (loader) {
+            modelMap[name] = await loader();
+          }
+        } catch (error) {
+        }
+      })
+    );
+  }
+  const promptList = await Promise.all(
+    promptNames.map(async (name) => {
+      try {
+        const loader = prompts[name];
+        if (!loader) {
+          return null;
+        }
+        const definition = await loader();
+        const modelDef = modelMap[definition.model];
+        const tools = (definition.tools || []).map(
+          (tool) => typeof tool === "string" ? tool : tool.name
+        );
+        return {
+          id: definition.name,
+          name: definition.name,
+          tool_description: definition.toolDescription,
+          prompt: normalizePromptContent(definition.prompt),
+          required_schema: toJSONSchema(definition.requiredSchema),
+          model_id: definition.model,
+          model_name: modelDef?.name || definition.model,
+          model_provider: modelDef?.provider || "unknown",
+          include_chat: definition.includeChat || false,
+          include_past_tools: definition.includePastTools || false,
+          parallel_tool_calls: definition.parallelToolCalls || false,
+          tool_choice: definition.toolChoice || "auto",
+          before_tool: definition.beforeTool || null,
+          after_tool: definition.afterTool || null,
+          tools,
+          prompts: definition.handoffAgents || [],
+          reasoning: definition.reasoning || null,
+          created_at: Math.floor(Date.now() / 1e3)
+        };
+      } catch (error) {
+        console.error(`Error loading prompt ${name}:`, error);
+        return null;
+      }
+    })
+  );
+  const validPrompts = promptList.filter(Boolean);
+  return Response.json({ prompts: validPrompts });
+});
+
+// src/api/providers.get.ts
+var SUPPORTED_PROVIDERS = [
+  {
+    name: "openai",
+    sdk: "openai",
+    label: "OpenAI",
+    envKey: "OPENAI_API_KEY"
+  },
+  {
+    name: "openrouter",
+    sdk: "openrouter",
+    label: "OpenRouter",
+    envKey: "OPENROUTER_API_KEY"
+  }
+];
+var providers_get_default = defineController(async ({ env }) => {
+  const providers = SUPPORTED_PROVIDERS.map((provider) => ({
+    name: provider.name,
+    sdk: provider.sdk,
+    label: provider.label,
+    hasApiKey: Boolean(env[provider.envKey])
+  }));
+  return Response.json({ providers });
+});
+
+// src/api/threads/index.post.ts
+var index_post_default3 = defineController(async ({ req, env }) => {
+  let body;
+  try {
+    body = await req.json();
+  } catch (error) {
+    return Response.json(
+      { error: "Invalid JSON in request body" },
+      { status: 400 }
+    );
+  }
+  const { agent_id, user_id, initial_messages, data, tags } = body;
+  if (!agent_id) {
+    return Response.json(
+      { error: "Missing required field: agent_id" },
+      { status: 400 }
+    );
+  }
+  if (initial_messages !== void 0 && initial_messages !== null) {
+    if (!Array.isArray(initial_messages)) {
+      return Response.json(
+        { error: "initial_messages must be an array" },
+        { status: 400 }
+      );
+    }
+  }
+  if (tags !== void 0 && tags !== null) {
+    if (!Array.isArray(tags)) {
+      return Response.json(
+        { error: "tags must be an array of strings" },
+        { status: 400 }
+      );
+    }
+    if (!tags.every((tag) => typeof tag === "string")) {
+      return Response.json(
+        { error: "All tags must be strings" },
+        { status: 400 }
+      );
+    }
+  }
+  const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+  const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+  try {
+    await agentBuilder.loadAgent(agent_id);
+  } catch (error) {
+    return Response.json(
+      { error: `Agent not found: ${agent_id}` },
+      { status: 404 }
+    );
+  }
+  try {
+    const thread = await agentBuilder.createThread({
+      agent_name: agent_id,
+      user_id,
+      tags
+    });
+    return Response.json({
+      threadId: thread.id,
+      agent_id: thread.agent_name,
+      message: "Thread created successfully"
+    });
+  } catch (error) {
+    console.error(`Error creating thread:`, error);
+    return Response.json(
+      {
+        error: error.message || "Failed to create thread"
+      },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/threads/index.ts
+var threads_default = defineController(async ({ req, env }) => {
+  if (req.method !== "GET") {
+    return new Response("Method Not Allowed", { status: 405 });
+  }
+  try {
+    const url = new URL(req.url);
+    const limit = parseInt(url.searchParams.get("limit") || "50", 10);
+    const offset = parseInt(url.searchParams.get("offset") || "0", 10);
+    const agentName = url.searchParams.get("agent_id");
+    const userId = url.searchParams.get("user_id");
+    const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+    const result = await agentBuilder.listThreads({
+      agent_name: agentName || void 0,
+      user_id: userId || void 0,
+      limit,
+      offset
+    });
+    const threads = await Promise.all(
+      result.threads.map(async (thread) => {
+        let agentDetails = null;
+        try {
+          const agentDef = await agentBuilder.loadAgent(thread.agent_name);
+          agentDetails = {
+            title: agentDef.title,
+            type: agentDef.type || "ai_human"
+          };
+        } catch {
+          agentDetails = { title: thread.agent_name, type: "unknown" };
+        }
+        return {
+          id: thread.id,
+          agent_id: thread.agent_name,
+          user_id: thread.user_id,
+          tags: thread.tags || [],
+          created_at: thread.created_at,
+          agent: agentDetails
+        };
+      })
+    );
+    return Response.json({
+      threads,
+      total: result.total,
+      hasMore: offset + threads.length < result.total
+    });
+  } catch (error) {
+    console.error("Error fetching threads:", error);
+    return Response.json(
+      { error: error.message || "Failed to fetch threads" },
+      { status: 500 }
+    );
+  }
+});
+function toJSONSchema2(schema) {
+  if (!schema) return null;
+  try {
+    if (schema && typeof schema === "object" && ("~standard" in schema || schema._def)) {
+      return z.toJSONSchema(schema);
+    }
+    return schema;
+  } catch {
+    return null;
+  }
+}
+var tools_get_default = defineController(async ({ url, tools, prompts, promptNames, agents, agentNames, models, modelNames }) => {
+  const type = url.searchParams.get("type");
+  const includeSchema = url.searchParams.get("schema") === "true";
+  const modelMap = {};
+  if (models && modelNames) {
+    await Promise.all(
+      modelNames.map(async (name) => {
+        try {
+          const loader = models[name];
+          if (loader) {
+            modelMap[name] = await loader();
+          }
+        } catch (error) {
+        }
+      })
+    );
+  }
+  if (type === "prompts") {
+    if (!prompts || !promptNames) {
+      return Response.json({});
+    }
+    const result2 = {};
+    await Promise.all(
+      promptNames.map(async (name) => {
+        try {
+          const loader = prompts[name];
+          if (!loader) return;
+          const definition = await loader();
+          const modelDef = modelMap[definition.model];
+          result2[name] = {
+            description: definition.toolDescription || "",
+            schema: includeSchema && definition.requiredSchema ? toJSONSchema2(definition.requiredSchema) : null,
+            hasError: false,
+            type: "prompt",
+            model: modelDef?.name || definition.model
+          };
+        } catch (error) {
+          console.error(`Error loading prompt ${name}:`, error);
+        }
+      })
+    );
+    return Response.json(result2);
+  }
+  if (type === "agents") {
+    if (!agents || !agentNames) {
+      return Response.json({});
+    }
+    const result2 = {};
+    await Promise.all(
+      agentNames.map(async (name) => {
+        try {
+          const loader = agents[name];
+          if (!loader) return;
+          const definition = await loader();
+          if (!definition.exposeAsTool) return;
+          result2[name] = {
+            description: definition.toolDescription || definition.title || "",
+            schema: null,
+            // Agents don't have schemas
+            hasError: false,
+            type: "agent"
+          };
+        } catch (error) {
+          console.error(`Error loading agent ${name}:`, error);
+        }
+      })
+    );
+    return Response.json(result2);
+  }
+  const result = {};
+  if (tools) {
+    const toolNames = Object.keys(tools);
+    await Promise.all(
+      toolNames.map(async (name) => {
+        try {
+          const loader = tools[name];
+          if (!loader) return;
+          const toolResult = await loader();
+          if (Array.isArray(toolResult) && typeof toolResult[0] === "string" && toolResult[0].includes("error")) {
+            result[name] = {
+              description: "",
+              schema: null,
+              hasError: true,
+              error: toolResult[0],
+              type: "tool"
+            };
+            return;
+          }
+          const [description, schema] = toolResult;
+          result[name] = {
+            description: description || "",
+            schema: includeSchema && schema ? toJSONSchema2(schema) : null,
+            hasError: false,
+            type: "tool"
+          };
+        } catch (error) {
+          console.error(`Error loading tool ${name}:`, error);
+          result[name] = {
+            description: "",
+            schema: null,
+            hasError: true,
+            error: `Error loading tool: ${error}`,
+            type: "tool"
+          };
+        }
+      })
+    );
+  }
+  if (prompts && promptNames) {
+    await Promise.all(
+      promptNames.map(async (name) => {
+        try {
+          const loader = prompts[name];
+          if (!loader) return;
+          const definition = await loader();
+          const modelDef = modelMap[definition.model];
+          result[name] = {
+            description: definition.toolDescription || "",
+            schema: includeSchema && definition.requiredSchema ? toJSONSchema2(definition.requiredSchema) : null,
+            hasError: false,
+            type: "prompt",
+            model: modelDef?.name || definition.model
+          };
+        } catch (error) {
+          console.error(`Error loading prompt ${name}:`, error);
+        }
+      })
+    );
+  }
+  return Response.json(result);
+});
+
+// src/api/users/index.get.ts
+var index_get_default2 = defineController(async ({ req, env }) => {
+  try {
+    const authResult = await requireAdmin(req, env);
+    if (authResult instanceof Response) {
+      return authResult;
+    }
+    const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+    const users = await agentBuilder.listUsers();
+    return Response.json({ users });
+  } catch (error) {
+    console.error("List users error:", error);
+    return Response.json(
+      { error: error.message || "Failed to list users" },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/users/index.post.ts
+var index_post_default4 = defineController(async ({ req, env }) => {
+  try {
+    const authResult = await requireAdmin(req, env);
+    if (authResult instanceof Response) {
+      return authResult;
+    }
+    const body = await req.json();
+    const { username, password, role = "admin" } = body;
+    if (!username || !password) {
+      return Response.json(
+        { error: "Username and password are required" },
+        { status: 400 }
+      );
+    }
+    if (!/^[a-zA-Z0-9_-]+$/.test(username)) {
+      return Response.json(
+        { error: "Username can only contain letters, numbers, underscores, and hyphens" },
+        { status: 400 }
+      );
+    }
+    if (username.length < 3 || username.length > 50) {
+      return Response.json(
+        { error: "Username must be between 3 and 50 characters" },
+        { status: 400 }
+      );
+    }
+    if (password.length < 8) {
+      return Response.json(
+        { error: "Password must be at least 8 characters" },
+        { status: 400 }
+      );
+    }
+    const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+    const existingUser = await agentBuilder.getUserByUsername(username);
+    if (existingUser) {
+      return Response.json(
+        { error: "Username already exists" },
+        { status: 400 }
+      );
+    }
+    const password_hash = await hashPassword(password);
+    const user = await agentBuilder.createUser({
+      username,
+      password_hash,
+      role
+    });
+    return Response.json({
+      user: {
+        id: user.id,
+        username: user.username,
+        role: user.role,
+        created_at: user.created_at,
+        updated_at: user.updated_at
+      }
+    }, { status: 201 });
+  } catch (error) {
+    console.error("Create user error:", error);
+    return Response.json(
+      { error: error.message || "Failed to create user" },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/agents/[name].get.ts
+var name_get_default = defineController(async ({ params, agents, prompts, promptNames }) => {
+  const { name } = params;
+  if (!agents || !agents[name]) {
+    return Response.json({ error: "Agent not found" }, { status: 404 });
+  }
+  try {
+    const promptMap = {};
+    if (prompts && promptNames) {
+      await Promise.all(
+        promptNames.map(async (promptName) => {
+          try {
+            const loader2 = prompts[promptName];
+            if (loader2) {
+              promptMap[promptName] = await loader2();
+            }
+          } catch (error) {
+          }
+        })
+      );
+    }
+    const loader = agents[name];
+    const definition = await loader();
+    const sideAPrompt = promptMap[definition.sideA?.prompt];
+    const sideBPrompt = definition.sideB ? promptMap[definition.sideB?.prompt] : null;
+    const agent = {
+      id: definition.name,
+      name: definition.name,
+      // title is deprecated - include for backward compatibility but prefer name
+      title: definition.title || definition.name,
+      type: definition.type || "ai_human",
+      // Side A configuration
+      side_a_label: definition.sideA?.label || null,
+      side_a_agent_prompt: definition.sideA?.prompt,
+      side_a_agent_prompt_name: sideAPrompt?.name || definition.sideA?.prompt,
+      side_a_stop_on_response: definition.sideA?.stopOnResponse !== void 0 ? definition.sideA.stopOnResponse : true,
+      side_a_stop_tool: definition.sideA?.stopTool || null,
+      side_a_stop_tool_response_property: definition.sideA?.stopToolResponseProperty || null,
+      side_a_max_turns: definition.sideA?.maxTurns || null,
+      side_a_end_conversation_tool: definition.sideA?.endConversationTool || null,
+      side_a_manual_stop_condition: definition.sideA?.manualStopCondition || false,
+      // Side B configuration (if dual_ai)
+      side_b_label: definition.sideB?.label || null,
+      side_b_agent_prompt: definition.sideB?.prompt || null,
+      side_b_agent_prompt_name: sideBPrompt?.name || definition.sideB?.prompt || null,
+      side_b_stop_on_response: definition.sideB?.stopOnResponse !== void 0 ? definition.sideB.stopOnResponse : true,
+      side_b_stop_tool: definition.sideB?.stopTool || null,
+      side_b_stop_tool_response_property: definition.sideB?.stopToolResponseProperty || null,
+      side_b_max_turns: definition.sideB?.maxTurns || null,
+      side_b_end_conversation_tool: definition.sideB?.endConversationTool || null,
+      side_b_manual_stop_condition: definition.sideB?.manualStopCondition || false,
+      // Session configuration
+      max_session_turns: definition.maxSessionTurns || null,
+      // Tool exposure
+      expose_as_tool: definition.exposeAsTool || false,
+      tool_description: definition.toolDescription || null,
+      // Tags
+      tags: definition.tags || [],
+      created_at: Math.floor(Date.now() / 1e3)
+    };
+    return Response.json({ agent });
+  } catch (error) {
+    console.error(`Error loading agent ${name}:`, error);
+    return Response.json(
+      { error: `Error loading agent: ${error}` },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/api-keys/[id].delete.ts
+var id_delete_default = defineController(async ({ req, env, params }) => {
+  try {
+    const authResult = await requireAuth(req, env);
+    if (authResult instanceof Response) {
+      return authResult;
+    }
+    if (authResult.authType === "super_admin") {
+      return Response.json(
+        { error: "Super admin has no API keys to delete." },
+        { status: 400 }
+      );
+    }
+    const keyId = params.id;
+    if (!keyId) {
+      return Response.json(
+        { error: "API key ID is required" },
+        { status: 400 }
+      );
+    }
+    const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+    await agentBuilder.deleteApiKey(keyId, authResult.user.id);
+    return Response.json({ success: true });
+  } catch (error) {
+    console.error("Delete API key error:", error);
+    return Response.json(
+      { error: error.message || "Failed to delete API key" },
+      { status: 500 }
+    );
+  }
+});
+function toJSONSchema3(schema) {
+  if (!schema) return null;
+  if (schema && typeof schema === "object" && ("~standard" in schema || "_def" in schema)) {
+    return z.toJSONSchema(schema);
+  }
+  return schema;
+}
+function normalizePromptContent2(prompt) {
+  if (!prompt) return "";
+  if (Array.isArray(prompt)) {
+    return JSON.stringify(prompt);
+  }
+  return prompt;
+}
+var name_get_default2 = defineController(async ({ params, prompts, models, modelNames }) => {
+  const { name } = params;
+  if (!prompts || !prompts[name]) {
+    return Response.json({ error: "Prompt not found" }, { status: 404 });
+  }
+  try {
+    const modelMap = {};
+    if (models && modelNames) {
+      await Promise.all(
+        modelNames.map(async (modelName) => {
+          try {
+            const loader2 = models[modelName];
+            if (loader2) {
+              modelMap[modelName] = await loader2();
+            }
+          } catch (error) {
+          }
+        })
+      );
+    }
+    const loader = prompts[name];
+    const definition = await loader();
+    const modelDef = modelMap[definition.model];
+    const tools = (definition.tools || []).map((tool) => {
+      if (typeof tool === "string") {
+        return {
+          name: tool,
+          include_text_response: true,
+          include_tool_calls: true,
+          include_errors: true,
+          init_user_message_property: null
+        };
+      }
+      return {
+        name: tool.name,
+        include_text_response: tool.includeTextResponse !== void 0 ? tool.includeTextResponse : true,
+        include_tool_calls: tool.includeToolCalls !== void 0 ? tool.includeToolCalls : true,
+        include_errors: tool.includeErrors !== void 0 ? tool.includeErrors : true,
+        init_user_message_property: tool.initUserMessageProperty || null
+      };
+    });
+    const prompt = {
+      id: definition.name,
+      name: definition.name,
+      tool_description: definition.toolDescription,
+      prompt: normalizePromptContent2(definition.prompt),
+      required_schema: toJSONSchema3(definition.requiredSchema),
+      model_id: definition.model,
+      model_name: modelDef?.name || definition.model,
+      model_provider: modelDef?.provider || "unknown",
+      include_chat: definition.includeChat || false,
+      include_past_tools: definition.includePastTools || false,
+      parallel_tool_calls: definition.parallelToolCalls || false,
+      tool_choice: definition.toolChoice || "auto",
+      before_tool: definition.beforeTool || null,
+      after_tool: definition.afterTool || null,
+      tools,
+      prompts: definition.handoffAgents || [],
+      reasoning: definition.reasoning || null,
+      created_at: Math.floor(Date.now() / 1e3)
+    };
+    return Response.json({ prompt });
+  } catch (error) {
+    console.error(`Error loading prompt ${name}:`, error);
+    return Response.json(
+      { error: `Error loading prompt: ${error}` },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/threads/[id].delete.ts
+var id_delete_default2 = defineController(async ({ req, env, params }) => {
+  const threadId = params.id;
+  if (!threadId) {
+    return Response.json({ error: "Missing thread ID" }, { status: 400 });
+  }
+  const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+  const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+  const thread = await agentBuilder.getThread(threadId);
+  if (!thread) {
+    return Response.json(
+      { error: `Thread not found: ${threadId}` },
+      { status: 404 }
+    );
+  }
+  try {
+    await agentBuilder.deleteThread(threadId);
+    const durableId = env.AGENT_BUILDER_THREAD.idFromName(threadId);
+    const stub = env.AGENT_BUILDER_THREAD.get(durableId);
+    await stub.deleteThread();
+    return Response.json({
+      success: true,
+      threadId,
+      message: "Thread deleted successfully"
+    });
+  } catch (error) {
+    console.error(`Error deleting thread ${threadId}:`, error);
+    return Response.json(
+      {
+        error: error.message || "Failed to delete thread",
+        threadId
+      },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/threads/[id].patch.ts
+var id_patch_default = defineController(async ({ req, env, params }) => {
+  if (req.method !== "PATCH") {
+    return new Response("Method Not Allowed", { status: 405 });
+  }
+  const threadId = params?.id;
+  if (!threadId) {
+    return Response.json({ error: "Thread ID required" }, { status: 400 });
+  }
+  try {
+    const body = await req.json();
+    const { tags, agent_id } = body;
+    const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+    const existingThread = await agentBuilder.getThread(threadId);
+    if (!existingThread) {
+      return Response.json(
+        { error: `Thread not found: ${threadId}` },
+        { status: 404 }
+      );
+    }
+    const updates = {};
+    if (tags !== void 0) {
+      if (!Array.isArray(tags)) {
+        return Response.json(
+          { error: "tags must be an array of strings" },
+          { status: 400 }
+        );
+      }
+      if (!tags.every((tag) => typeof tag === "string")) {
+        return Response.json(
+          { error: "All tags must be strings" },
+          { status: 400 }
+        );
+      }
+      updates.tags = tags;
+    }
+    if (agent_id !== void 0) {
+      if (typeof agent_id !== "string") {
+        return Response.json(
+          { error: "agent_id must be a string" },
+          { status: 400 }
+        );
+      }
+      const durableId = env.AGENT_BUILDER_THREAD.idFromName(threadId);
+      const stub = env.AGENT_BUILDER_THREAD.get(durableId);
+      try {
+        const agentDef = await stub.loadAgent(agent_id);
+        if (!agentDef) {
+          return Response.json(
+            { error: `Agent not found: ${agent_id}` },
+            { status: 404 }
+          );
+        }
+        if (agentDef.type !== "ai_human") {
+          return Response.json(
+            { error: "Only ai_human agents can be assigned to threads" },
+            { status: 400 }
+          );
+        }
+      } catch (e) {
+        return Response.json(
+          { error: `Agent not found: ${agent_id}` },
+          { status: 404 }
+        );
+      }
+      updates.agent_name = agent_id;
+    }
+    if (Object.keys(updates).length === 0) {
+      return Response.json(
+        { error: "No valid fields to update" },
+        { status: 400 }
+      );
+    }
+    const updatedThread = await agentBuilder.updateThread(threadId, updates);
+    return Response.json({
+      id: updatedThread.id,
+      agent_id: updatedThread.agent_name,
+      // Map agent_name back to agent_id for API compat
+      user_id: updatedThread.user_id,
+      tags: updatedThread.tags || [],
+      created_at: updatedThread.created_at
+    });
+  } catch (error) {
+    console.error("Error updating thread:", error);
+    return Response.json(
+      { error: error.message || "Failed to update thread" },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/threads/[id].ts
+var id_default = defineController(async ({ req, params, env }) => {
+  const threadId = params.id;
+  if (!threadId) {
+    return Response.json({ error: "Thread ID required" }, { status: 400 });
+  }
+  try {
+    const durableId = env.AGENT_BUILDER_THREAD.idFromName(threadId);
+    const stub = env.AGENT_BUILDER_THREAD.get(durableId);
+    const doData = await stub.getThreadMeta(threadId);
+    if (!doData) {
+      return Response.json(
+        { error: `Thread not found: ${threadId}` },
+        { status: 404 }
+      );
+    }
+    return Response.json(doData);
+  } catch (error) {
+    console.error(`Error fetching thread ${threadId}:`, error);
+    return Response.json(
+      { error: error.message || "Failed to fetch thread" },
+      { status: 500 }
+    );
+  }
+});
+function toJSONSchema4(schema) {
+  if (!schema) return null;
+  try {
+    if (schema && typeof schema === "object" && ("~standard" in schema || schema._def)) {
+      return z.toJSONSchema(schema);
+    }
+    return schema;
+  } catch {
+    return null;
+  }
+}
+var name_get_default3 = defineController(async ({ params, tools }) => {
+  const { name } = params;
+  if (!tools || !tools[name]) {
+    return Response.json({ error: "Tool not found" }, { status: 404 });
+  }
+  try {
+    const loader = tools[name];
+    const toolResult = await loader();
+    if (Array.isArray(toolResult) && typeof toolResult[0] === "string" && toolResult[0].includes("error")) {
+      return Response.json({
+        name,
+        description: "",
+        schema: null,
+        hasError: true,
+        error: toolResult[0]
+      });
+    }
+    const [description, schema] = toolResult;
+    return Response.json({
+      name,
+      description: description || "",
+      schema: toJSONSchema4(schema),
+      hasError: false
+    });
+  } catch (error) {
+    console.error(`Error loading tool ${name}:`, error);
+    return Response.json({
+      name,
+      description: "",
+      schema: null,
+      hasError: true,
+      error: `Error loading tool: ${error}`
+    });
+  }
+});
+
+// src/api/users/[id].delete.ts
+var id_delete_default3 = defineController(async ({ req, env, params }) => {
+  try {
+    const authResult = await requireAdmin(req, env);
+    if (authResult instanceof Response) {
+      return authResult;
+    }
+    const { id } = params;
+    if (!id) {
+      return Response.json({ error: "User ID is required" }, { status: 400 });
+    }
+    const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+    const user = await agentBuilder.getUserById(id);
+    if (!user) {
+      return Response.json({ error: "User not found" }, { status: 404 });
+    }
+    await agentBuilder.deleteUser(id);
+    return Response.json({ success: true });
+  } catch (error) {
+    console.error("Delete user error:", error);
+    return Response.json(
+      { error: error.message || "Failed to delete user" },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/users/[id].put.ts
+var id_put_default = defineController(async ({ req, env, params }) => {
+  try {
+    const authResult = await requireAdmin(req, env);
+    if (authResult instanceof Response) {
+      return authResult;
+    }
+    const { id } = params;
+    if (!id) {
+      return Response.json({ error: "User ID is required" }, { status: 400 });
+    }
+    const body = await req.json();
+    const { username, password, role } = body;
+    const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+    const existingUser = await agentBuilder.getUserById(id);
+    if (!existingUser) {
+      return Response.json({ error: "User not found" }, { status: 404 });
+    }
+    if (username && username !== existingUser.username) {
+      const userWithUsername = await agentBuilder.getUserByUsername(username);
+      if (userWithUsername && userWithUsername.id !== id) {
+        return Response.json(
+          { error: "Username already taken" },
+          { status: 409 }
+        );
+      }
+    }
+    const updateParams = {};
+    if (username) {
+      updateParams.username = username;
+    }
+    if (password) {
+      updateParams.password_hash = await hashPassword(password);
+    }
+    if (role) {
+      updateParams.role = role;
+    }
+    const updatedUser = await agentBuilder.updateUser(id, updateParams);
+    return Response.json({
+      user: {
+        id: updatedUser.id,
+        username: updatedUser.username,
+        role: updatedUser.role,
+        created_at: updatedUser.created_at,
+        updated_at: updatedUser.updated_at
+      }
+    });
+  } catch (error) {
+    console.error("Update user error:", error);
+    return Response.json(
+      { error: error.message || "Failed to update user" },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/auth/config.get.ts
+var config_get_default2 = defineController(async ({ env }) => {
+  const githubConfigured = !!(env.GITHUB_CLIENT_ID && env.GITHUB_CLIENT_SECRET);
+  const googleConfigured = !!(env.GOOGLE_CLIENT_ID && env.GOOGLE_CLIENT_SECRET);
+  return {
+    github: githubConfigured,
+    google: googleConfigured
+  };
+});
+
+// src/api/auth/login.post.ts
+var login_post_default = defineController(async ({ req, env }) => {
+  try {
+    const body = await req.json();
+    const { username, password } = body;
+    if (!password) {
+      return Response.json(
+        { error: "Password is required" },
+        { status: 400 }
+      );
+    }
+    if (env.SUPER_ADMIN_PASSWORD && password === env.SUPER_ADMIN_PASSWORD) {
+      if (!env.ENCRYPTION_KEY) {
+        return Response.json(
+          { error: "Server misconfigured: ENCRYPTION_KEY required for super admin" },
+          { status: 500 }
+        );
+      }
+      const token2 = await generateSuperAdminToken(env.ENCRYPTION_KEY);
+      return Response.json({
+        token: token2,
+        user: {
+          id: "super_admin",
+          username: "admin",
+          role: "admin"
+        }
+      });
+    }
+    if (!username) {
+      return Response.json(
+        { error: "Username is required" },
+        { status: 400 }
+      );
+    }
+    const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+    const user = await agentBuilder.getUserByUsername(username);
+    if (!user) {
+      return Response.json(
+        { error: "Invalid username or password" },
+        { status: 401 }
+      );
+    }
+    const isValid = await verifyPassword(password, user.password_hash);
+    if (!isValid) {
+      return Response.json(
+        { error: "Invalid username or password" },
+        { status: 401 }
+      );
+    }
+    const token = generateUserToken();
+    const tokenHash = await hashToken(token);
+    const expiresAt = Math.floor(Date.now() / 1e3) + 30 * 24 * 60 * 60;
+    await agentBuilder.createSession({
+      user_id: user.id,
+      token_hash: tokenHash,
+      expires_at: expiresAt
+    });
+    return Response.json({
+      token,
+      user: {
+        id: user.id,
+        username: user.username,
+        role: user.role
+      }
+    });
+  } catch (error) {
+    console.error("Login error:", error);
+    return Response.json(
+      { error: error.message || "Login failed" },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/auth/logout.post.ts
+var logout_post_default = defineController(async ({ req, env }) => {
+  try {
+    const authHeader = req.headers.get("Authorization");
+    if (!authHeader || !authHeader.startsWith("Bearer ")) {
+      return Response.json({ error: "Unauthorized" }, { status: 401 });
+    }
+    const token = authHeader.substring(7);
+    if (token.includes(".")) {
+      return Response.json({ success: true });
+    }
+    if (isValidUserToken(token)) {
+      const tokenHash = await hashToken(token);
+      const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+      const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+      await agentBuilder.deleteSession(tokenHash);
+    }
+    return Response.json({ success: true });
+  } catch (error) {
+    console.error("Logout error:", error);
+    return Response.json(
+      { error: error.message || "Logout failed" },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/auth/me.get.ts
+var me_get_default = defineController(async ({ req, env }) => {
+  try {
+    const authContext = await authenticate(req, env);
+    if (!authContext) {
+      return Response.json({ error: "Unauthorized" }, { status: 401 });
+    }
+    return Response.json({
+      user: authContext.user,
+      authType: authContext.authType
+    });
+  } catch (error) {
+    console.error("Auth check error:", error);
+    return Response.json(
+      { error: error.message || "Authentication check failed" },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/models/available.post.ts
+var PROVIDER_CONFIGS = {
+  openai: {
+    sdk: "openai",
+    modelsEndpoint: "https://api.openai.com/v1/models",
+    envKey: "OPENAI_API_KEY",
+    headers: (apiKey) => ({
+      Authorization: `Bearer ${apiKey}`
+    }),
+    parseResponse: (data) => {
+      const chatModelPrefixes = [
+        "gpt-4",
+        "gpt-3.5",
+        "o1",
+        "o3",
+        "chatgpt"
+      ];
+      return data.data.filter((model) => {
+        const id = model.id.toLowerCase();
+        return chatModelPrefixes.some((prefix) => id.startsWith(prefix));
+      }).map((model) => ({
+        value: model.id,
+        label: model.id,
+        description: `Owned by ${model.owned_by}`,
+        iconId: "openai"
+      })).sort((a, b) => a.label.localeCompare(b.label));
+    }
+  },
+  openrouter: {
+    sdk: "openrouter",
+    modelsEndpoint: "https://openrouter.ai/api/v1/models",
+    envKey: "OPENROUTER_API_KEY",
+    headers: () => ({}),
+    // OpenRouter models endpoint doesn't require auth
+    parseResponse: (data) => {
+      return data.data.map((model) => ({
+        value: model.id,
+        label: model.name || model.id,
+        description: model.description?.slice(0, 150) + (model.description?.length > 150 ? "..." : "") || "",
+        slug: model.canonical_slug || model.id,
+        iconId: model.id.split("/")[0]
+        // e.g., "anthropic" from "anthropic/claude-3"
+      })).sort((a, b) => a.label.localeCompare(b.label));
+    }
+  }
+};
+var available_post_default = defineController(async ({ req, env }) => {
+  const body = await req.json().catch(() => ({}));
+  const { provider } = body;
+  if (!provider) {
+    return Response.json({ error: "Provider is required" }, { status: 400 });
+  }
+  const config = PROVIDER_CONFIGS[provider];
+  if (!config) {
+    return Response.json(
+      { error: `Unknown provider: ${provider}. Supported: ${Object.keys(PROVIDER_CONFIGS).join(", ")}` },
+      { status: 400 }
+    );
+  }
+  const apiKey = env[config.envKey];
+  if (!apiKey && config.sdk !== "openrouter") {
+    return Response.json(
+      { error: `API key not configured for ${provider}. Set ${config.envKey} environment variable.` },
+      { status: 401 }
+    );
+  }
+  try {
+    const response = await fetch(config.modelsEndpoint, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        ...config.headers(apiKey || "")
+      }
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error(`Failed to fetch models from ${provider}:`, errorText);
+      return Response.json(
+        { error: `Failed to fetch models from ${provider}: ${response.statusText}` },
+        { status: response.status }
+      );
+    }
+    const data = await response.json();
+    const models = config.parseResponse(data);
+    return Response.json({ models });
+  } catch (error) {
+    console.error(`Error fetching models from ${provider}:`, error);
+    return Response.json(
+      { error: `Failed to fetch models: ${error.message}` },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/models/endpoints.post.ts
+var endpoints_post_default = defineController(async ({ req, env }) => {
+  const body = await req.json().catch(() => ({}));
+  const { provider, modelSlug } = body;
+  if (!provider || !modelSlug) {
+    return Response.json(
+      { error: "Provider and modelSlug are required" },
+      { status: 400 }
+    );
+  }
+  if (provider !== "openrouter") {
+    return Response.json(
+      { error: "Endpoints are only available for OpenRouter provider" },
+      { status: 400 }
+    );
+  }
+  const slashIndex = modelSlug.indexOf("/");
+  if (slashIndex === -1) {
+    return Response.json(
+      { error: `Invalid model slug format: ${modelSlug}. Expected format: author/model-name` },
+      { status: 400 }
+    );
+  }
+  const author = modelSlug.substring(0, slashIndex);
+  const slug = modelSlug.substring(slashIndex + 1);
+  try {
+    const response = await fetch(`https://openrouter.ai/api/v1/models/${author}/${slug}/endpoints`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        return Response.json(
+          { error: `Model not found: ${modelSlug}` },
+          { status: 404 }
+        );
+      }
+      const errorText = await response.text();
+      console.error(`Failed to fetch endpoints from OpenRouter:`, errorText);
+      return Response.json(
+        { error: `Failed to fetch endpoints: ${response.statusText}` },
+        { status: response.status }
+      );
+    }
+    const data = await response.json();
+    const endpoints = parseOpenRouterEndpoints(data);
+    return Response.json({ endpoints });
+  } catch (error) {
+    console.error(`Error fetching endpoints for ${modelSlug}:`, error);
+    return Response.json(
+      { error: `Failed to fetch endpoints: ${error.message}` },
+      { status: 500 }
+    );
+  }
+});
+function parseOpenRouterEndpoints(data) {
+  const model = data.data || data;
+  const endpointsArray = model.endpoints || [];
+  if (!Array.isArray(endpointsArray) || endpointsArray.length === 0) {
+    return [];
+  }
+  return endpointsArray.map((endpoint) => ({
+    // Use 'tag' as the ID since it's the provider identifier used for routing
+    id: endpoint.tag || endpoint.provider_name || endpoint.name,
+    name: endpoint.name || endpoint.provider_name || endpoint.tag,
+    pricing: {
+      // Pricing values come as strings, convert to numbers
+      prompt: parseFloat(endpoint.pricing?.prompt) || 0,
+      completion: parseFloat(endpoint.pricing?.completion) || 0
+    },
+    quantization: endpoint.quantization,
+    maxPromptTokens: endpoint.max_prompt_tokens || endpoint.context_length,
+    maxCompletionTokens: endpoint.max_completion_tokens
+  }));
+}
+
+// src/api/threads/[id]/cost.get.ts
+var cost_get_default = defineController(async ({ req, params, env }) => {
+  const threadId = params.id;
+  if (!threadId) {
+    return Response.json({ error: "Thread ID required" }, { status: 400 });
+  }
+  try {
+    const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+    const thread = await agentBuilder.getThread(threadId);
+    if (!thread) {
+      return Response.json(
+        { error: `Thread not found: ${threadId}` },
+        { status: 404 }
+      );
+    }
+    const durableId = env.AGENT_BUILDER_THREAD.idFromName(threadId);
+    const stub = env.AGENT_BUILDER_THREAD.get(durableId);
+    const logsResult = await stub.getLogs(1e4, 0, "ASC");
+    const logs = logsResult.logs || [];
+    let totalCost = 0;
+    const modelCosts = {};
+    const uniqueMessages = /* @__PURE__ */ new Set();
+    for (const log of logs) {
+      const cost = log.cost_total;
+      if (cost !== null && cost !== void 0 && !isNaN(cost)) {
+        totalCost += cost;
+        if (log.message_id) {
+          uniqueMessages.add(log.message_id);
+        }
+        const modelKey = log.model_name || log.model || "unknown";
+        if (!modelCosts[modelKey]) {
+          modelCosts[modelKey] = {
+            totalCost: 0,
+            count: 0
+          };
+        }
+        modelCosts[modelKey].totalCost += cost;
+        modelCosts[modelKey].count += 1;
+      }
+    }
+    const messageCount = uniqueMessages.size;
+    const avgCostPerMessage = messageCount > 0 ? totalCost / messageCount : 0;
+    const avgCostPerMessageByModel = {};
+    for (const [modelName, data] of Object.entries(modelCosts)) {
+      avgCostPerMessageByModel[modelName] = {
+        avgCost: data.count > 0 ? data.totalCost / data.count : 0,
+        messageCount: data.count
+      };
+    }
+    const modelBreakdown = Object.entries(modelCosts).map(([modelName, data]) => ({
+      modelName,
+      totalCost: data.totalCost,
+      requestCount: data.count,
+      avgCostPerRequest: data.count > 0 ? data.totalCost / data.count : 0
+    }));
+    return Response.json({
+      totalCost,
+      messageCount,
+      avgCostPerMessage,
+      modelBreakdown,
+      avgCostPerMessageByModel
+    });
+  } catch (error) {
+    console.error(`Error calculating cost for thread ${threadId}:`, error);
+    return Response.json(
+      { error: error.message || "Failed to calculate costs" },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/threads/[id]/logs.get.ts
+var logs_get_default = defineController(async ({ req, params, env }) => {
+  const url = new URL(req.url);
+  const threadId = params.id;
+  if (!threadId) {
+    return Response.json({ error: "Thread ID required" }, { status: 400 });
+  }
+  try {
+    const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+    const thread = await agentBuilder.getThread(threadId);
+    if (!thread) {
+      return Response.json(
+        { error: `Thread not found: ${threadId}` },
+        { status: 404 }
+      );
+    }
+    const limit = parseInt(url.searchParams.get("limit") || "100", 10);
+    const offset = parseInt(url.searchParams.get("offset") || "0", 10);
+    const order = url.searchParams.get("order") === "desc" ? "DESC" : "ASC";
+    if (req.headers.get("upgrade")?.toLowerCase() === "websocket") {
+      const durableId2 = env.AGENT_BUILDER_THREAD.idFromName(threadId);
+      const stub2 = env.AGENT_BUILDER_THREAD.get(durableId2);
+      return await stub2.fetch(req);
+    }
+    const durableId = env.AGENT_BUILDER_THREAD.idFromName(threadId);
+    const stub = env.AGENT_BUILDER_THREAD.get(durableId);
+    const result = await stub.getLogs(limit, offset, order);
+    return Response.json(result);
+  } catch (error) {
+    console.error(`Error fetching logs for thread ${threadId}:`, error);
+    return Response.json(
+      { error: error.message || "Failed to fetch logs" },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/threads/[id]/message.post.ts
+var message_post_default = defineController(async ({ req, params, env }) => {
+  const threadId = params.id;
+  if (!threadId) {
+    return Response.json({ error: "Thread ID required" }, { status: 400 });
+  }
+  try {
+    const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+    const thread = await agentBuilder.getThread(threadId);
+    if (!thread) {
+      return Response.json(
+        { error: `Thread not found: ${threadId}` },
+        { status: 404 }
+      );
+    }
+    const body = await req.json();
+    const { content, role } = body;
+    if (!content || typeof content !== "string") {
+      return Response.json(
+        { error: "Message content is required" },
+        { status: 400 }
+      );
+    }
+    const durableId = env.AGENT_BUILDER_THREAD.idFromName(threadId);
+    const stub = env.AGENT_BUILDER_THREAD.get(durableId);
+    return await stub.sendMessage(threadId, content, role);
+  } catch (error) {
+    console.error(`Error sending message to thread ${threadId}:`, error);
+    return Response.json(
+      { error: error.message || "Failed to send message" },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/threads/[id]/messages.get.ts
+var messages_get_default = defineController(async ({ req, params, env }) => {
+  const url = new URL(req.url);
+  const threadId = params.id;
+  if (!threadId) {
+    return Response.json({ error: "Thread ID required" }, { status: 400 });
+  }
+  try {
+    const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+    const thread = await agentBuilder.getThread(threadId);
+    if (!thread) {
+      return Response.json(
+        { error: `Thread not found: ${threadId}` },
+        { status: 404 }
+      );
+    }
+    const limit = parseInt(url.searchParams.get("limit") || "100", 10);
+    const offset = parseInt(url.searchParams.get("offset") || "0", 10);
+    const order = url.searchParams.get("order") === "asc" ? "ASC" : "DESC";
+    const includeSilent = url.searchParams.get("includeSilent") === "true";
+    const maxDepth = parseInt(url.searchParams.get("depth") || "0", 10);
+    const durableId = env.AGENT_BUILDER_THREAD.idFromName(threadId);
+    const stub = env.AGENT_BUILDER_THREAD.get(durableId);
+    const result = await stub.getMessages(
+      limit,
+      offset,
+      order,
+      includeSilent,
+      maxDepth
+    );
+    return Response.json(result);
+  } catch (error) {
+    console.error(`Error fetching messages for thread ${threadId}:`, error);
+    return Response.json(
+      { error: error.message || "Failed to fetch messages" },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/threads/[id]/rpc.post.ts
+var rpc_post_default = defineController(async ({ req, params, env }) => {
+  const threadId = params.id;
+  if (!threadId) {
+    return Response.json({ error: "Thread ID required" }, { status: 400 });
+  }
+  const body = await req.json();
+  const { method, args = [] } = body;
+  if (!method) {
+    return Response.json({ error: "Method required" }, { status: 400 });
+  }
+  try {
+    const id = env.AGENT_BUILDER_THREAD.idFromName(threadId);
+    const thread = env.AGENT_BUILDER_THREAD.get(id);
+    const result = await thread[method](...args);
+    if (result instanceof Response) {
+      return result;
+    }
+    return Response.json(result);
+  } catch (error) {
+    console.error(`RPC call to ${method} failed:`, error);
+    return Response.json(
+      { error: error.message || "RPC call failed" },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/threads/[id]/stop.post.ts
+var stop_post_default = defineController(async ({ params, env }) => {
+  const threadId = params.id;
+  if (!threadId) {
+    return Response.json({ error: "Thread ID required" }, { status: 400 });
+  }
+  try {
+    const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+    const thread = await agentBuilder.getThread(threadId);
+    if (!thread) {
+      return Response.json(
+        { error: `Thread not found: ${threadId}` },
+        { status: 404 }
+      );
+    }
+    const durableId = env.AGENT_BUILDER_THREAD.idFromName(threadId);
+    const stub = env.AGENT_BUILDER_THREAD.get(durableId);
+    return await stub.stop();
+  } catch (error) {
+    console.error(`Error stopping thread ${threadId}:`, error);
+    return Response.json(
+      { error: error.message || "Failed to stop thread" },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/threads/[id]/stream.ts
+var stream_default = defineController(async ({ req, params, env }) => {
+  const threadId = params.id;
+  if (!threadId) {
+    return Response.json({ error: "Thread ID required" }, { status: 400 });
+  }
+  if (req.headers.get("upgrade")?.toLowerCase() !== "websocket") {
+    return Response.json(
+      { error: "This endpoint only supports WebSocket connections" },
+      { status: 400 }
+    );
+  }
+  try {
+    const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+    const thread = await agentBuilder.getThread(threadId);
+    if (!thread) {
+      return Response.json(
+        { error: `Thread not found: ${threadId}` },
+        { status: 404 }
+      );
+    }
+    const durableId = env.AGENT_BUILDER_THREAD.idFromName(threadId);
+    const stub = env.AGENT_BUILDER_THREAD.get(durableId);
+    return await stub.fetch(req);
+  } catch (error) {
+    console.error(`Error handling message stream for thread ${threadId}:`, error);
+    return Response.json(
+      { error: error.message || "Failed to establish message stream" },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/threads/[id]/logs/[logId].get.ts
+var logId_get_default = defineController(async ({ req, params, env }) => {
+  const threadId = params.id;
+  const logId = params.logId;
+  if (!threadId) {
+    return Response.json({ error: "Thread ID required" }, { status: 400 });
+  }
+  if (!logId) {
+    return Response.json({ error: "Log ID required" }, { status: 400 });
+  }
+  try {
+    const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+    const thread = await agentBuilder.getThread(threadId);
+    if (!thread) {
+      return Response.json(
+        { error: `Thread not found: ${threadId}` },
+        { status: 404 }
+      );
+    }
+    const durableId = env.AGENT_BUILDER_THREAD.idFromName(threadId);
+    const stub = env.AGENT_BUILDER_THREAD.get(durableId);
+    const logDetails = await stub.getLogDetails(logId);
+    return Response.json(logDetails);
+  } catch (error) {
+    console.error(`Error fetching log details for ${logId}:`, error);
+    if (error.message?.includes("not found")) {
+      return Response.json(
+        { error: error.message },
+        { status: 404 }
+      );
+    }
+    return Response.json(
+      { error: error.message || "Failed to fetch log details" },
+      { status: 500 }
+    );
+  }
+});
+
+// src/api/threads/[id]/messages/[messageId].delete.ts
+var messageId_delete_default = defineController(async ({ req, params, env }) => {
+  const threadId = params.id;
+  const messageId = params.messageId;
+  if (!threadId) {
+    return Response.json({ error: "Thread ID required" }, { status: 400 });
+  }
+  if (!messageId) {
+    return Response.json({ error: "Message ID required" }, { status: 400 });
+  }
+  try {
+    const agentBuilderId = env.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env.AGENT_BUILDER.get(agentBuilderId);
+    const thread = await agentBuilder.getThread(threadId);
+    if (!thread) {
+      return Response.json(
+        { error: `Thread not found: ${threadId}` },
+        { status: 404 }
+      );
+    }
+    const durableId = env.AGENT_BUILDER_THREAD.idFromName(threadId);
+    const stub = env.AGENT_BUILDER_THREAD.get(durableId);
+    const result = await stub.deleteMessage(messageId);
+    if (!result.success) {
+      return Response.json(
+        { error: result.error || "Failed to delete message" },
+        { status: 404 }
+      );
+    }
+    return Response.json({ success: true });
+  } catch (error) {
+    console.error(`Error deleting message ${messageId} from thread ${threadId}:`, error);
+    return Response.json(
+      { error: error.message || "Failed to delete message" },
+      { status: 500 }
+    );
+  }
+});
+
+// src/built-in-routes.ts
+var routeHandlers = {
+  "POST:/": index_post_default,
+  "GET:/agents": agents_get_default,
+  "GET:/api-keys": index_get_default,
+  "POST:/api-keys": index_post_default2,
+  "GET:/config": config_get_default,
+  "GET:/diagnostics": diagnostics_get_default,
+  "GET:/events": events_get_default,
+  "GET:/models": models_get_default,
+  "GET:/new-test": new_test_get_default,
+  "GET:/prompts": prompts_get_default,
+  "GET:/providers": providers_get_default,
+  "POST:/threads": index_post_default3,
+  "GET:/threads": threads_default,
+  "GET:/tools": tools_get_default,
+  "GET:/users": index_get_default2,
+  "POST:/users": index_post_default4,
+  "GET:/agents/:name": name_get_default,
+  "DELETE:/api-keys/:id": id_delete_default,
+  "GET:/prompts/:name": name_get_default2,
+  "DELETE:/threads/:id": id_delete_default2,
+  "PATCH:/threads/:id": id_patch_default,
+  "GET:/threads/:id": id_default,
+  "GET:/tools/:name": name_get_default3,
+  "DELETE:/users/:id": id_delete_default3,
+  "PUT:/users/:id": id_put_default,
+  "GET:/auth/config": config_get_default2,
+  "POST:/auth/login": login_post_default,
+  "POST:/auth/logout": logout_post_default,
+  "GET:/auth/me": me_get_default,
+  "POST:/models/available": available_post_default,
+  "POST:/models/endpoints": endpoints_post_default,
+  "GET:/threads/:id/cost": cost_get_default,
+  "GET:/threads/:id/logs": logs_get_default,
+  "POST:/threads/:id/message": message_post_default,
+  "GET:/threads/:id/messages": messages_get_default,
+  "POST:/threads/:id/rpc": rpc_post_default,
+  "POST:/threads/:id/stop": stop_post_default,
+  "GET:/threads/:id/stream": stream_default,
+  "GET:/threads/:id/logs/:logId": logId_get_default,
+  "DELETE:/threads/:id/messages/:messageId": messageId_delete_default
+};
+function registerBuiltInRoutes(router, runtimeData) {
+  for (const [key, handler] of Object.entries(routeHandlers)) {
+    const [method, ...routeParts] = key.split(":");
+    const route = routeParts.join(":");
+    const apiRoute = `/api${route}`;
+    const wrappedHandler = async (context) => {
+      const enhancedContext = {
+        ...context,
+        ...runtimeData?.config && { config: runtimeData.config },
+        ...runtimeData?.tools && { tools: runtimeData.tools },
+        ...runtimeData?.models && { models: runtimeData.models },
+        ...runtimeData?.modelNames && { modelNames: runtimeData.modelNames },
+        ...runtimeData?.prompts && { prompts: runtimeData.prompts },
+        ...runtimeData?.promptNames && { promptNames: runtimeData.promptNames },
+        ...runtimeData?.agents && { agents: runtimeData.agents },
+        ...runtimeData?.agentNames && { agentNames: runtimeData.agentNames }
+      };
+      return handler(enhancedContext);
+    };
+    addRoute(router, method, apiRoute, async () => wrappedHandler);
+  }
+}
+
+export { registerBuiltInRoutes };
+//# sourceMappingURL=built-in-routes.js.map
+//# sourceMappingURL=built-in-routes.js.map