graphlit-client 1.0.20250610008 → 1.0.20250610010

package/README.md

@@ -2,7 +2,37 @@
 
 ## Overview
 
-The Graphlit Client for Node.js enables straightforward interactions with the Graphlit API, allowing developers to execute GraphQL queries and mutations against the Graphlit service. This document outlines the setup process and provides examples of using the client, including the new streaming capabilities.
+The Graphlit Client for Node.js enables straightforward interactions with the Graphlit API, allowing developers to execute GraphQL queries and mutations against the Graphlit service. This document outlines the setup process and provides examples of using the client, including advanced streaming capabilities with real-time token delivery and tool calling support.
+
+## Quick Start
+
+Get up and running in 2 minutes:
+
+```bash
+# Install the client
+npm install graphlit-client
+
+# Set your credentials (get from https://portal.graphlit.dev)
+export GRAPHLIT_ORGANIZATION_ID=your_org_id
+export GRAPHLIT_ENVIRONMENT_ID=your_env_id  
+export GRAPHLIT_JWT_SECRET=your_secret
+```
+
+```typescript
+import { Graphlit } from "graphlit-client";
+
+const client = new Graphlit();
+
+// Stream a conversation
+await client.streamAgent(
+  "Hello! Tell me a joke",
+  (event) => {
+    if (event.type === "message_update") {
+      console.log(event.message.message);
+    }
+  }
+);
+```
 
 ## Prerequisites
 
