@just-every/ensemble 0.1.34 → 0.2.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Context
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -5,6 +5,16 @@
 
 A unified interface for interacting with multiple LLM providers (OpenAI, Anthropic, Google, etc.) with streaming support, tool calling, and embeddings.
 
+## Features
+
+- 🔄 **Unified Streaming Interface** - Consistent event-based streaming across all providers
+- 🛠️ **Advanced Tool Calling** - Parallel/sequential execution, timeouts, and background tracking
+- 📊 **Cost & Quota Tracking** - Built-in usage monitoring and cost calculation
+- 🎯 **Smart Result Processing** - Automatic summarization and truncation for long outputs
+- 🔌 **Multi-Provider Support** - OpenAI, Anthropic, Google, DeepSeek, xAI, OpenRouter
+- 🖼️ **Multi-Modal** - Support for text, images, and embeddings
+- 📝 **Message History** - Automatic conversation management with compaction
+
 ## Installation
 
 ```bash
@@ -14,215 +24,77 @@ npm install @just-every/ensemble
 ## Quick Start
 
 ```typescript
-import { request, embed, image } from '@just-every/ensemble';
-
-// Simple streaming request
-for await (const event of request('gpt-4o-mini', [
-  { type: 'message', role: 'user', content: 'Hello!' }
-])) {
-  if (event.type === 'text_delta') {
-    process.stdout.write(event.delta);
-  }
-}
-```
-
-## Core Functions
+import { ensembleRequest } from '@just-every/ensemble';
 
-### `request(model, messages, options?)`
+const messages = [
+    { type: 'message', role: 'user', content: 'Hello, how are you?' }
+];
 
-Make streaming LLM requests with automatic tool execution.
+const agent = {
+    model: 'o3',
+    agent_id: 'assistant'
+};
 
-```typescript
-// Basic usage
-const stream = request('claude-3.5-sonnet', [
-  { type: 'message', role: 'user', content: 'Explain quantum computing' }
-]);
-
-for await (const event of stream) {
-  if (event.type === 'text_delta') {
-    process.stdout.write(event.delta);
-  } else if (event.type === 'cost_update') {
-    console.log(`Cost: $${event.usage.total_cost}`);
-  }
-}
-
-// With tools
-const tools = [{
-  function: async ({ city }) => `Weather in ${city}: Sunny, 72°F`,
-  definition: {
-    type: 'function',
-    function: {
-      name: 'get_weather',
-      description: 'Get weather for a city',
-      parameters: {
-        type: 'object',
-        properties: {
-          city: { type: 'string' }
-        },
-        required: ['city']
-      }
+for await (const event of ensembleRequest(messages, agent)) {
+    if (event.type === 'message_delta') {
+        process.stdout.write(event.content);
     }
-  }
-}];
-
-const stream = request('gpt-4o', [
-  { type: 'message', role: 'user', content: 'What\'s the weather in Paris?' }
-], { tools });
-```
-
-### `embed(text, options?)`
-
-Generate embeddings for semantic search and RAG applications.
-
-```typescript
-// Simple embedding
-const embedding = await embed('Hello, world!');
-console.log(`Dimension: ${embedding.length}`); // e.g., 1536
-
-// With specific model
-const embedding = await embed('Search query', { 
-  model: 'text-embedding-3-large' 
-});
-
-// Calculate similarity
-function cosineSimilarity(a: number[], b: number[]): number {
-  const dotProduct = a.reduce((sum, val, i) => sum + val * b[i], 0);
-  const normA = Math.sqrt(a.reduce((sum, val) => sum + val * val, 0));
-  const normB = Math.sqrt(b.reduce((sum, val) => sum + val * val, 0));
-  return dotProduct / (normA * normB);
 }
-
-const similarity = cosineSimilarity(embedding1, embedding2);
 ```
 
-### `image(prompt, options?)`
-
-Generate images from text prompts using DALL-E or Imagen models.
-
-```typescript
-// Simple image generation
-const result = await image('A beautiful sunset over mountains');
-console.log(`Generated ${result.images.length} image(s)`);
-
-// With specific options
-const result = await image('A robot holding a skateboard', {
-  model: 'dall-e-3',
-  size: 'landscape',
-  quality: 'hd',
-  n: 2
-});
-
-// Image editing (DALL-E 2 only)
-const result = await image('Add a red hat to the person', {
-  model: 'dall-e-2',
-  source_images: 'data:image/png;base64,...' // or URL
-});
-
-// Inpainting with mask
-const result = await image('Replace with a golden retriever', {
-  model: 'dall-e-2',
-  source_images: originalImage,
-  mask: maskImage // transparent areas will be edited
-});
-
-// Using Google Imagen
-const result = await image('A serene lake at dawn', {
-  model: 'imagen-3.0-generate-002',
-  size: 'portrait'
-});
-```
-
-### `chainRequests(messages, requests)`
-
-Chain multiple LLM calls, using the output of one as input to the next.
-
-```typescript
-import { chainRequests } from '@just-every/ensemble';
-
-const result = await chainRequests(
-  [{ type: 'message', role: 'user', content: 'Analyze this code for bugs: ...' }],
-  [
-    {
-      model: 'gpt-4o',
-      systemPrompt: 'You are a code reviewer. Find bugs and security issues.'
-    },
-    {
-      model: 'claude-3.5-sonnet',
-      systemPrompt: 'Prioritize the issues found and suggest fixes.'
-    },
-    {
-      model: 'gpt-4o-mini',
-      systemPrompt: 'Summarize the analysis in 3 bullet points.'
-    }
-  ]
-);
-
-console.log(result.fullResponse);
-```
+## Documentation
 
-## Supported Providers
+- [Tool Execution Guide](docs/tool-execution.md) - Advanced tool calling features
+- [Examples](examples/) - Complete working examples
+- [API Reference](docs/api.md) - Full API documentation
 
-- **OpenAI**: GPT-4o, GPT-4o-mini, o1-preview, o1-mini
-- **Anthropic**: Claude 3.5 Sonnet, Claude 3.5 Haiku
-- **Google**: Gemini 2.0 Flash, Gemini 1.5 Pro
-- **DeepSeek**: DeepSeek Chat, DeepSeek Coder
-- **xAI**: Grok 2, Grok Beta
-- **OpenRouter**: Access to 100+ models
+## Core Concepts
 
-## OpenAI SDK Compatibility
+### Tools
 
-Drop-in replacement for the OpenAI SDK:
+Define tools that LLMs can call:
 
 ```typescript
-// Instead of: import OpenAI from 'openai';
-import OpenAIEnsemble from '@just-every/ensemble/openai-compat';
-
-const completion = await OpenAIEnsemble.chat.completions.create({
-  model: 'claude-3.5-sonnet',  // Use any supported model!
-  messages: [{ role: 'user', content: 'Hello!' }],
-  stream: true
-});
+const agent = {
+    model: 'o3',
+    tools: [{
+        definition: {
+            type: 'function',
+            function: {
+                name: 'get_weather',
+                description: 'Get weather for a location',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        location: { type: 'string' }
+                    },
+                    required: ['location']
+                }
+            }
+        },
+        function: async (location: string) => {
+            return `Weather in ${location}: Sunny, 72°F`;
+        }
+    }]
+};
 ```
 
-## Environment Variables
+### Streaming Events
 
-```bash
-ANTHROPIC_API_KEY=your_key_here
-OPENAI_API_KEY=your_key_here
-GOOGLE_API_KEY=your_key_here
-DEEPSEEK_API_KEY=your_key_here
-XAI_API_KEY=your_key_here
-OPENROUTER_API_KEY=your_key_here
-```
+All providers emit standardized events:
 
-## Key Features
+- `message_start` / `message_delta` / `message_complete` - Message streaming
+- `tool_start` / `tool_delta` / `tool_done` - Tool execution
+- `cost_update` - Token usage and cost tracking
+- `error` - Error handling
 
-- **Unified streaming API** across all LLM providers
-- **Automatic tool execution** with type-safe function calling
-- **Smart model rotation** based on availability and performance
-- **Built-in embeddings** with caching
-- **Image generation** with DALL-E and Imagen support
-- **OpenAI SDK compatibility** - drop-in replacement
-- **Cost tracking** and quota management
-
-## Documentation
+### Advanced Features
 
-- [Model Selection & Management](./docs/models.md)
-- [Advanced Usage](./docs/advanced-usage.md) - Tools, structured output, images
-- [Image Generation](./docs/image-generation.md) - DALL-E and Imagen support
-- [Error Handling](./docs/error-handling.md)
-- [OpenAI Compatibility](./docs/openai-compatibility.md)
-- [Utility Functions](./docs/utilities.md)
-- [Test Utilities](./docs/test-utilities.md) - Testing helpers and mocks
-
-## Examples
-
-See the [examples](./examples) directory for:
-- [Basic usage](./examples/basic-request.ts)
-- [Tool calling](./examples/tool-calling.ts)
-- [Embeddings & semantic search](./examples/embeddings.ts)
-- [Model rotation](./examples/model-rotation.ts)
-- [Stream conversion](./examples/stream-conversion.ts)
+- **Parallel Tool Execution** - Tools run concurrently by default
+- **Sequential Mode** - Enforce one-at-a-time execution
+- **Timeout Handling** - Automatic timeout with background tracking
+- **Result Summarization** - Long outputs are intelligently summarized
+- **Abort Signals** - Graceful cancellation support
 
 ## License
 

package/dist/config/tool_execution.d.ts

@@ -0,0 +1,11 @@
+export declare const FUNCTION_TIMEOUT_MS = 30000;
+export declare const EXCLUDED_FROM_TIMEOUT_FUNCTIONS: Set<string>;
+export declare const MAX_RESULT_LENGTH = 1000;
+export declare const SKIP_SUMMARIZATION_TOOLS: Set<string>;
+export interface ToolConfig {
+    skipSummarization?: boolean;
+    maxLength?: number;
+    truncationMessage?: string;
+}
+export declare const TOOL_CONFIGS: Record<string, ToolConfig>;
+//# sourceMappingURL=tool_execution.d.ts.map

package/dist/config/tool_execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool_execution.d.ts","sourceRoot":"","sources":["../../config/tool_execution.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,mBAAmB,QAAQ,CAAC;AAKzC,eAAO,MAAM,+BAA+B,aAM1C,CAAC;AAKH,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAKtC,eAAO,MAAM,wBAAwB,aAKnC,CAAC;AAKH,MAAM,WAAW,UAAU;IACvB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAenD,CAAC"}

package/dist/config/tool_execution.js

@@ -0,0 +1,31 @@
+export const FUNCTION_TIMEOUT_MS = 30000;
+export const EXCLUDED_FROM_TIMEOUT_FUNCTIONS = new Set([
+    'wait_for_running_tool',
+    'run_shell_command_with_output',
+    'execute_code',
+    'debug_code',
+    'test_code',
+]);
+export const MAX_RESULT_LENGTH = 1000;
+export const SKIP_SUMMARIZATION_TOOLS = new Set([
+    'read_source',
+    'get_page_content',
+    'read_file',
+    'list_files',
+]);
+export const TOOL_CONFIGS = {
+    read_source: {
+        skipSummarization: true,
+        maxLength: 1000,
+        truncationMessage: '\n\n[Full output truncated: Use write_source(summary_id, file_path) to write full output to a file.]',
+    },
+    get_page_content: {
+        skipSummarization: true,
+        maxLength: 1000,
+    },
+    read_file: {
+        skipSummarization: true,
+        maxLength: 1000,
+    },
+};
+//# sourceMappingURL=tool_execution.js.map

package/dist/config/tool_execution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool_execution.js","sourceRoot":"","sources":["../../config/tool_execution.ts"],"names":[],"mappings":"AAOA,MAAM,CAAC,MAAM,mBAAmB,GAAG,KAAK,CAAC;AAKzC,MAAM,CAAC,MAAM,+BAA+B,GAAG,IAAI,GAAG,CAAC;IACnD,uBAAuB;IACvB,+BAA+B;IAC/B,cAAc;IACd,YAAY;IACZ,WAAW;CACd,CAAC,CAAC;AAKH,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,CAAC;AAKtC,MAAM,CAAC,MAAM,wBAAwB,GAAG,IAAI,GAAG,CAAC;IAC5C,aAAa;IACb,kBAAkB;IAClB,WAAW;IACX,YAAY;CACf,CAAC,CAAC;AAWH,MAAM,CAAC,MAAM,YAAY,GAA+B;IACpD,WAAW,EAAE;QACT,iBAAiB,EAAE,IAAI;QACvB,SAAS,EAAE,IAAI;QACf,iBAAiB,EACb,sGAAsG;KAC7G;IACD,gBAAgB,EAAE;QACd,iBAAiB,EAAE,IAAI;QACvB,SAAS,EAAE,IAAI;KAClB;IACD,SAAS,EAAE;QACP,iBAAiB,EAAE,IAAI;QACvB,SAAS,EAAE,IAAI;KAClB;CACJ,CAAC"}

package/dist/core/ensemble_embed.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition, EmbedOpts } from '../types/types.js';
+export declare function ensembleEmbed(text: string, agent: AgentDefinition, options?: EmbedOpts): Promise<number[]>;
+//# sourceMappingURL=ensemble_embed.d.ts.map

package/dist/core/ensemble_embed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensemble_embed.d.ts","sourceRoot":"","sources":["../../core/ensemble_embed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAuCpE,wBAAsB,aAAa,CAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,eAAe,EACtB,OAAO,CAAC,EAAE,SAAS,GACpB,OAAO,CAAC,MAAM,EAAE,CAAC,CAqCnB"}

package/dist/core/ensemble_embed.js

@@ -0,0 +1,24 @@
+import { getModelFromAgent, getModelProvider, } from '../model_providers/model_provider.js';
+const embeddingCache = new Map();
+export async function ensembleEmbed(text, agent, options) {
+    const cacheKey = `${agent.model || agent.modelClass}:${text}`;
+    if (embeddingCache.has(cacheKey)) {
+        const cached = embeddingCache.get(cacheKey);
+        return cached.embedding;
+    }
+    const model = await getModelFromAgent(agent, 'embedding');
+    const provider = getModelProvider(model);
+    if (!provider.createEmbedding) {
+        throw new Error(`Provider for model ${model} does not support embeddings`);
+    }
+    const result = await provider.createEmbedding(text, model, options);
+    const embedding = Array.isArray(result[0])
+        ? result[0]
+        : result;
+    embeddingCache.set(cacheKey, {
+        embedding,
+        timestamp: new Date(),
+    });
+    return embedding;
+}
+//# sourceMappingURL=ensemble_embed.js.map

package/dist/core/ensemble_embed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensemble_embed.js","sourceRoot":"","sources":["../../core/ensemble_embed.ts"],"names":[],"mappings":"AACA,OAAO,EACH,iBAAiB,EACjB,gBAAgB,GACnB,MAAM,sCAAsC,CAAC;AAG9C,MAAM,cAAc,GAAG,IAAI,GAAG,EAM3B,CAAC;AA0BJ,MAAM,CAAC,KAAK,UAAU,aAAa,CAC/B,IAAY,EACZ,KAAsB,EACtB,OAAmB;IAGnB,MAAM,QAAQ,GAAG,GAAG,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,UAAU,IAAI,IAAI,EAAE,CAAC;IAG9D,IAAI,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC/B,MAAM,MAAM,GAAG,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAE,CAAC;QAC7C,OAAO,MAAM,CAAC,SAAS,CAAC;IAC5B,CAAC;IAGD,MAAM,KAAK,GAAG,MAAM,iBAAiB,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IAG1D,MAAM,QAAQ,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;IAEzC,IAAI,CAAC,QAAQ,CAAC,eAAe,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CACX,sBAAsB,KAAK,8BAA8B,CAC5D,CAAC;IACN,CAAC;IAGD,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,eAAe,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IAGpE,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QACtC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;QACX,CAAC,CAAE,MAAmB,CAAC;IAG3B,cAAc,CAAC,GAAG,CAAC,QAAQ,EAAE;QACzB,SAAS;QACT,SAAS,EAAE,IAAI,IAAI,EAAE;KACxB,CAAC,CAAC;IAEH,OAAO,SAAS,CAAC;AACrB,CAAC"}

package/dist/core/ensemble_image.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition, ImageGenerationOpts } from '../types/types.js';
+export declare function ensembleImage(prompt: string, agent: AgentDefinition, options?: ImageGenerationOpts): Promise<string[]>;
+//# sourceMappingURL=ensemble_image.d.ts.map

package/dist/core/ensemble_image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensemble_image.d.ts","sourceRoot":"","sources":["../../core/ensemble_image.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AA2B9E,wBAAsB,aAAa,CAC/B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,eAAe,EACtB,OAAO,GAAE,mBAAwB,GAClC,OAAO,CAAC,MAAM,EAAE,CAAC,CAWnB"}

package/dist/core/ensemble_image.js

@@ -0,0 +1,10 @@
+import { getModelFromAgent, getModelProvider, } from '../model_providers/model_provider.js';
+export async function ensembleImage(prompt, agent, options = {}) {
+    const model = await getModelFromAgent(agent, 'image_generation');
+    const provider = getModelProvider(model);
+    if (!provider.createImage) {
+        throw new Error(`Provider for model ${model} does not support image generation`);
+    }
+    return provider.createImage(prompt, model, options);
+}
+//# sourceMappingURL=ensemble_image.js.map

package/dist/core/ensemble_image.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensemble_image.js","sourceRoot":"","sources":["../../core/ensemble_image.ts"],"names":[],"mappings":"AACA,OAAO,EACH,iBAAiB,EACjB,gBAAgB,GACnB,MAAM,sCAAsC,CAAC;AAuB9C,MAAM,CAAC,KAAK,UAAU,aAAa,CAC/B,MAAc,EACd,KAAsB,EACtB,UAA+B,EAAE;IAEjC,MAAM,KAAK,GAAG,MAAM,iBAAiB,CAAC,KAAK,EAAE,kBAAkB,CAAC,CAAC;IACjE,MAAM,QAAQ,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;IAEzC,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CACX,sBAAsB,KAAK,oCAAoC,CAClE,CAAC;IACN,CAAC;IAED,OAAO,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;AACxD,CAAC"}

package/dist/core/ensemble_request.d.ts

@@ -0,0 +1,4 @@
+import { ProviderStreamEvent, ResponseInput, AgentDefinition } from '../types/types.js';
+export declare function ensembleRequest(messages: ResponseInput, agent: AgentDefinition): AsyncGenerator<ProviderStreamEvent>;
+export declare function mergeHistoryThread(mainHistory: ResponseInput, thread: ResponseInput, startIndex: number): void;
+//# sourceMappingURL=ensemble_request.d.ts.map

package/dist/core/ensemble_request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensemble_request.d.ts","sourceRoot":"","sources":["../../core/ensemble_request.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,mBAAmB,EACnB,aAAa,EAGb,eAAe,EAGlB,MAAM,mBAAmB,CAAC;AAkB3B,wBAAuB,eAAe,CAClC,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,eAAe,GACvB,cAAc,CAAC,mBAAmB,CAAC,CAsGrC;AAwRD,wBAAgB,kBAAkB,CAC9B,WAAW,EAAE,aAAa,EAC1B,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,MAAM,GACnB,IAAI,CAGN"}

package/dist/core/ensemble_request.js

@@ -0,0 +1,240 @@
+import { createRequestContext, ToolCallAction, } from '../types/tool_types.js';
+import { getModelFromAgent, getModelProvider, } from '../model_providers/model_provider.js';
+import { MessageHistory } from '../utils/message_history.js';
+import { handleToolCall } from '../utils/tool_execution_manager.js';
+import { processToolResult } from '../utils/tool_result_processor.js';
+import { verifyOutput } from '../utils/verification.js';
+export async function* ensembleRequest(messages, agent) {
+    const conversationHistory = agent?.historyThread || messages;
+    const history = new MessageHistory(conversationHistory, {
+        compactToolCalls: true,
+        preserveSystemMessages: true,
+    });
+    const context = createRequestContext({
+        messages: history.getMessages(),
+    });
+    try {
+        let totalToolCalls = 0;
+        let toolCallRounds = 0;
+        const maxToolCalls = agent?.maxToolCalls || 200;
+        const maxRounds = agent?.maxToolCallRoundsPerTurn || Infinity;
+        let hasToolCalls = true;
+        let lastMessageContent = '';
+        while (hasToolCalls && toolCallRounds < maxRounds && totalToolCalls < maxToolCalls) {
+            hasToolCalls = false;
+            const roundResult = await executeRound(agent, context, history, totalToolCalls, maxToolCalls);
+            for await (const event of roundResult.stream) {
+                yield event;
+            }
+            if (roundResult.toolCount > 0) {
+                hasToolCalls = true;
+                totalToolCalls += roundResult.toolCount;
+                toolCallRounds++;
+            }
+            if (roundResult.messageContent) {
+                lastMessageContent = roundResult.messageContent;
+            }
+        }
+        if (hasToolCalls && toolCallRounds >= maxRounds) {
+            yield {
+                type: 'message_delta',
+                content: '\n\n[Tool call rounds limit reached]',
+            };
+        }
+        else if (hasToolCalls && totalToolCalls >= maxToolCalls) {
+            yield {
+                type: 'message_delta',
+                content: '\n\n[Total tool calls limit reached]',
+            };
+        }
+        if (agent?.verifier && lastMessageContent) {
+            const verificationResult = await performVerification(agent, lastMessageContent, history.getMessages());
+            if (verificationResult) {
+                for await (const event of verificationResult) {
+                    yield event;
+                }
+            }
+        }
+    }
+    catch (error) {
+        yield {
+            type: 'error',
+            error: error.message || 'Unknown error',
+            code: error.code,
+            details: error.details,
+            recoverable: error.recoverable,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    finally {
+        yield {
+            type: 'stream_end',
+            timestamp: new Date().toISOString(),
+        };
+    }
+}
+async function executeRound(agent, context, history, currentToolCalls, maxToolCalls) {
+    const events = [];
+    let messageContent = '';
+    let toolCount = 0;
+    const messages = history.getMessages();
+    const model = await getModelFromAgent(agent);
+    const provider = await getModelProvider(model);
+    const stream = provider.createResponseStream(messages, model, agent);
+    const toolPromises = [];
+    for await (const event of stream) {
+        if (agent.allowedEvents && !agent.allowedEvents.includes(event.type)) {
+            continue;
+        }
+        events.push(event);
+        switch (event.type) {
+            case 'message_complete':
+                if ('content' in event) {
+                    messageContent = event.content;
+                }
+                break;
+            case 'tool_start':
+                if ('tool_calls' in event && event.tool_calls) {
+                    const remainingCalls = maxToolCalls - currentToolCalls;
+                    if (remainingCalls <= 0) {
+                        console.warn(`Tool call limit reached (${maxToolCalls}). Skipping tool calls.`);
+                        break;
+                    }
+                    const toolCallsToProcess = event.tool_calls.slice(0, remainingCalls);
+                    toolCount += toolCallsToProcess.length;
+                    toolPromises.push(processToolCalls(toolCallsToProcess, agent, context));
+                }
+                break;
+            case 'error':
+                if (context) {
+                    context.halt();
+                }
+                break;
+        }
+    }
+    const toolResults = (await Promise.all(toolPromises)).flat();
+    if (messageContent.length > 0 || toolResults.length > 0) {
+        history.addAssistantResponse(messageContent, toolResults);
+    }
+    if (context) {
+        context.messages = history.getMessages();
+        context.toolCallCount += toolResults.length;
+    }
+    async function* eventGenerator() {
+        for (const event of events) {
+            yield event;
+        }
+    }
+    return {
+        stream: eventGenerator(),
+        toolCount,
+        messageContent,
+    };
+}
+async function* performVerification(agent, output, messages, attempt = 0) {
+    if (!agent.verifier)
+        return;
+    const maxAttempts = agent.maxVerificationAttempts || 2;
+    const verification = await verifyOutput(agent.verifier, output, messages);
+    if (verification.status === 'pass') {
+        yield {
+            type: 'message_delta',
+            content: '\n\n✓ Output verified',
+        };
+        return;
+    }
+    if (attempt < maxAttempts - 1) {
+        yield {
+            type: 'message_delta',
+            content: `\n\n⚠️ Verification failed: ${verification.reason}\n\nRetrying...`,
+        };
+        const retryMessages = [
+            ...messages,
+            { type: 'message', role: 'assistant', content: output, status: 'completed' },
+            {
+                type: 'message',
+                role: 'developer',
+                content: `Verification failed: ${verification.reason}\n\nPlease correct your response.`
+            }
+        ];
+        const retryAgent = {
+            ...agent,
+            verifier: undefined,
+            historyThread: retryMessages,
+        };
+        const retryStream = ensembleRequest(retryMessages, retryAgent);
+        let retryOutput = '';
+        for await (const event of retryStream) {
+            yield event;
+            if (event.type === 'message_complete' && 'content' in event) {
+                retryOutput = event.content;
+            }
+        }
+        if (retryOutput) {
+            yield* performVerification(agent, retryOutput, messages, attempt + 1);
+        }
+    }
+    else {
+        yield {
+            type: 'message_delta',
+            content: `\n\n❌ Verification failed after ${maxAttempts} attempts: ${verification.reason}`,
+        };
+    }
+}
+async function processToolCalls(toolCalls, agent, context) {
+    const toolCallPromises = toolCalls.map(async (toolCall) => {
+        if (agent.onToolCall) {
+            const action = await agent.onToolCall(toolCall);
+            if (action && action === ToolCallAction.SKIP) {
+                return null;
+            }
+            if (action === ToolCallAction.HALT && context) {
+                context.halt();
+                return null;
+            }
+        }
+        try {
+            if (!agent.tools) {
+                throw new Error('No tools available for agent');
+            }
+            const tool = agent.tools.find(t => t.definition.function.name === toolCall.function.name);
+            if (!tool || !('function' in tool)) {
+                throw new Error(`Tool ${toolCall.function.name} not found`);
+            }
+            const rawResult = await handleToolCall(toolCall, tool, agent);
+            const processedResult = await processToolResult(toolCall, rawResult);
+            const toolCallResult = {
+                toolCall,
+                id: toolCall.id,
+                call_id: toolCall.call_id || toolCall.id,
+                output: processedResult,
+            };
+            if (agent.onToolResult) {
+                await agent.onToolResult(toolCallResult);
+            }
+            return toolCallResult;
+        }
+        catch (error) {
+            const errorOutput = error instanceof Error
+                ? `Tool execution failed: ${error.message}`
+                : `Tool execution failed: ${String(error)}`;
+            const toolCallResult = {
+                toolCall,
+                id: toolCall.id,
+                call_id: toolCall.call_id || toolCall.id,
+                output: errorOutput,
+            };
+            if (agent.onToolError) {
+                await agent.onToolError(toolCallResult);
+            }
+            return toolCallResult;
+        }
+    });
+    const results = await Promise.all(toolCallPromises);
+    return results.filter((result) => result !== null);
+}
+export function mergeHistoryThread(mainHistory, thread, startIndex) {
+    const newMessages = thread.slice(startIndex);
+    mainHistory.push(...newMessages);
+}
+//# sourceMappingURL=ensemble_request.js.map