@standardagents/builder 0.9.12 → 0.9.15

package/dist/index.js

@@ -349,20 +349,22 @@ var init_OpenAIProvider = __esm({
           const request = {
             model: modelId,
             messages: context.messages,
-            stream: true
-          };
-          if (context.tools && context.tools.length > 0) {
-            request.tools = context.tools;
-            if (context.parallel_tool_calls !== void 0) {
-              request.parallel_tool_calls = context.parallel_tool_calls;
-            }
-            if (context.tool_choice) {
-              request.tool_choice = context.tool_choice;
+            stream: true,
+            // Optional fields - add only if present
+            ...context.tools && context.tools.length > 0 && {
+              tools: context.tools,
+              ...context.parallel_tool_calls !== void 0 && {
+                parallel_tool_calls: context.parallel_tool_calls
+              },
+              ...context.tool_choice && {
+                tool_choice: context.tool_choice
+              }
+            },
+            // OpenAI o-series models use max_completion_tokens for reasoning
+            ...context.reasoning?.max_tokens && {
+              max_completion_tokens: context.reasoning.max_tokens
             }
-          }
-          if (context.reasoning?.max_tokens) {
-            request.max_completion_tokens = context.reasoning.max_tokens;
-          }
+          };
           await this.logActualRequest(request, logId, state);
           const stream = await client.chat.completions.create(request, {
             signal
@@ -450,53 +452,57 @@ var init_OpenRouterProvider = __esm({
             apiKey: this.config.api_key,
             baseURL: "https://openrouter.ai/api/v1"
           });
-          const request = {
-            model: modelId,
-            messages: context.messages,
-            stream: true,
-            // Enable usage accounting to get cost information
-            // https://openrouter.ai/docs/use-cases/usage-accounting
-            usage: {
-              include: true
-            }
-          };
+          let providerRouting;
           if (modelConfig?.included_providers) {
             try {
               const providers = JSON.parse(modelConfig.included_providers);
               if (Array.isArray(providers) && providers.length > 0) {
-                request.provider = {
-                  only: providers
-                };
+                providerRouting = { only: providers };
               }
             } catch (error) {
               console.error("[OpenRouter] Failed to parse included_providers:", error);
             }
           }
-          if (context.tools && context.tools.length > 0) {
-            request.tools = context.tools;
-            if (context.parallel_tool_calls !== void 0) {
-              request.parallel_tool_calls = context.parallel_tool_calls;
-            }
-            if (context.tool_choice) {
-              request.tool_choice = context.tool_choice;
-            }
-          }
+          let reasoningConfig;
           if (context.reasoning) {
-            request.reasoning = {};
+            reasoningConfig = {};
             if (context.reasoning.effort) {
-              request.reasoning.effort = context.reasoning.effort;
+              reasoningConfig.effort = context.reasoning.effort;
             }
             if (context.reasoning.max_tokens) {
-              request.reasoning.max_tokens = context.reasoning.max_tokens;
+              reasoningConfig.max_tokens = context.reasoning.max_tokens;
             }
             if (context.reasoning.exclude) {
-              request.reasoning.exclude = true;
+              reasoningConfig.exclude = true;
             }
           }
+          const request = {
+            model: modelId,
+            messages: context.messages,
+            stream: true,
+            // OpenRouter-specific: enable usage accounting
+            // https://openrouter.ai/docs/use-cases/usage-accounting
+            usage: { include: true },
+            // Optional OpenRouter routing
+            ...providerRouting && { provider: providerRouting },
+            // Optional reasoning config
+            ...reasoningConfig && { reasoning: reasoningConfig },
+            // Optional tools
+            ...context.tools && context.tools.length > 0 && {
+              tools: context.tools,
+              ...context.parallel_tool_calls !== void 0 && {
+                parallel_tool_calls: context.parallel_tool_calls
+              },
+              ...context.tool_choice && {
+                tool_choice: context.tool_choice
+              }
+            }
+          };
           await this.logActualRequest(request, logId, state);
-          const stream = await client.chat.completions.create(request, {
-            signal
-          });
+          const stream = await client.chat.completions.create(
+            request,
+            { signal }
+          );
           let content = "";
           let reasoning_content = "";
           let reasoning_details = [];
@@ -508,7 +514,8 @@ var init_OpenRouterProvider = __esm({
           let actualProvider;
           const allChunks = [];
           try {
-            for await (const chunk of stream) {
+            for await (const rawChunk of stream) {
+              const chunk = rawChunk;
               if (signal?.aborted || await state.thread.instance.shouldStop()) {
                 break;
               }
@@ -522,18 +529,15 @@ var init_OpenRouterProvider = __esm({
                 this.streamContentChunk(choice.delta.content, state);
               }
               if (choice.delta?.reasoning) {
-                const reasoning = choice.delta.reasoning;
-                reasoning_content += reasoning;
+                reasoning_content += choice.delta.reasoning;
               }
               if (choice.delta?.reasoning_details) {
                 const details = choice.delta.reasoning_details;
-                if (Array.isArray(details)) {
-                  for (const item of details) {
-                    if (item.type === "reasoning.text") {
-                      reasoning_content += item.text || "";
-                    } else {
-                      reasoning_details.push(item);
-                    }
+                for (const item of details) {
+                  if (item.type === "reasoning.text") {
+                    reasoning_content += item.text || "";
+                  } else {
+                    reasoning_details.push(item);
                   }
                 }
               }
@@ -574,22 +578,24 @@ var init_OpenRouterProvider = __esm({
               }
             }
           } catch (streamError) {
+            const err = streamError;
             console.error(`[openrouter] Stream error for model ${modelId}:`, {
               error: streamError,
-              code: streamError?.code,
-              status: streamError?.status,
-              message: streamError?.message,
-              type: streamError?.type
+              code: err.code,
+              status: err.status,
+              message: err.message,
+              type: err.type
             });
             throw new Error(
-              `Stream error: ${streamError?.message || "Unknown error"} (code: ${streamError?.code || "unknown"})`
+              `Stream error: ${err.message || "Unknown error"} (code: ${err.code || "unknown"})`
             );
           }
-          if (usage && cost !== void 0) {
-            usage.cost = cost;
+          const extendedUsage = usage;
+          if (extendedUsage && cost !== void 0) {
+            extendedUsage.cost = cost;
           }
-          if (usage && actualProvider !== void 0) {
-            usage.provider = actualProvider;
+          if (extendedUsage && actualProvider !== void 0) {
+            extendedUsage.provider = actualProvider;
           }
           const toolCalls = toolCallsMap.size > 0 ? this.finalizeToolCalls(toolCallsMap) : void 0;
           const aggregateResponse = {
@@ -609,7 +615,7 @@ var init_OpenRouterProvider = __esm({
                 finish_reason: finishReason || "stop"
               }
             ],
-            usage: usage || {
+            usage: extendedUsage || {
               prompt_tokens: 0,
               completion_tokens: 0,
               total_tokens: 0
@@ -617,8 +623,8 @@ var init_OpenRouterProvider = __esm({
             // Include all chunks for debugging/auditing
             _raw_chunks: allChunks.length
           };
-          let finalReasoningContent = reasoning_content || null;
-          let finalReasoningDetails = reasoning_details.length > 0 ? reasoning_details : void 0;
+          const finalReasoningContent = reasoning_content || null;
+          const finalReasoningDetails = reasoning_details.length > 0 ? reasoning_details : void 0;
           return {
             id: responseId,
             model: modelId,
@@ -643,12 +649,343 @@ var init_OpenRouterProvider = __esm({
   }
 });
 
+// src/agents/providers/TestScript.ts
+var TestScript;
+var init_TestScript = __esm({
+  "src/agents/providers/TestScript.ts"() {
+    TestScript = class _TestScript {
+      responses = [];
+      streamingConfig;
+      /**
+       * Create a new TestScript instance
+       */
+      static create() {
+        return new _TestScript();
+      }
+      /**
+       * Add a response to the sequence
+       */
+      addResponse(response) {
+        this.responses.push(response);
+        return this;
+      }
+      /**
+       * Add a simple text response (stops after response)
+       */
+      addTextResponse(content, options) {
+        return this.addResponse({
+          content,
+          finishReason: "stop",
+          ...options
+        });
+      }
+      /**
+       * Add a response with tool calls
+       */
+      addToolCallResponse(toolCalls, content, options) {
+        return this.addResponse({
+          content: content ?? null,
+          toolCalls: toolCalls.map((tc) => ({
+            id: tc.id || `call_${crypto.randomUUID().substring(0, 8)}`,
+            type: "function",
+            function: {
+              name: tc.name,
+              arguments: JSON.stringify(tc.arguments)
+            }
+          })),
+          finishReason: "tool_calls",
+          ...options
+        });
+      }
+      /**
+       * Add an error response (simulates provider error)
+       */
+      addErrorResponse(message, code, status, options) {
+        return this.addResponse({
+          error: { message, code, status },
+          ...options
+        });
+      }
+      /**
+       * Add a response with reasoning content (for o1-style models)
+       */
+      addReasoningResponse(content, reasoningContent, options) {
+        return this.addResponse({
+          content,
+          reasoningContent,
+          finishReason: "stop",
+          ...options
+        });
+      }
+      /**
+       * Enable streaming simulation for all responses
+       */
+      withStreamingSimulation(config) {
+        this.streamingConfig = config;
+        return this;
+      }
+      /**
+       * Get all scripted responses
+       */
+      getResponses() {
+        return [...this.responses];
+      }
+      /**
+       * Get streaming configuration
+       */
+      getStreamingConfig() {
+        return this.streamingConfig;
+      }
+      /**
+       * Get total number of responses
+       */
+      get length() {
+        return this.responses.length;
+      }
+      /**
+       * Check if script is empty
+       */
+      isEmpty() {
+        return this.responses.length === 0;
+      }
+      /**
+       * Create a clone of this script
+       */
+      clone() {
+        const cloned = new _TestScript();
+        cloned.responses = [...this.responses];
+        cloned.streamingConfig = this.streamingConfig ? { ...this.streamingConfig } : void 0;
+        return cloned;
+      }
+    };
+  }
+});
+
+// src/agents/providers/TestProvider.ts
+var TestProvider;
+var init_TestProvider = __esm({
+  "src/agents/providers/TestProvider.ts"() {
+    init_BaseProvider();
+    TestProvider = class extends BaseProvider {
+      script;
+      responseIndex = 0;
+      validateInputs;
+      debugLog;
+      requestLog = [];
+      constructor(config) {
+        super(config);
+        this.script = config.script;
+        this.validateInputs = config.validateInputs ?? false;
+        this.debugLog = config.debugLog ?? false;
+      }
+      get name() {
+        return "test";
+      }
+      /**
+       * Test provider supports any model ID
+       */
+      supportsModel(_modelId) {
+        return true;
+      }
+      /**
+       * Return the next scripted response
+       */
+      async chat(modelId, context, state, logId, signal, _modelConfig) {
+        if (this.debugLog) {
+          console.log(`[TestProvider] Request ${this.responseIndex + 1}:`, {
+            messageCount: context.messages.length,
+            lastMessage: context.messages.slice(-1)[0]
+          });
+        }
+        this.requestLog.push({ ...context });
+        if (signal?.aborted) {
+          throw new Error("Request aborted");
+        }
+        const responses = this.script.getResponses();
+        if (this.responseIndex >= responses.length) {
+          const lastMessage = context.messages.slice(-1)[0];
+          throw new Error(
+            `TestProvider: Script exhausted after ${this.responseIndex} responses. Expected ${responses.length} total requests. Received request with ${context.messages.length} messages. Last message role: "${lastMessage?.role}", content: "${lastMessage?.content?.substring(0, 100)}..."`
+          );
+        }
+        const scripted = responses[this.responseIndex];
+        this.responseIndex++;
+        if (this.validateInputs && scripted.expectInput) {
+          this.validateInput(context, scripted.expectInput);
+        }
+        if (scripted.delayMs) {
+          await this.sleep(scripted.delayMs);
+        }
+        if (scripted.error) {
+          const error = new Error(scripted.error.message);
+          error.code = scripted.error.code;
+          error.status = scripted.error.status;
+          await this.logError(state, error, `TestProvider: ${modelId}`);
+          throw error;
+        }
+        await this.logActualRequest(
+          { model: modelId, messages: context.messages, tools: context.tools },
+          logId,
+          state
+        );
+        const streamingConfig = this.script.getStreamingConfig();
+        if (streamingConfig && scripted.content) {
+          await this.simulateStreaming(scripted.content, streamingConfig, state);
+        } else if (scripted.content) {
+          this.streamContent(scripted.content, state);
+          this.streamContentChunk(scripted.content, state);
+        }
+        const responseId = `test_${crypto.randomUUID().substring(0, 12)}`;
+        const promptTokens = scripted.usage?.promptTokens ?? this.estimateTokens(context.messages);
+        const completionTokens = scripted.usage?.completionTokens ?? this.estimateTokens([{ content: scripted.content }]);
+        const reasoningTokens = scripted.usage?.reasoningTokens ?? 0;
+        return {
+          id: responseId,
+          model: modelId,
+          content: scripted.content ?? null,
+          reasoning_content: scripted.reasoningContent ?? null,
+          reasoning_details: scripted.reasoningDetails,
+          tool_calls: scripted.toolCalls,
+          finish_reason: scripted.finishReason ?? "stop",
+          usage: {
+            prompt_tokens: promptTokens,
+            completion_tokens: completionTokens,
+            total_tokens: promptTokens + completionTokens,
+            completion_tokens_details: reasoningTokens ? { reasoning_tokens: reasoningTokens } : void 0
+          }
+        };
+      }
+      /**
+       * Simulate streaming by sending content in chunks
+       */
+      async simulateStreaming(content, config, state) {
+        for (let i = 0; i < content.length; i += config.chunkSize) {
+          const chunk = content.substring(i, i + config.chunkSize);
+          this.streamContent(chunk, state);
+          this.streamContentChunk(chunk, state);
+          if (config.chunkDelayMs > 0) {
+            await this.sleep(config.chunkDelayMs);
+          }
+        }
+      }
+      /**
+       * Validate request matches expectations
+       */
+      validateInput(context, expectations) {
+        if (expectations.messageCount !== void 0) {
+          if (context.messages.length !== expectations.messageCount) {
+            throw new Error(
+              `TestProvider: Expected ${expectations.messageCount} messages, got ${context.messages.length}`
+            );
+          }
+        }
+        if (expectations.containsMessage) {
+          const pattern = expectations.containsMessage;
+          const found = context.messages.some((m) => {
+            if (!m.content) return false;
+            return typeof pattern === "string" ? m.content.includes(pattern) : pattern.test(m.content);
+          });
+          if (!found) {
+            throw new Error(
+              `TestProvider: Expected message containing "${pattern}" not found`
+            );
+          }
+        }
+        if (expectations.containsToolResult) {
+          const { toolName, resultContains } = expectations.containsToolResult;
+          const found = context.messages.some((m) => {
+            if (m.role !== "tool") return false;
+            if (!m.content) return false;
+            return !resultContains || m.content.includes(resultContains);
+          });
+          if (!found) {
+            throw new Error(
+              `TestProvider: Expected tool result for "${toolName}" not found`
+            );
+          }
+        }
+        if (expectations.systemPromptContains) {
+          const pattern = expectations.systemPromptContains;
+          const systemMessage = context.messages.find((m) => m.role === "system");
+          if (!systemMessage?.content) {
+            throw new Error(`TestProvider: No system message found`);
+          }
+          const matches = typeof pattern === "string" ? systemMessage.content.includes(pattern) : pattern.test(systemMessage.content);
+          if (!matches) {
+            throw new Error(
+              `TestProvider: System prompt does not contain "${pattern}"`
+            );
+          }
+        }
+      }
+      /**
+       * Simple token estimation (for mock usage stats)
+       */
+      estimateTokens(messages) {
+        return messages.reduce((sum, m) => {
+          const content = m.content || "";
+          return sum + Math.ceil(content.length / 4);
+        }, 0);
+      }
+      sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+      }
+      // ============ Test Utility Methods ============
+      /**
+       * Get logged requests (for test assertions)
+       */
+      getRequestLog() {
+        return [...this.requestLog];
+      }
+      /**
+       * Get the last request made
+       */
+      getLastRequest() {
+        return this.requestLog[this.requestLog.length - 1];
+      }
+      /**
+       * Reset provider state for reuse across tests
+       */
+      reset() {
+        this.responseIndex = 0;
+        this.requestLog = [];
+      }
+      /**
+       * Replace the script with a new one and reset
+       */
+      setScript(script) {
+        this.script = script;
+        this.reset();
+      }
+      /**
+       * Check if all scripted responses were consumed
+       */
+      isScriptComplete() {
+        return this.responseIndex === this.script.length;
+      }
+      /**
+       * Get remaining unconsumed response count
+       */
+      remainingResponses() {
+        return this.script.length - this.responseIndex;
+      }
+      /**
+       * Get current response index
+       */
+      getCurrentIndex() {
+        return this.responseIndex;
+      }
+    };
+  }
+});
+
 // src/agents/providers/ProviderRegistry.ts
 var ProviderRegistryImpl, ProviderRegistry;
 var init_ProviderRegistry = __esm({
   "src/agents/providers/ProviderRegistry.ts"() {
     init_OpenAIProvider();
     init_OpenRouterProvider();
+    init_TestProvider();
     ProviderRegistryImpl = class {
       factories = /* @__PURE__ */ new Map();
       providerCache = /* @__PURE__ */ new Map();
@@ -658,6 +995,7 @@ var init_ProviderRegistry = __esm({
       registerBuiltInProviders() {
         this.register("openai", (config) => new OpenAIProvider(config));
         this.register("openrouter", (config) => new OpenRouterProvider(config));
+        this.register("test", (config) => new TestProvider(config));
       }
       register(sdk, factory) {
         this.factories.set(sdk.toLowerCase(), factory);
@@ -733,6 +1071,14 @@ var init_ProviderRegistry = __esm({
        * Provider API keys come from environment variables.
        */
       async getProviderConfig(providerName, env) {
+        if (providerName.toLowerCase() === "test") {
+          return {
+            name: "test",
+            sdk: "test",
+            api_key: "test"
+            // Dummy key for test provider
+          };
+        }
         const apiKeyEnvVarMap = {
           openai: "OPENAI_API_KEY",
           openrouter: "OPENROUTER_API_KEY",
@@ -768,7 +1114,9 @@ __export(providers_exports, {
   BaseProvider: () => BaseProvider,
   OpenAIProvider: () => OpenAIProvider,
   OpenRouterProvider: () => OpenRouterProvider,
-  ProviderRegistry: () => ProviderRegistry
+  ProviderRegistry: () => ProviderRegistry,
+  TestProvider: () => TestProvider,
+  TestScript: () => TestScript
 });
 var init_providers = __esm({
   "src/agents/providers/index.ts"() {
@@ -776,6 +1124,8 @@ var init_providers = __esm({
     init_BaseProvider();
     init_OpenAIProvider();
     init_OpenRouterProvider();
+    init_TestScript();
+    init_TestProvider();
     init_ProviderRegistry();
   }
 });
@@ -933,7 +1283,7 @@ var init_LLMRequest = __esm({
             message_id: state.rootMessageId || crypto.randomUUID(),
             provider: this.getProviderFromModel(modelId),
             model: modelId,
-            model_name: modelName,
+            model_name: modelName ?? void 0,
             endpoint: "chat.completions",
             request_body: JSON.stringify({
               model: modelName || modelId,
@@ -944,11 +1294,11 @@ var init_LLMRequest = __esm({
             }),
             tools_available: context.tools ? context.tools.length : 0,
             message_history_length: context.messages.length,
-            prompt_name: context.promptName || null,
-            parent_log_id: context.parentLogId || null,
-            retry_of_log_id: retryOfLogId || null,
-            tools_schema: context.tools ? JSON.stringify(context.tools) : null,
-            system_prompt: context.systemPrompt || null,
+            prompt_name: context.promptName ?? void 0,
+            parent_log_id: context.parentLogId ?? void 0,
+            retry_of_log_id: retryOfLogId ?? void 0,
+            tools_schema: context.tools ? JSON.stringify(context.tools) : void 0,
+            system_prompt: context.systemPrompt ?? void 0,
             is_complete: false,
             // Incomplete until response received
             created_at: Date.now() * TIMESTAMP_MULTIPLIER
@@ -1057,13 +1407,13 @@ var init_LLMRequest = __esm({
             total_tokens: response.usage.total_tokens,
             latency_ms: Date.now() - startTime,
             finish_reason: response.finish_reason,
-            tools_called: toolsCalled,
-            cost_total,
-            provider: actualProvider,
+            tools_called: toolsCalled ?? void 0,
+            cost_total: cost_total ?? void 0,
+            provider: actualProvider ?? void 0,
             // Update provider with actual value if available
             is_complete: true,
             // Now complete
-            reasoning_content: response.reasoning_content || null
+            reasoning_content: response.reasoning_content ?? void 0
             // Store reasoning separately
           };
           await state.stream.waitFor(async () => {
@@ -1910,7 +2260,7 @@ var init_ToolExecutor = __esm({
           if (state.parentMessageId !== void 0 && processedResult.status === "error") {
             const parentToolConfig = state.context.__parentToolConfig;
             let includeErrors = true;
-            if (typeof parentToolConfig === "object" && parentToolConfig !== null) {
+            if (parentToolConfig !== void 0 && parentToolConfig !== null) {
               includeErrors = parentToolConfig.includeErrors ?? true;
             }
             if (includeErrors && !content.startsWith("Error: ")) {
@@ -2611,21 +2961,22 @@ var init_FlowEngine = __esm({
             id: newAgentName,
             title: newAgentDef.title || newAgentName,
             type: newAgentDef.type,
-            max_session_turns: newAgentDef.maxSessionTurns,
-            side_a_label: newAgentDef.sideA?.label,
-            side_a_agent_prompt: newAgentDef.sideA?.prompt,
+            created_at: Date.now(),
+            max_session_turns: newAgentDef.maxSessionTurns ?? null,
+            side_a_label: newAgentDef.sideA?.label ?? null,
+            side_a_agent_prompt: newAgentDef.sideA?.prompt ?? null,
             side_a_stop_on_response: newAgentDef.sideA?.stopOnResponse ?? false,
-            side_a_stop_tool: newAgentDef.sideA?.stopTool,
-            side_a_stop_tool_response_property: newAgentDef.sideA?.stopToolResponseProperty,
-            side_a_max_turns: newAgentDef.sideA?.maxTurns,
-            side_a_end_conversation_tool: newAgentDef.sideA?.endConversationTool,
-            side_b_label: newAgentDef.sideB?.label,
-            side_b_agent_prompt: newAgentDef.sideB?.prompt,
+            side_a_stop_tool: newAgentDef.sideA?.stopTool ?? null,
+            side_a_stop_tool_response_property: newAgentDef.sideA?.stopToolResponseProperty ?? null,
+            side_a_max_turns: newAgentDef.sideA?.maxTurns ?? null,
+            side_a_end_conversation_tool: newAgentDef.sideA?.endConversationTool ?? null,
+            side_b_label: newAgentDef.sideB?.label ?? null,
+            side_b_agent_prompt: newAgentDef.sideB?.prompt ?? null,
             side_b_stop_on_response: newAgentDef.sideB?.stopOnResponse ?? false,
-            side_b_stop_tool: newAgentDef.sideB?.stopTool,
-            side_b_stop_tool_response_property: newAgentDef.sideB?.stopToolResponseProperty,
-            side_b_max_turns: newAgentDef.sideB?.maxTurns,
-            side_b_end_conversation_tool: newAgentDef.sideB?.endConversationTool
+            side_b_stop_tool: newAgentDef.sideB?.stopTool ?? null,
+            side_b_stop_tool_response_property: newAgentDef.sideB?.stopToolResponseProperty ?? null,
+            side_b_max_turns: newAgentDef.sideB?.maxTurns ?? null,
+            side_b_end_conversation_tool: newAgentDef.sideB?.endConversationTool ?? null
           };
           const { sideAPrompt, sideBPrompt } = await this.loadAgentAndPrompts(
             agentConfig,
@@ -5480,7 +5831,7 @@ function scanApiDirectory(dir, baseRoute = "") {
         routes.push(...scanApiDirectory(fullPath, subRoute));
       } else if (entry.isFile() && entry.name.endsWith(".ts")) {
         const fileName = entry.name.replace(/\.ts$/, "");
-        let method = "GET";
+        let method = "";
         let routePath = baseRoute;
         if (fileName.includes(".")) {
           const parts = fileName.split(".");
@@ -5848,12 +6199,12 @@ function agentbuilder(options = {}) {
   }
   return {
     name: "vite-plugin-agent",
+    enforce: "pre",
     config() {
       const depsToExclude = [
         "@standardagents/builder",
         "@standardagents/builder/runtime",
-        "@standardagents/builder/built-in-routes",
-        "@standardagents/builder/mcp"
+        "@standardagents/builder/built-in-routes"
       ];
       return {
         optimizeDeps: {
@@ -5862,8 +6213,6 @@ function agentbuilder(options = {}) {
           exclude: depsToExclude
         },
         ssr: {
-          // Only MCP should be external (not used in worker)
-          external: ["@standardagents/builder/mcp"],
           // noExternal ensures Vite transforms these instead of leaving as external
           // The Cloudflare plugin handles the actual bundling and knows about cloudflare:workers
           noExternal: [
@@ -5871,11 +6220,6 @@ function agentbuilder(options = {}) {
             "@standardagents/builder/runtime",
             "@standardagents/builder/built-in-routes"
           ]
-        },
-        build: {
-          rollupOptions: {
-            external: ["@standardagents/builder/mcp"]
-          }
         }
       };
     },
@@ -5884,8 +6228,7 @@ function agentbuilder(options = {}) {
       const depsToExclude = [
         "@standardagents/builder",
         "@standardagents/builder/runtime",
-        "@standardagents/builder/built-in-routes",
-        "@standardagents/builder/mcp"
+        "@standardagents/builder/built-in-routes"
       ];
       config.optimizeDeps = config.optimizeDeps || {};
       config.optimizeDeps.exclude = [
@@ -6630,6 +6973,101 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
             return;
           }
         }
+        if (pathWithoutMount === "/api/prompts" && method === "GET") {
+          try {
+            const fs4 = await import('fs');
+            const files = fs4.existsSync(promptsDir) ? fs4.readdirSync(promptsDir).filter((f) => f.endsWith(".ts")) : [];
+            const modelFiles = fs4.existsSync(modelsDir) ? fs4.readdirSync(modelsDir).filter((f) => f.endsWith(".ts")) : [];
+            const modelMap = {};
+            for (const file of modelFiles) {
+              try {
+                const filePath = path3.join(modelsDir, file);
+                const content = fs4.readFileSync(filePath, "utf-8");
+                const name = content.match(/name:\s*['"]([^'"]+)['"]/)?.[1];
+                const provider = content.match(/provider:\s*['"]([^'"]+)['"]/)?.[1];
+                if (name) {
+                  modelMap[name] = { name, provider: provider || "unknown" };
+                }
+              } catch (error) {
+              }
+            }
+            const promptList = files.map((file) => {
+              try {
+                const filePath = path3.join(promptsDir, file);
+                const content = fs4.readFileSync(filePath, "utf-8");
+                const getName = (c) => c.match(/name:\s*['"]([^'"]+)['"]/)?.[1];
+                const getToolDescription = (c) => c.match(/toolDescription:\s*['"]([^'"]+)['"]/)?.[1];
+                const getModel = (c) => c.match(/model:\s*['"]([^'"]+)['"]/)?.[1];
+                const getIncludeChat = (c) => c.match(/includeChat:\s*(true|false)/)?.[1] === "true";
+                const getIncludePastTools = (c) => c.match(/includePastTools:\s*(true|false)/)?.[1] === "true";
+                const getParallelToolCalls = (c) => c.match(/parallelToolCalls:\s*(true|false)/)?.[1] === "true";
+                const getToolChoice = (c) => c.match(/toolChoice:\s*['"]([^'"]+)['"]/)?.[1];
+                const getBeforeTool = (c) => c.match(/beforeTool:\s*['"]([^'"]+)['"]/)?.[1];
+                const getAfterTool = (c) => c.match(/afterTool:\s*['"]([^'"]+)['"]/)?.[1];
+                const getTools = (c) => {
+                  const match = c.match(/tools:\s*\[([^\]]*)\]/);
+                  if (!match) return [];
+                  const items = match[1].match(/['"]([^'"]+)['"]/g);
+                  return items ? items.map((s) => s.replace(/['"]/g, "")) : [];
+                };
+                const getHandoffAgents = (c) => {
+                  const match = c.match(/handoffAgents:\s*\[([^\]]*)\]/);
+                  if (!match) return [];
+                  const items = match[1].match(/['"]([^'"]+)['"]/g);
+                  return items ? items.map((s) => s.replace(/['"]/g, "")) : [];
+                };
+                const getPrompt = (c) => {
+                  const backtickMatch = c.match(/prompt:\s*`([\s\S]*?)`/);
+                  if (backtickMatch) return backtickMatch[1];
+                  const quotedMatch = c.match(/prompt:\s*['"]([^'"]*)['"]/);
+                  if (quotedMatch) return quotedMatch[1];
+                  const arrayMatch = c.match(/prompt:\s*(\[[\s\S]*?\])/);
+                  if (arrayMatch) return arrayMatch[1];
+                  return "";
+                };
+                const name = getName(content);
+                if (!name) return null;
+                const modelId = getModel(content);
+                const modelDef = modelId ? modelMap[modelId] : null;
+                return {
+                  id: name,
+                  name,
+                  tool_description: getToolDescription(content) || "",
+                  prompt: getPrompt(content),
+                  required_schema: null,
+                  // Complex to parse, skip for now
+                  model_id: modelId || "",
+                  model_name: modelDef?.name || modelId || "",
+                  model_provider: modelDef?.provider || "unknown",
+                  include_chat: getIncludeChat(content),
+                  include_past_tools: getIncludePastTools(content),
+                  parallel_tool_calls: getParallelToolCalls(content),
+                  tool_choice: getToolChoice(content) || "auto",
+                  before_tool: getBeforeTool(content) || null,
+                  after_tool: getAfterTool(content) || null,
+                  tools: getTools(content),
+                  prompts: getHandoffAgents(content),
+                  reasoning: null,
+                  // Complex to parse
+                  created_at: Math.floor(Date.now() / 1e3)
+                };
+              } catch (error) {
+                console.error(`Error loading prompt ${file}:`, error);
+                return null;
+              }
+            });
+            const validPrompts = promptList.filter(Boolean);
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ prompts: validPrompts }));
+            return;
+          } catch (error) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: error.message || "Failed to list prompts" }));
+            return;
+          }
+        }
         if (pathWithoutMount === "/api/prompts" && method === "POST") {
           try {
             const rawBody = await parseRequestBody(req);
@@ -6755,6 +7193,54 @@ export class DurableAgentBuilder extends _BaseDurableAgentBuilder {
             return;
           }
         }
+        if (pathWithoutMount === "/api/agents" && method === "GET") {
+          try {
+            const fs4 = await import('fs');
+            const files = fs4.existsSync(agentsDir) ? fs4.readdirSync(agentsDir).filter((f) => f.endsWith(".ts")) : [];
+            const agentList = files.map((file) => {
+              try {
+                const filePath = path3.join(agentsDir, file);
+                const content = fs4.readFileSync(filePath, "utf-8");
+                const getName = (c) => c.match(/name:\s*['"]([^'"]+)['"]/)?.[1];
+                const getTitle = (c) => c.match(/title:\s*['"]([^'"]+)['"]/)?.[1];
+                const getType = (c) => c.match(/type:\s*['"]([^'"]+)['"]/)?.[1];
+                const getDefaultPrompt = (c) => c.match(/defaultPrompt:\s*['"]([^'"]+)['"]/)?.[1];
+                const getDefaultModel = (c) => c.match(/defaultModel:\s*['"]([^'"]+)['"]/)?.[1];
+                const getTools = (c) => {
+                  const match = c.match(/tools:\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;
+                return {
+                  id: name,
+                  name,
+                  title: getTitle(content) || name,
+                  type: getType(content) || "ai_human",
+                  default_prompt: getDefaultPrompt(content) || "",
+                  default_model: getDefaultModel(content) || "",
+                  tools: getTools(content),
+                  created_at: Math.floor(Date.now() / 1e3)
+                };
+              } catch (error) {
+                console.error(`Error loading agent ${file}:`, error);
+                return null;
+              }
+            });
+            const validAgents = agentList.filter(Boolean);
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ agents: validAgents }));
+            return;
+          } catch (error) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: error.message || "Failed to list agents" }));
+            return;
+          }
+        }
         if (pathWithoutMount === "/api/agents" && method === "POST") {
           try {
             const rawBody = await parseRequestBody(req);
@@ -10203,7 +10689,7 @@ function defineModel(options) {
   if (!options.model) {
     throw new Error("Model ID is required");
   }
-  const validProviders = ["openai", "openrouter", "anthropic", "google"];
+  const validProviders = ["openai", "openrouter", "anthropic", "google", "test"];
   if (!validProviders.includes(options.provider)) {
     throw new Error(
       `Invalid provider '${options.provider}'. Must be one of: ${validProviders.join(", ")}`