@@ -102,17 +132,17 @@ const contents = await client.queryContents({
 
 ### Streaming Conversations with streamAgent
 
-The new `streamAgent` method provides real-time streaming responses with automatic UI event handling:
+The `streamAgent` method provides real-time streaming responses with automatic UI event handling. It supports both native SDK streaming (when LLM clients are configured) and fallback streaming through the Graphlit API:
 
 ```typescript
-import { Graphlit, UIStreamEvent } from "graphlit-client";
+import { Graphlit, AgentStreamEvent } from "graphlit-client";
 
 const client = new Graphlit();
 
 // Basic streaming conversation
 await client.streamAgent(
   "Tell me about artificial intelligence",
-  (event: UIStreamEvent) => {
+  (event: AgentStreamEvent) => {
     switch (event.type) {
       case "conversation_started":
         console.log(`Started conversation: ${event.conversationId}`);
@@ -135,9 +165,27 @@ await client.streamAgent(
 );
 ```
 
+### Non-Streaming Conversations with promptAgent
+
+For simpler use cases without streaming, use `promptAgent`:
+
+```typescript
+const result = await client.promptAgent(
+  "What's the weather like?",
+  undefined, // conversationId (creates new)
+  { id: "your-specification-id" }, // specification
+  tools, // optional tools array
+  toolHandlers, // optional tool handlers
+  { timeout: 30000 } // optional timeout
+);
+
+console.log(result.message); // Complete response
+console.log(result.conversationId); // For continuing the conversation
+```
+
 ### Tool Calling with Streaming
 
-`streamAgent` supports tool calling with automatic execution:
+`streamAgent` supports sophisticated tool calling with automatic execution and parallel processing:
 
 ```typescript
 // Define tools
@@ -164,12 +212,15 @@ const toolHandlers = {
 // Stream with tools
 await client.streamAgent(
   "What's the weather in San Francisco?",
-  (event: UIStreamEvent) => {
+  (event: AgentStreamEvent) => {
     if (event.type === "tool_update") {
       console.log(`Tool ${event.toolCall.name}: ${event.status}`);
       if (event.result) {
         console.log(`Result: ${JSON.stringify(event.result)}`);
       }
+      if (event.error) {
+        console.error(`Tool error: ${event.error}`);
+      }
     } else if (event.type === "conversation_completed") {
       console.log(`Final: ${event.message.message}`);
     }
@@ -306,17 +357,98 @@ client.streamAgent(
 setTimeout(() => controller.abort(), 5000);
 ```
 
+## Advanced Tool Calling
+
+### Multiple Tool Calls
+
+The agent can make multiple tool calls in a single response:
+
+```typescript
+const tools = [
+  {
+    name: "search_web",
+    description: "Search the web for information",
+    schema: JSON.stringify({
+      type: "object",
+      properties: {
+        query: { type: "string" }
+      },
+      required: ["query"]
+    })
+  },
+  {
+    name: "calculate",
+    description: "Perform calculations",
+    schema: JSON.stringify({
+      type: "object",
+      properties: {
+        expression: { type: "string" }
+      },
+      required: ["expression"]
+    })
+  }
+];
+
+const toolHandlers = {
+  search_web: async ({ query }) => {
+    // Implement web search
+    return { results: ["Result 1", "Result 2"] };
+  },
+  calculate: async ({ expression }) => {
+    // Implement calculation
+    return { result: eval(expression) }; // Use a proper math parser in production
+  }
+};
+
+// The agent can use multiple tools to answer complex queries
+await client.streamAgent(
+  "Search for the current GDP of Japan and calculate 2.5% of it",
+  handleStreamEvent,
+  undefined,
+  { id: specId },
+  tools,
+  toolHandlers,
+  { maxToolRounds: 5 } // Allow multiple rounds of tool calls
+);
+```
+
+### Tool Calling with Timeouts
+
+Protect against hanging tools with timeouts:
+
+```typescript
+const toolHandlers = {
+  slow_operation: async (args) => {
+    // This will timeout after 30 seconds (default)
+    await someSlowOperation(args);
+  }
+};
+
+// Or set custom timeout in AgentOptions
+await client.promptAgent(
+  "Run the slow operation",
+  undefined,
+  { id: specId },
+  tools,
+  toolHandlers,
+  { 
+    timeout: 60000, // 60 second timeout for entire operation
+    maxToolRounds: 3 
+  }
+);
+```
+
 ## Stream Event Reference
 
-### UI Stream Events
+### Agent Stream Events
 
 | Event Type | Description | Properties |
 |------------|-------------|------------|
-| `conversation_started` | Conversation initialized | `conversationId`, `timestamp` |
+| `conversation_started` | Conversation initialized | `conversationId`, `timestamp`, `model?` |
 | `message_update` | Message text updated | `message` (complete text), `isStreaming` |
 | `tool_update` | Tool execution status | `toolCall`, `status`, `result?`, `error?` |
 | `conversation_completed` | Streaming finished | `message` (final) |
-| `error` | Error occurred | `error` object with `message`, `code`, `recoverable` |
+| `error` | Error occurred | `error` object with `message`, `code?`, `recoverable` |
 
 ### Tool Execution Statuses
 
@@ -405,12 +537,111 @@ await client.streamAgent(
 );
 ```
 
+## Best Practices
+
+### 1. Always Handle Errors
+
+```typescript
+await client.streamAgent(
+  prompt,
+  (event) => {
+    if (event.type === "error") {
+      // Check if error is recoverable
+      if (event.error.recoverable) {
+        // Could retry or fallback
+        console.warn("Recoverable error:", event.error.message);
+      } else {
+        // Fatal error
+        console.error("Fatal error:", event.error.message);
+      }
+    }
+  }
+);
+```
+
+### 2. Clean Up Resources
+
+```typescript
+// Always clean up conversations when done
+let conversationId: string;
+
+try {
+  await client.streamAgent(
+    prompt,
+    (event) => {
+      if (event.type === "conversation_started") {
+        conversationId = event.conversationId;
+      }
+    }
+  );
+} finally {
+  if (conversationId) {
+    await client.deleteConversation(conversationId);
+  }
+}
+```
+
+### 3. Tool Handler Best Practices
+
+```typescript
+const toolHandlers = {
+  // Always validate inputs
+  calculate: async (args) => {
+    if (!args.expression || typeof args.expression !== 'string') {
+      throw new Error("Invalid expression");
+    }
+    
+    // Return structured data
+    return {
+      expression: args.expression,
+      result: evaluateExpression(args.expression),
+      timestamp: new Date().toISOString()
+    };
+  },
+  
+  // Handle errors gracefully
+  fetch_data: async (args) => {
+    try {
+      const data = await fetchFromAPI(args.url);
+      return { success: true, data };
+    } catch (error) {
+      return { 
+        success: false, 
+        error: error.message,
+        // Help the LLM understand what went wrong
+        suggestion: "The URL might be invalid or the service is down"
+      };
+    }
+  }
+};
+```
+
+### 4. Optimize for Performance
+
+```typescript
+// Use appropriate chunking strategy for your use case
+const options = {
+  // For code generation or technical content
+  chunkingStrategy: 'character' as const,
+  
+  // For natural conversation (default)
+  chunkingStrategy: 'word' as const,
+  
+  // For long-form content
+  chunkingStrategy: 'sentence' as const,
+  
+  // Adjust smoothing delay for your UI
+  smoothingDelay: 20, // Faster updates
+  smoothingDelay: 50, // Smoother updates (default: 30)
+};
+```
+
 ## Migration Guide
 
-If you're upgrading from `promptConversation` to `streamAgent`:
+If you're upgrading from `promptConversation` to `streamAgent` or `promptAgent`:
 
 ```typescript
-// Before
+// Before (v1.0)
 const response = await client.promptConversation(
   "Your prompt",
   undefined,
@@ -418,7 +649,15 @@ const response = await client.promptConversation(
 );
 console.log(response.promptConversation.message.message);
 
-// After
+// After (v1.1) - Non-streaming
+const result = await client.promptAgent(
+  "Your prompt",
+  undefined,
+  { id: specId }
+);
+console.log(result.message);
+
+// After (v1.1) - Streaming
 await client.streamAgent(
   "Your prompt",
   (event) => {
@@ -431,6 +670,69 @@ await client.streamAgent(
 );
 ```
 
+## Troubleshooting
+
+### Common Issues
+
+#### 1. Streaming Not Working
+
+```typescript
+// Check if streaming is supported
+if (!client.supportsStreaming()) {
+  console.log("Streaming not supported - using fallback mode");
+}
+
+// Ensure LLM clients are properly configured
+const hasNativeStreaming = 
+  client.hasOpenAIClient() || 
+  client.hasAnthropicClient() || 
+  client.hasGoogleClient();
+```
+
+#### 2. Tool Calls Not Executing
+
+```typescript
+// Ensure tool schemas are valid JSON Schema
+const validSchema = {
+  type: "object",
+  properties: {
+    param: { type: "string", description: "Parameter description" }
+  },
+  required: ["param"] // Don't forget required fields
+};
+
+// Tool names must match exactly
+const tools = [{ name: "my_tool", /* ... */ }];
+const toolHandlers = { 
+  "my_tool": async (args) => { /* ... */ } // Name must match
+};
+```
+
+#### 3. Incomplete Streaming Responses
+
+Some LLM providers may truncate responses. The client handles this automatically, but you can enable debug logging:
+
+```bash
+DEBUG_STREAMING=true npm start
+```
+
+#### 4. Type Errors
+
+Ensure you're importing the correct types:
+
+```typescript
+import { 
+  Graphlit,
+  AgentStreamEvent,  // For streaming events
+  AgentResult,       // For promptAgent results
+  ToolHandler,       // For tool handler functions
+  StreamAgentOptions // For streaming options
+} from "graphlit-client";
+
+// Also available if needed
+import * as Types from "graphlit-client/generated/graphql-types";
+```
+
 ## Support
 
 Please refer to the [Graphlit API Documentation](https://docs.graphlit.dev/).

package/dist/client.d.ts

@@ -2,40 +2,6 @@ import { ApolloClient, NormalizedCacheObject } from "@apollo/client/core";
 import * as Types from "./generated/graphql-types.js";
 import { AgentOptions, AgentResult, StreamAgentOptions, ToolHandler } from "./types/agent.js";
 import { AgentStreamEvent } from "./types/ui-events.js";
-export type StreamEvent = {
-    type: "start";
-    conversationId: string;
-} | {
-    type: "token";
-    token: string;
-} | {
-    type: "message";
-    message: string;
-} | {
-    type: "tool_call_start";
-    toolCall: {
-        id: string;
-        name: string;
-    };
-} | {
-    type: "tool_call_delta";
-    toolCallId: string;
-    argumentDelta: string;
-} | {
-    type: "tool_call_complete";
-    toolCall: {
-        id: string;
-        name: string;
-        arguments: string;
-    };
-} | {
-    type: "complete";
-    messageId?: string;
-    conversationId?: string;
-} | {
-    type: "error";
-    error: string;
-};
 export type { AgentOptions, AgentResult, StreamAgentOptions, ToolCallResult, UsageInfo, AgentError, } from "./types/agent.js";
 export type { AgentStreamEvent } from "./types/ui-events.js";
 declare class Graphlit {
@@ -376,7 +342,7 @@ declare class Graphlit {
      * @param options - Stream agent options
      * @throws Error if streaming is not supported
      */
-    streamAgent(prompt: string, onEvent: (event: StreamEvent | AgentStreamEvent) => void, conversationId?: string, specification?: Types.EntityReferenceInput, tools?: Types.ToolDefinitionInput[], toolHandlers?: Record<string, ToolHandler>, options?: StreamAgentOptions, mimeType?: string, data?: string, // base64 encoded
+    streamAgent(prompt: string, onEvent: (event: AgentStreamEvent) => void, conversationId?: string, specification?: Types.EntityReferenceInput, tools?: Types.ToolDefinitionInput[], toolHandlers?: Record<string, ToolHandler>, options?: StreamAgentOptions, mimeType?: string, data?: string, // base64 encoded
     correlationId?: string): Promise<void>;
     /**
      * Execute the streaming agent workflow with tool calling loop
@@ -417,4 +383,3 @@ declare class Graphlit {
 }
 export { Graphlit };
 export * as Types from "./generated/graphql-types.js";
-export { StreamEventAggregator, AggregatedEvent, formatSSEEvent, createSSEStream, wrapToolHandlers, enhanceToolCalls, ConversationMetrics, ToolResultEmitter, ServerMapping, } from "./stream-helpers.js";

package/dist/client.js

@@ -2113,5 +2113,3 @@ class Graphlit {
 }
 export { Graphlit };
 export * as Types from "./generated/graphql-types.js";
-// Export streaming helpers
-export { StreamEventAggregator, formatSSEEvent, createSSEStream, wrapToolHandlers, enhanceToolCalls, ConversationMetrics, } from "./stream-helpers.js";

package/dist/streaming/providers.d.ts

@@ -1,6 +1,6 @@
 import { ConversationToolCall, Specification, ToolDefinitionInput } from "../generated/graphql-types.js";
-import { StreamEvent } from "../client.js";
 import { OpenAIMessage, AnthropicMessage, GoogleMessage } from "./llm-formatters.js";
+import { StreamEvent } from "../types/internal.js";
 /**
  * Stream with OpenAI SDK
  */

package/dist/streaming/ui-event-adapter.d.ts

@@ -1,5 +1,5 @@
 import { AgentStreamEvent } from "../types/ui-events.js";
-import { StreamEvent } from "../client.js";
+import { StreamEvent } from "../types/internal.js";
 import { ChunkingStrategy } from "./chunk-buffer.js";
 /**
  * Adapter that transforms low-level streaming events into high-level UI events

package/dist/types/internal.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Internal types used by the streaming implementation
+ * These are not exported to consumers of the library
+ */
+/**
+ * Low-level streaming events used internally by providers
+ * These get transformed into AgentStreamEvent by UIEventAdapter
+ */
+export type StreamEvent = {
+    type: "start";
+    conversationId: string;
+} | {
+    type: "token";
+    token: string;
+} | {
+    type: "message";
+    message: string;
+} | {
+    type: "tool_call_start";
+    toolCall: {
+        id: string;
+        name: string;
+    };
+} | {
+    type: "tool_call_delta";
+    toolCallId: string;
+    argumentDelta: string;
+} | {
+    type: "tool_call_complete";
+    toolCall: {
+        id: string;
+        name: string;
+        arguments: string;
+    };
+} | {
+    type: "complete";
+    messageId?: string;
+    conversationId?: string;
+} | {
+    type: "error";
+    error: string;
+};

package/dist/types/internal.js

@@ -0,0 +1,5 @@
+/**
+ * Internal types used by the streaming implementation
+ * These are not exported to consumers of the library
+ */
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphlit-client",
-  "version": "1.0.20250610008",
+  "version": "1.0.20250610010",
   "description": "Graphlit API Client for TypeScript",
   "main": "dist/client.js",
   "types": "dist/client.d.ts",

package/dist/stream-helpers.d.ts

@@ -1,106 +0,0 @@
-import { StreamEvent } from "./client.js";
-import { ConversationRoleTypes } from "./generated/graphql-types.js";
-export declare class StreamEventAggregator {
-    private conversationId;
-    private messageBuffer;
-    private toolCallsBuffer;
-    private isFirstAssistantMessage;
-    private hasReceivedToolCalls;
-    private tokenBuffer;
-    /**
-     * Process a stream event and return any complete messages ready for the UI
-     */
-    processEvent(event: StreamEvent): AggregatedEvent | null;
-    /**
-     * Reset the aggregator for a new conversation
-     */
-    reset(): void;
-    /**
-     * Get current state (useful for debugging)
-     */
-    getState(): {
-        conversationId: string;
-        messageBuffer: string;
-        toolCallsCount: number;
-        hasReceivedToolCalls: boolean;
-        isFirstAssistantMessage: boolean;
-        tokenCount: number;
-    };
-}
-/**
- * Aggregated event types that are ready for UI consumption
- */
-export type AggregatedEvent = {
-    type: "conversationStarted";
-    conversationId: string;
-} | {
-    type: "token";
-    token: string;
-    accumulated: string;
-} | {
-    type: "assistantMessage";
-    message: {
-        message?: string | null;
-        role?: ConversationRoleTypes | null;
-        toolCalls?: any[];
-    };
-    isFinal: boolean;
-    conversationId?: string;
-} | {
-    type: "streamComplete";
-    conversationId?: string;
-} | {
-    type: "error";
-    error: string;
-};
-/**
- * Helper to create an SSE response with proper formatting
- */
-export declare function formatSSEEvent(data: any, eventName?: string): string;
-/**
- * Helper to create a TransformStream for SSE with built-in ping support
- */
-export declare function createSSEStream(options?: {
-    pingInterval?: number;
-}): {
-    readable: ReadableStream<any>;
-    sendEvent: (data: any, eventName?: string) => Promise<void>;
-    close: () => Promise<void>;
-    writer: WritableStreamDefaultWriter<any>;
-};
-/**
- * Helper to wrap tool handlers with result emission
- */
-export interface ToolResultEmitter {
-    (toolCallId: string, result: any, status: "complete" | "error" | "blocked", duration: number): void;
-}
-export declare function wrapToolHandlers(handlers: Record<string, (args: any) => Promise<any>>, emitResult: ToolResultEmitter): Record<string, (args: any) => Promise<any>>;
-/**
- * Helper to enhance tool calls with server information
- */
-export interface ServerMapping {
-    toolName: string;
-    serverName: string;
-    serverId: string;
-}
-export declare function enhanceToolCalls(toolCalls: any[], serverMappings: ServerMapping[]): any[];
-/**
- * Helper to track conversation metrics
- */
-export declare class ConversationMetrics {
-    private startTime;
-    private tokenCount;
-    private toolCallCount;
-    private errorCount;
-    recordToken(): void;
-    recordToolCall(): void;
-    recordError(): void;
-    getMetrics(): {
-        duration: number;
-        tokenCount: number;
-        toolCallCount: number;
-        errorCount: number;
-        tokensPerSecond: number;
-    };
-    reset(): void;
-}

package/dist/stream-helpers.js

@@ -1,237 +0,0 @@
-import { ConversationRoleTypes, } from "./generated/graphql-types.js";
-export class StreamEventAggregator {
-    conversationId = "";
-    messageBuffer = "";
-    toolCallsBuffer = new Map();
-    isFirstAssistantMessage = true;
-    hasReceivedToolCalls = false;
-    tokenBuffer = [];
-    /**
-     * Process a stream event and return any complete messages ready for the UI
-     */
-    processEvent(event) {
-        switch (event.type) {
-            case "start":
-                this.conversationId = event.conversationId;
-                return {
-                    type: "conversationStarted",
-                    conversationId: event.conversationId,
-                };
-            case "token":
-                this.messageBuffer += event.token;
-                this.tokenBuffer.push(event.token);
-                return {
-                    type: "token",
-                    token: event.token,
-                    accumulated: this.messageBuffer,
-                };
-            case "message":
-                // SDK provides accumulated message - we can use this instead of our buffer
-                this.messageBuffer = event.message;
-                return null; // Don't emit, wait for complete event
-            case "tool_call_start":
-                this.hasReceivedToolCalls = true;
-                this.toolCallsBuffer.set(event.toolCall.id, {
-                    id: event.toolCall.id,
-                    name: event.toolCall.name,
-                    argumentsBuffer: "",
-                    isComplete: false,
-                    startTime: Date.now(),
-                });
-                return null; // Buffer until complete
-            case "tool_call_delta":
-                const toolCall = this.toolCallsBuffer.get(event.toolCallId);
-                if (toolCall) {
-                    toolCall.argumentsBuffer += event.argumentDelta;
-                }
-                return null; // Buffer until complete
-            case "tool_call_complete":
-                const completeToolCall = this.toolCallsBuffer.get(event.toolCall.id);
-                if (completeToolCall) {
-                    completeToolCall.argumentsBuffer = event.toolCall.arguments;
-                    completeToolCall.isComplete = true;
-                }
-                // Check if all tool calls are complete
-                const allComplete = Array.from(this.toolCallsBuffer.values()).every((tc) => tc.isComplete);
-                if (allComplete &&
-                    this.hasReceivedToolCalls &&
-                    this.isFirstAssistantMessage) {
-                    // Emit complete assistant message with all tool calls
-                    const toolCalls = Array.from(this.toolCallsBuffer.values()).map((tc) => ({
-                        id: tc.id,
-                        name: tc.name,
-                        arguments: tc.argumentsBuffer,
-                        status: "pending",
-                    }));
-                    this.isFirstAssistantMessage = false;
-                    return {
-                        type: "assistantMessage",
-                        message: {
-                            message: this.messageBuffer,
-                            role: ConversationRoleTypes.Assistant,
-                            toolCalls,
-                        },
-                        isFinal: false,
-                    };
-                }
-                return null;
-            case "complete":
-                // If we haven't sent a message yet (no tool calls), send it now
-                if (this.isFirstAssistantMessage && !this.hasReceivedToolCalls) {
-                    return {
-                        type: "assistantMessage",
-                        message: {
-                            message: this.messageBuffer,
-                            role: ConversationRoleTypes.Assistant,
-                        },
-                        isFinal: true,
-                        conversationId: event.conversationId,
-                    };
-                }
-                return { type: "streamComplete", conversationId: event.conversationId };
-            case "error":
-                return { type: "error", error: event.error };
-            default:
-                return null;
-        }
-    }
-    /**
-     * Reset the aggregator for a new conversation
-     */
-    reset() {
-        this.conversationId = "";
-        this.messageBuffer = "";
-        this.toolCallsBuffer.clear();
-        this.isFirstAssistantMessage = true;
-        this.hasReceivedToolCalls = false;
-        this.tokenBuffer = [];
-    }
-    /**
-     * Get current state (useful for debugging)
-     */
-    getState() {
-        return {
-            conversationId: this.conversationId,
-            messageBuffer: this.messageBuffer,
-            toolCallsCount: this.toolCallsBuffer.size,
-            hasReceivedToolCalls: this.hasReceivedToolCalls,
-            isFirstAssistantMessage: this.isFirstAssistantMessage,
-            tokenCount: this.tokenBuffer.length,
-        };
-    }
-}
-/**
- * Helper to create an SSE response with proper formatting
- */
-export function formatSSEEvent(data, eventName = "message") {
-    if (typeof data === "string") {
-        return `event: ${eventName}\ndata: ${data}\n\n`;
-    }
-    return `event: ${eventName}\ndata: ${JSON.stringify(data)}\n\n`;
-}
-/**
- * Helper to create a TransformStream for SSE with built-in ping support
- */
-export function createSSEStream(options) {
-    const encoder = new TextEncoder();
-    const { readable, writable } = new TransformStream();
-    const writer = writable.getWriter();
-    let pingInterval = null;
-    if (options?.pingInterval) {
-        pingInterval = globalThis.setInterval(() => {
-            writer.write(encoder.encode(":\n\n")).catch(() => {
-                // Ignore errors on ping
-            });
-        }, options.pingInterval);
-    }
-    const sendEvent = (data, eventName = "message") => {
-        const formatted = formatSSEEvent(data, eventName);
-        return writer.write(encoder.encode(formatted));
-    };
-    const close = async () => {
-        if (pingInterval) {
-            globalThis.clearInterval(pingInterval);
-        }
-        await writer.close();
-    };
-    return {
-        readable,
-        sendEvent,
-        close,
-        writer,
-    };
-}
-export function wrapToolHandlers(handlers, emitResult) {
-    const wrapped = {};
-    Object.entries(handlers).forEach(([name, handler]) => {
-        wrapped[name] = async (args) => {
-            const toolCallId = `tool_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-            const startTime = Date.now();
-            try {
-                const result = await handler(args);
-                const duration = Date.now() - startTime;
-                // Emit success result
-                emitResult(toolCallId, { status: "success", result }, "complete", duration);
-                return result;
-            }
-            catch (error) {
-                const duration = Date.now() - startTime;
-                // Emit error result
-                emitResult(toolCallId, {
-                    status: "error",
-                    error: error instanceof Error ? error.message : String(error),
-                }, "error", duration);
-                throw error;
-            }
-        };
-    });
-    return wrapped;
-}
-export function enhanceToolCalls(toolCalls, serverMappings) {
-    const mappingDict = serverMappings.reduce((acc, mapping) => {
-        acc[mapping.toolName] = {
-            serverName: mapping.serverName,
-            serverId: mapping.serverId,
-        };
-        return acc;
-    }, {});
-    return toolCalls.map((toolCall) => ({
-        ...toolCall,
-        serverName: mappingDict[toolCall.name]?.serverName,
-        serverId: mappingDict[toolCall.name]?.serverId,
-    }));
-}
-/**
- * Helper to track conversation metrics
- */
-export class ConversationMetrics {
-    startTime = Date.now();
-    tokenCount = 0;
-    toolCallCount = 0;
-    errorCount = 0;
-    recordToken() {
-        this.tokenCount++;
-    }
-    recordToolCall() {
-        this.toolCallCount++;
-    }
-    recordError() {
-        this.errorCount++;
-    }
-    getMetrics() {
-        const duration = Date.now() - this.startTime;
-        return {
-            duration,
-            tokenCount: this.tokenCount,
-            toolCallCount: this.toolCallCount,
-            errorCount: this.errorCount,
-            tokensPerSecond: this.tokenCount / (duration / 1000),
-        };
-    }
-    reset() {
-        this.startTime = Date.now();
-        this.tokenCount = 0;
-        this.toolCallCount = 0;
-        this.errorCount = 0;
-    }
-}