@tuttiai/core 0.5.0 → 0.7.0

package/dist/index.js

@@ -1,3 +1,107 @@
+// src/logger.ts
+import pino from "pino";
+var createLogger = (name) => pino({
+  name,
+  level: process.env.TUTTI_LOG_LEVEL ?? "info",
+  transport: process.env.NODE_ENV === "production" ? void 0 : {
+    target: "pino-pretty",
+    options: {
+      colorize: true,
+      translateTime: "HH:MM:ss",
+      ignore: "pid,hostname"
+    }
+  }
+});
+var logger = createLogger("tutti");
+
+// src/telemetry.ts
+import { trace, SpanStatusCode } from "@opentelemetry/api";
+var tracer = trace.getTracer("tutti", "1.0.0");
+var TuttiTracer = {
+  agentRun(agentName, sessionId, fn) {
+    return tracer.startActiveSpan("agent.run", async (span) => {
+      span.setAttribute("agent.name", agentName);
+      span.setAttribute("session.id", sessionId);
+      try {
+        const result = await fn();
+        span.setStatus({ code: SpanStatusCode.OK });
+        return result;
+      } catch (err) {
+        span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: err instanceof Error ? err.message : String(err)
+        });
+        throw err;
+      } finally {
+        span.end();
+      }
+    });
+  },
+  llmCall(model, fn) {
+    return tracer.startActiveSpan("llm.call", async (span) => {
+      span.setAttribute("llm.model", model);
+      try {
+        const result = await fn();
+        span.setStatus({ code: SpanStatusCode.OK });
+        return result;
+      } catch (err) {
+        span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: err instanceof Error ? err.message : String(err)
+        });
+        throw err;
+      } finally {
+        span.end();
+      }
+    });
+  },
+  toolCall(toolName, fn) {
+    return tracer.startActiveSpan("tool.call", async (span) => {
+      span.setAttribute("tool.name", toolName);
+      try {
+        const result = await fn();
+        span.setStatus({ code: SpanStatusCode.OK });
+        return result;
+      } catch (err) {
+        span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: err instanceof Error ? err.message : String(err)
+        });
+        throw err;
+      } finally {
+        span.end();
+      }
+    });
+  }
+};
+
+// src/telemetry-setup.ts
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
+var sdk;
+function initTelemetry(config) {
+  if (!config.enabled || sdk) return;
+  const endpoint = config.endpoint ?? "http://localhost:4318";
+  const exporter = new OTLPTraceExporter({
+    url: `${endpoint}/v1/traces`,
+    headers: config.headers
+  });
+  sdk = new NodeSDK({
+    traceExporter: exporter,
+    instrumentations: [getNodeAutoInstrumentations({ "@opentelemetry/instrumentation-fs": { enabled: false } })],
+    serviceName: process.env.OTEL_SERVICE_NAME ?? "tutti"
+  });
+  sdk.start();
+  logger.info({ endpoint }, "OpenTelemetry tracing enabled");
+}
+async function shutdownTelemetry() {
+  if (sdk) {
+    await sdk.shutdown();
+    sdk = void 0;
+  }
+}
+
 // src/agent-runner.ts
 import { zodToJsonSchema } from "zod-to-json-schema";
 
@@ -148,157 +252,181 @@ The session may have expired or the ID is incorrect.
 Omit session_id to start a new conversation.`
       );
     }
-    this.events.emit({
-      type: "agent:start",
-      agent_name: agent.name,
-      session_id: session.id
-    });
-    const allTools = agent.voices.flatMap((v) => v.tools);
-    const toolDefs = allTools.map(toolToDefinition);
-    const messages = [
-      ...session.messages,
-      { role: "user", content: input }
-    ];
-    const maxTurns = agent.max_turns ?? DEFAULT_MAX_TURNS;
-    const maxToolCalls = agent.max_tool_calls ?? DEFAULT_MAX_TOOL_CALLS;
-    const budget = agent.budget ? new TokenBudget(agent.budget, agent.model ?? "") : void 0;
-    const totalUsage = { input_tokens: 0, output_tokens: 0 };
-    let turns = 0;
-    let totalToolCalls = 0;
-    while (turns < maxTurns) {
-      turns++;
+    return TuttiTracer.agentRun(agent.name, session.id, async () => {
+      logger.info({ agent: agent.name, session: session.id }, "Agent started");
       this.events.emit({
-        type: "turn:start",
+        type: "agent:start",
         agent_name: agent.name,
-        session_id: session.id,
-        turn: turns
+        session_id: session.id
       });
-      let systemPrompt = agent.system_prompt;
-      const memCfg = agent.semantic_memory;
-      if (memCfg?.enabled && this.semanticMemory) {
-        const maxMemories = memCfg.max_memories ?? 5;
-        const injectSystem = memCfg.inject_system !== false;
-        if (injectSystem) {
-          const memories = await this.semanticMemory.search(
-            input,
-            agent.name,
-            maxMemories
-          );
-          if (memories.length > 0) {
-            const memoryBlock = memories.map((m) => `- ${m.content}`).join("\n");
-            systemPrompt += "\n\nRelevant context from previous sessions:\n" + memoryBlock;
+      const allTools = agent.voices.flatMap((v) => v.tools);
+      const toolDefs = allTools.map(toolToDefinition);
+      const messages = [
+        ...session.messages,
+        { role: "user", content: input }
+      ];
+      const maxTurns = agent.max_turns ?? DEFAULT_MAX_TURNS;
+      const maxToolCalls = agent.max_tool_calls ?? DEFAULT_MAX_TOOL_CALLS;
+      const budget = agent.budget ? new TokenBudget(agent.budget, agent.model ?? "") : void 0;
+      const totalUsage = { input_tokens: 0, output_tokens: 0 };
+      let turns = 0;
+      let totalToolCalls = 0;
+      while (turns < maxTurns) {
+        turns++;
+        logger.info({ agent: agent.name, session: session.id, turn: turns }, "Turn started");
+        this.events.emit({
+          type: "turn:start",
+          agent_name: agent.name,
+          session_id: session.id,
+          turn: turns
+        });
+        let systemPrompt = agent.system_prompt;
+        const memCfg = agent.semantic_memory;
+        if (memCfg?.enabled && this.semanticMemory) {
+          const maxMemories = memCfg.max_memories ?? 5;
+          const injectSystem = memCfg.inject_system !== false;
+          if (injectSystem) {
+            const memories = await this.semanticMemory.search(
+              input,
+              agent.name,
+              maxMemories
+            );
+            if (memories.length > 0) {
+              const memoryBlock = memories.map((m) => `- ${m.content}`).join("\n");
+              systemPrompt += "\n\nRelevant context from previous sessions:\n" + memoryBlock;
+            }
           }
         }
-      }
-      const request = {
-        model: agent.model,
-        system: systemPrompt,
-        messages,
-        tools: toolDefs.length > 0 ? toolDefs : void 0
-      };
-      this.events.emit({
-        type: "llm:request",
-        agent_name: agent.name,
-        request
-      });
-      const response = await this.provider.chat(request);
-      this.events.emit({
-        type: "llm:response",
-        agent_name: agent.name,
-        response
-      });
-      totalUsage.input_tokens += response.usage.input_tokens;
-      totalUsage.output_tokens += response.usage.output_tokens;
-      if (budget) {
-        budget.add(response.usage.input_tokens, response.usage.output_tokens);
-        const status = budget.check();
-        if (status === "warning") {
-          this.events.emit({
-            type: "budget:warning",
-            agent_name: agent.name,
-            tokens: budget.total_tokens,
-            cost_usd: budget.estimated_cost_usd
-          });
-        } else if (status === "exceeded") {
-          this.events.emit({
-            type: "budget:exceeded",
-            agent_name: agent.name,
-            tokens: budget.total_tokens,
-            cost_usd: budget.estimated_cost_usd
+        const request = {
+          model: agent.model,
+          system: systemPrompt,
+          messages,
+          tools: toolDefs.length > 0 ? toolDefs : void 0
+        };
+        logger.debug({ agent: agent.name, model: agent.model }, "LLM request");
+        this.events.emit({
+          type: "llm:request",
+          agent_name: agent.name,
+          request
+        });
+        const response = await TuttiTracer.llmCall(
+          agent.model ?? "unknown",
+          () => agent.streaming ? this.streamToResponse(agent.name, request) : this.provider.chat(request)
+        );
+        logger.debug(
+          { agent: agent.name, stopReason: response.stop_reason, usage: response.usage },
+          "LLM response"
+        );
+        this.events.emit({
+          type: "llm:response",
+          agent_name: agent.name,
+          response
+        });
+        totalUsage.input_tokens += response.usage.input_tokens;
+        totalUsage.output_tokens += response.usage.output_tokens;
+        if (budget) {
+          budget.add(response.usage.input_tokens, response.usage.output_tokens);
+          const status = budget.check();
+          if (status === "warning") {
+            logger.warn(
+              { agent: agent.name, tokens: budget.total_tokens, cost_usd: budget.estimated_cost_usd },
+              "Approaching token budget limit"
+            );
+            this.events.emit({
+              type: "budget:warning",
+              agent_name: agent.name,
+              tokens: budget.total_tokens,
+              cost_usd: budget.estimated_cost_usd
+            });
+          } else if (status === "exceeded") {
+            logger.warn(
+              { agent: agent.name, tokens: budget.total_tokens, cost_usd: budget.estimated_cost_usd },
+              "Token budget exceeded"
+            );
+            this.events.emit({
+              type: "budget:exceeded",
+              agent_name: agent.name,
+              tokens: budget.total_tokens,
+              cost_usd: budget.estimated_cost_usd
+            });
+            messages.push({ role: "assistant", content: response.content });
+            break;
+          }
+        }
+        messages.push({ role: "assistant", content: response.content });
+        this.events.emit({
+          type: "turn:end",
+          agent_name: agent.name,
+          session_id: session.id,
+          turn: turns
+        });
+        if (response.stop_reason !== "tool_use") {
+          break;
+        }
+        const toolUseBlocks = response.content.filter(
+          (b) => b.type === "tool_use"
+        );
+        totalToolCalls += toolUseBlocks.length;
+        if (totalToolCalls > maxToolCalls) {
+          messages.push({
+            role: "user",
+            content: toolUseBlocks.map((block) => ({
+              type: "tool_result",
+              tool_use_id: block.id,
+              content: `Tool call rate limit exceeded: ${totalToolCalls} calls (max: ${maxToolCalls})`,
+              is_error: true
+            }))
           });
-          messages.push({ role: "assistant", content: response.content });
           break;
         }
+        const toolTimeoutMs = agent.tool_timeout_ms ?? DEFAULT_TOOL_TIMEOUT_MS;
+        const toolContext = {
+          session_id: session.id,
+          agent_name: agent.name
+        };
+        if (memCfg?.enabled && this.semanticMemory) {
+          const sm = this.semanticMemory;
+          const agentName = agent.name;
+          toolContext.memory = {
+            remember: async (content, metadata = {}) => {
+              await sm.add({ agent_name: agentName, content, metadata });
+            },
+            recall: async (query, limit) => {
+              const entries = await sm.search(query, agentName, limit);
+              return entries.map((e) => ({ id: e.id, content: e.content }));
+            },
+            forget: async (id) => {
+              await sm.delete(id);
+            }
+          };
+        }
+        const toolResults = await Promise.all(
+          toolUseBlocks.map(
+            (block) => this.executeTool(allTools, block, toolContext, toolTimeoutMs)
+          )
+        );
+        messages.push({ role: "user", content: toolResults });
       }
-      messages.push({ role: "assistant", content: response.content });
+      this.sessions.update(session.id, messages);
+      const lastAssistant = messages.filter((m) => m.role === "assistant").at(-1);
+      const output = extractText(lastAssistant?.content);
+      logger.info(
+        { agent: agent.name, session: session.id, turns, usage: totalUsage },
+        "Agent finished"
+      );
       this.events.emit({
-        type: "turn:end",
+        type: "agent:end",
         agent_name: agent.name,
-        session_id: session.id,
-        turn: turns
+        session_id: session.id
       });
-      if (response.stop_reason !== "tool_use") {
-        break;
-      }
-      const toolUseBlocks = response.content.filter(
-        (b) => b.type === "tool_use"
-      );
-      totalToolCalls += toolUseBlocks.length;
-      if (totalToolCalls > maxToolCalls) {
-        messages.push({
-          role: "user",
-          content: toolUseBlocks.map((block) => ({
-            type: "tool_result",
-            tool_use_id: block.id,
-            content: `Tool call rate limit exceeded: ${totalToolCalls} calls (max: ${maxToolCalls})`,
-            is_error: true
-          }))
-        });
-        break;
-      }
-      const toolTimeoutMs = agent.tool_timeout_ms ?? DEFAULT_TOOL_TIMEOUT_MS;
-      const toolContext = {
+      return {
         session_id: session.id,
-        agent_name: agent.name
+        output,
+        messages,
+        turns,
+        usage: totalUsage
       };
-      if (memCfg?.enabled && this.semanticMemory) {
-        const sm = this.semanticMemory;
-        const agentName = agent.name;
-        toolContext.memory = {
-          remember: async (content, metadata = {}) => {
-            await sm.add({ agent_name: agentName, content, metadata });
-          },
-          recall: async (query, limit) => {
-            const entries = await sm.search(query, agentName, limit);
-            return entries.map((e) => ({ id: e.id, content: e.content }));
-          },
-          forget: async (id) => {
-            await sm.delete(id);
-          }
-        };
-      }
-      const toolResults = await Promise.all(
-        toolUseBlocks.map(
-          (block) => this.executeTool(allTools, block, toolContext, toolTimeoutMs)
-        )
-      );
-      messages.push({ role: "user", content: toolResults });
-    }
-    this.sessions.update(session.id, messages);
-    const lastAssistant = messages.filter((m) => m.role === "assistant").at(-1);
-    const output = extractText(lastAssistant?.content);
-    this.events.emit({
-      type: "agent:end",
-      agent_name: agent.name,
-      session_id: session.id
     });
-    return {
-      session_id: session.id,
-      output,
-      messages,
-      turns,
-      usage: totalUsage
-    };
   }
   async executeWithTimeout(fn, timeoutMs, toolName) {
     return Promise.race([
@@ -316,6 +444,38 @@ Increase tool_timeout_ms in your agent config, or check if the tool is hanging.`
       )
     ]);
   }
+  async streamToResponse(agentName, request) {
+    const content = [];
+    let textBuffer = "";
+    let usage = { input_tokens: 0, output_tokens: 0 };
+    let stopReason = "end_turn";
+    for await (const chunk of this.provider.stream(request)) {
+      if (chunk.type === "text" && chunk.text) {
+        textBuffer += chunk.text;
+        this.events.emit({
+          type: "token:stream",
+          agent_name: agentName,
+          text: chunk.text
+        });
+      }
+      if (chunk.type === "tool_use" && chunk.tool) {
+        content.push({
+          type: "tool_use",
+          id: chunk.tool.id,
+          name: chunk.tool.name,
+          input: chunk.tool.input
+        });
+      }
+      if (chunk.type === "usage") {
+        if (chunk.usage) usage = chunk.usage;
+        if (chunk.stop_reason) stopReason = chunk.stop_reason;
+      }
+    }
+    if (textBuffer) {
+      content.unshift({ type: "text", text: textBuffer });
+    }
+    return { id: "", content, stop_reason: stopReason, usage };
+  }
   async executeTool(tools, block, context, timeoutMs) {
     const tool = tools.find((t) => t.name === block.name);
     if (!tool) {
@@ -327,55 +487,64 @@ Increase tool_timeout_ms in your agent config, or check if the tool is hanging.`
         is_error: true
       };
     }
-    this.events.emit({
-      type: "tool:start",
-      agent_name: context.agent_name,
-      tool_name: block.name,
-      input: block.input
-    });
-    try {
-      const parsed = tool.parameters.parse(block.input);
-      const result = await this.executeWithTimeout(
-        () => tool.execute(parsed, context),
-        timeoutMs,
-        block.name
-      );
+    return TuttiTracer.toolCall(block.name, async () => {
+      logger.debug({ tool: block.name, input: block.input }, "Tool called");
       this.events.emit({
-        type: "tool:end",
+        type: "tool:start",
         agent_name: context.agent_name,
         tool_name: block.name,
-        result
+        input: block.input
       });
-      const scan = PromptGuard.scan(result.content);
-      if (!scan.safe) {
+      try {
+        const parsed = tool.parameters.parse(block.input);
+        const result = await this.executeWithTimeout(
+          () => tool.execute(parsed, context),
+          timeoutMs,
+          block.name
+        );
+        logger.debug({ tool: block.name, result: result.content }, "Tool completed");
+        this.events.emit({
+          type: "tool:end",
+          agent_name: context.agent_name,
+          tool_name: block.name,
+          result
+        });
+        const scan = PromptGuard.scan(result.content);
+        if (!scan.safe) {
+          logger.warn(
+            { tool: block.name, patterns: scan.found },
+            "Potential prompt injection detected in tool output"
+          );
+          this.events.emit({
+            type: "security:injection_detected",
+            agent_name: context.agent_name,
+            tool_name: block.name,
+            patterns: scan.found
+          });
+        }
+        return {
+          type: "tool_result",
+          tool_use_id: block.id,
+          content: PromptGuard.wrap(block.name, result.content),
+          is_error: result.is_error
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error({ error: message, tool: block.name }, "Tool failed");
         this.events.emit({
-          type: "security:injection_detected",
+          type: "tool:error",
           agent_name: context.agent_name,
           tool_name: block.name,
-          patterns: scan.found
+          error: error instanceof Error ? error : new Error(message)
         });
+        return {
+          type: "tool_result",
+          tool_use_id: block.id,
+          content: SecretsManager.redact(`Tool execution error: ${message}`),
+          is_error: true
+        };
       }
-      return {
-        type: "tool_result",
-        tool_use_id: block.id,
-        content: PromptGuard.wrap(block.name, result.content),
-        is_error: result.is_error
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.events.emit({
-        type: "tool:error",
-        agent_name: context.agent_name,
-        tool_name: block.name,
-        error: error instanceof Error ? error : new Error(message)
-      });
-      return {
-        type: "tool_result",
-        tool_use_id: block.id,
-        content: SecretsManager.redact(`Tool execution error: ${message}`),
-        is_error: true
-      };
-    }
+    });
   }
 };
 function toolToDefinition(tool) {
@@ -509,13 +678,14 @@ var PostgresSessionStore = class {
         session.updated_at
       ]
     ).catch((err) => {
-      console.error(
-        `[tutti] Failed to persist session ${session.id} to Postgres: ${err instanceof Error ? err.message : err}`
+      logger.error(
+        { error: err instanceof Error ? err.message : String(err), session: session.id },
+        "Failed to persist session to Postgres"
       );
     });
     return session;
   }
-  get(id) {
+  get(_id) {
     return void 0;
   }
   /**
@@ -545,8 +715,9 @@ var PostgresSessionStore = class {
          WHERE id = $2`,
       [JSON.stringify(messages), id]
     ).catch((err) => {
-      console.error(
-        `[tutti] Failed to update session ${id} in Postgres: ${err instanceof Error ? err.message : err}`
+      logger.error(
+        { error: err instanceof Error ? err.message : String(err), session: id },
+        "Failed to update session in Postgres"
       );
     });
   }
@@ -616,8 +787,9 @@ var PermissionGuard = class {
       (p) => p === "shell" || p === "filesystem"
     );
     if (dangerous.length > 0) {
-      console.warn(
-        "[tutti] Warning: voice " + voice.name + " has elevated permissions: " + dangerous.join(", ")
+      logger.warn(
+        { voice: voice.name, permissions: dangerous },
+        "Voice has elevated permissions"
       );
     }
   }
@@ -641,6 +813,10 @@ var TuttiRuntime = class _TuttiRuntime {
       this._sessions,
       this.semanticMemory
     );
+    if (score.telemetry) {
+      initTelemetry(score.telemetry);
+    }
+    logger.info({ score: score.name, agents: Object.keys(score.agents) }, "Runtime initialized");
   }
   /**
    * Create a runtime with async initialization (required for Postgres).
@@ -847,9 +1023,15 @@ var AgentSchema = z2.object({
   max_tool_calls: z2.number().int().positive("max_tool_calls must be a positive number").optional(),
   tool_timeout_ms: z2.number().int().positive("tool_timeout_ms must be a positive number").optional(),
   budget: BudgetSchema.optional(),
+  streaming: z2.boolean().optional(),
   delegates: z2.array(z2.string()).optional(),
   role: z2.enum(["orchestrator", "specialist"]).optional()
 }).passthrough();
+var TelemetrySchema = z2.object({
+  enabled: z2.boolean(),
+  endpoint: z2.string().url("telemetry.endpoint must be a valid URL").optional(),
+  headers: z2.record(z2.string(), z2.string()).optional()
+}).strict();
 var ScoreSchema = z2.object({
   provider: z2.object({ chat: z2.function() }).passthrough().refine((p) => typeof p.chat === "function", {
     message: "provider must have a chat() method \u2014 did you forget to pass a provider instance?"
@@ -861,7 +1043,8 @@ var ScoreSchema = z2.object({
   name: z2.string().optional(),
   description: z2.string().optional(),
   default_model: z2.string().optional(),
-  entry: z2.string().optional()
+  entry: z2.string().optional(),
+  telemetry: TelemetrySchema.optional()
 }).passthrough();
 function validateScore(config) {
   const result = ScoreSchema.safeParse(config);
@@ -958,6 +1141,7 @@ var AnthropicProvider = class {
       });
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
+      logger.error({ error: msg, provider: "anthropic" }, "Provider request failed");
       throw new Error(
         `Anthropic API error: ${msg}
 Check that ANTHROPIC_API_KEY is set correctly in your .env file.`
@@ -987,6 +1171,90 @@ Check that ANTHROPIC_API_KEY is set correctly in your .env file.`
       }
     };
   }
+  async *stream(request) {
+    if (!request.model) {
+      throw new Error(
+        "AnthropicProvider requires a model on ChatRequest.\nSet model on the agent or default_model on the score."
+      );
+    }
+    let raw;
+    try {
+      raw = await this.client.messages.create({
+        model: request.model,
+        max_tokens: request.max_tokens ?? 4096,
+        system: request.system ?? "",
+        messages: request.messages.map((msg) => ({
+          role: msg.role,
+          content: msg.content
+        })),
+        tools: request.tools?.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          input_schema: tool.input_schema
+        })),
+        ...request.temperature != null && { temperature: request.temperature },
+        ...request.stop_sequences && { stop_sequences: request.stop_sequences },
+        stream: true
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error({ error: msg, provider: "anthropic" }, "Provider stream failed");
+      throw new Error(
+        `Anthropic API error: ${msg}
+Check that ANTHROPIC_API_KEY is set correctly in your .env file.`
+      );
+    }
+    const toolBlocks = /* @__PURE__ */ new Map();
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let stopReason = "end_turn";
+    for await (const event of raw) {
+      if (event.type === "message_start") {
+        inputTokens = event.message.usage.input_tokens;
+      }
+      if (event.type === "content_block_start") {
+        if (event.content_block.type === "tool_use") {
+          toolBlocks.set(event.index, {
+            id: event.content_block.id,
+            name: event.content_block.name,
+            json: ""
+          });
+        }
+      }
+      if (event.type === "content_block_delta") {
+        if (event.delta.type === "text_delta") {
+          yield { type: "text", text: event.delta.text };
+        }
+        if (event.delta.type === "input_json_delta") {
+          const block = toolBlocks.get(event.index);
+          if (block) block.json += event.delta.partial_json;
+        }
+      }
+      if (event.type === "content_block_stop") {
+        const block = toolBlocks.get(event.index);
+        if (block) {
+          yield {
+            type: "tool_use",
+            tool: {
+              id: block.id,
+              name: block.name,
+              input: block.json ? JSON.parse(block.json) : {}
+            }
+          };
+          toolBlocks.delete(event.index);
+        }
+      }
+      if (event.type === "message_delta") {
+        outputTokens = event.usage.output_tokens;
+        stopReason = event.delta.stop_reason ?? "end_turn";
+      }
+    }
+    yield {
+      type: "usage",
+      usage: { input_tokens: inputTokens, output_tokens: outputTokens },
+      stop_reason: stopReason
+    };
+  }
 };
 
 // src/providers/openai.ts
@@ -1070,6 +1338,7 @@ var OpenAIProvider = class {
       });
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
+      logger.error({ error: msg, provider: "openai" }, "Provider request failed");
       throw new Error(
         `OpenAI API error: ${msg}
 Check that OPENAI_API_KEY is set correctly in your .env file.`
@@ -1114,6 +1383,112 @@ Check that OPENAI_API_KEY is set correctly in your .env file.`
       }
     };
   }
+  async *stream(request) {
+    if (!request.model) {
+      throw new Error(
+        "OpenAIProvider requires a model on ChatRequest.\nSet model on the agent or default_model on the score."
+      );
+    }
+    const messages = [];
+    if (request.system) {
+      messages.push({ role: "system", content: request.system });
+    }
+    for (const msg of request.messages) {
+      if (msg.role === "user") {
+        if (typeof msg.content === "string") {
+          messages.push({ role: "user", content: msg.content });
+        } else {
+          for (const block of msg.content) {
+            if (block.type === "tool_result") {
+              messages.push({ role: "tool", tool_call_id: block.tool_use_id, content: block.content });
+            }
+          }
+        }
+      } else if (msg.role === "assistant") {
+        if (typeof msg.content === "string") {
+          messages.push({ role: "assistant", content: msg.content });
+        } else {
+          const textParts = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+          const toolCalls2 = msg.content.filter((b) => b.type === "tool_use").map((b) => {
+            const block = b;
+            return { id: block.id, type: "function", function: { name: block.name, arguments: JSON.stringify(block.input) } };
+          });
+          messages.push({ role: "assistant", content: textParts || null, ...toolCalls2.length > 0 && { tool_calls: toolCalls2 } });
+        }
+      }
+    }
+    const tools = request.tools?.map((tool) => ({
+      type: "function",
+      function: { name: tool.name, description: tool.description, parameters: tool.input_schema }
+    }));
+    let raw;
+    try {
+      raw = await this.client.chat.completions.create({
+        model: request.model,
+        messages,
+        tools: tools && tools.length > 0 ? tools : void 0,
+        max_tokens: request.max_tokens,
+        temperature: request.temperature,
+        stop: request.stop_sequences,
+        stream: true,
+        stream_options: { include_usage: true }
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error({ error: msg, provider: "openai" }, "Provider stream failed");
+      throw new Error(
+        `OpenAI API error: ${msg}
+Check that OPENAI_API_KEY is set correctly in your .env file.`
+      );
+    }
+    const toolCalls = /* @__PURE__ */ new Map();
+    let finishReason = "end_turn";
+    for await (const chunk of raw) {
+      const choice = chunk.choices[0];
+      if (!choice) {
+        if (chunk.usage) {
+          yield {
+            type: "usage",
+            usage: { input_tokens: chunk.usage.prompt_tokens, output_tokens: chunk.usage.completion_tokens },
+            stop_reason: finishReason
+          };
+        }
+        continue;
+      }
+      if (choice.delta.content) {
+        yield { type: "text", text: choice.delta.content };
+      }
+      if (choice.delta.tool_calls) {
+        for (const tc of choice.delta.tool_calls) {
+          if (tc.id) {
+            toolCalls.set(tc.index, { id: tc.id, name: tc.function?.name ?? "", args: "" });
+          }
+          const existing = toolCalls.get(tc.index);
+          if (existing && tc.function?.arguments) {
+            existing.args += tc.function.arguments;
+          }
+        }
+      }
+      if (choice.finish_reason) {
+        for (const tc of toolCalls.values()) {
+          yield { type: "tool_use", tool: { id: tc.id, name: tc.name, input: JSON.parse(tc.args || "{}") } };
+        }
+        switch (choice.finish_reason) {
+          case "tool_calls":
+            finishReason = "tool_use";
+            break;
+          case "length":
+            finishReason = "max_tokens";
+            break;
+          case "stop":
+            finishReason = "end_turn";
+            break;
+          default:
+            finishReason = "end_turn";
+        }
+      }
+    }
+  }
 };
 
 // src/providers/gemini.ts
@@ -1206,6 +1581,7 @@ var GeminiProvider = class {
       });
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
+      logger.error({ error: msg, provider: "gemini" }, "Provider request failed");
       throw new Error(
         `Gemini API error: ${msg}
 Check that GEMINI_API_KEY is set correctly in your .env file.`
@@ -1250,6 +1626,93 @@ Check that GEMINI_API_KEY is set correctly in your .env file.`
       }
     };
   }
+  async *stream(request) {
+    const model = request.model ?? "gemini-2.0-flash";
+    const tools = [];
+    if (request.tools && request.tools.length > 0) {
+      tools.push({
+        functionDeclarations: request.tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          parameters: convertJsonSchemaToGemini(tool.input_schema)
+        }))
+      });
+    }
+    const generativeModel = this.client.getGenerativeModel({
+      model,
+      systemInstruction: request.system,
+      tools: tools.length > 0 ? tools : void 0
+    });
+    const contents = [];
+    for (const msg of request.messages) {
+      if (msg.role === "user") {
+        if (typeof msg.content === "string") {
+          contents.push({ role: "user", parts: [{ text: msg.content }] });
+        } else {
+          const parts = [];
+          for (const block of msg.content) {
+            if (block.type === "tool_result") {
+              parts.push({ functionResponse: { name: block.tool_use_id, response: { content: block.content } } });
+            }
+          }
+          if (parts.length > 0) contents.push({ role: "user", parts });
+        }
+      } else if (msg.role === "assistant") {
+        if (typeof msg.content === "string") {
+          contents.push({ role: "model", parts: [{ text: msg.content }] });
+        } else {
+          const parts = [];
+          for (const block of msg.content) {
+            if (block.type === "text") parts.push({ text: block.text });
+            else if (block.type === "tool_use") parts.push({ functionCall: { name: block.name, args: block.input } });
+          }
+          if (parts.length > 0) contents.push({ role: "model", parts });
+        }
+      }
+    }
+    let result;
+    try {
+      result = await generativeModel.generateContentStream({
+        contents,
+        generationConfig: {
+          maxOutputTokens: request.max_tokens,
+          temperature: request.temperature,
+          stopSequences: request.stop_sequences
+        }
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error({ error: msg, provider: "gemini" }, "Provider stream failed");
+      throw new Error(
+        `Gemini API error: ${msg}
+Check that GEMINI_API_KEY is set correctly in your .env file.`
+      );
+    }
+    let hasToolCalls = false;
+    for await (const chunk of result.stream) {
+      const candidate = chunk.candidates?.[0];
+      if (!candidate) continue;
+      for (const part of candidate.content.parts) {
+        if ("text" in part && part.text) {
+          yield { type: "text", text: part.text };
+        }
+        if ("functionCall" in part && part.functionCall) {
+          hasToolCalls = true;
+          yield {
+            type: "tool_use",
+            tool: { id: part.functionCall.name, name: part.functionCall.name, input: part.functionCall.args ?? {} }
+          };
+        }
+      }
+    }
+    const response = await result.response;
+    const usage = response.usageMetadata;
+    yield {
+      type: "usage",
+      usage: { input_tokens: usage?.promptTokenCount ?? 0, output_tokens: usage?.candidatesTokenCount ?? 0 },
+      stop_reason: hasToolCalls ? "tool_use" : "end_turn"
+    };
+  }
 };
 function convertJsonSchemaToGemini(schema) {
   const type = schema.type;
@@ -1277,7 +1740,12 @@ export {
   SecretsManager,
   TokenBudget,
   TuttiRuntime,
+  TuttiTracer,
+  createLogger,
   defineScore,
+  initTelemetry,
+  logger,
+  shutdownTelemetry,
   validateScore
 };
 //# sourceMappingURL=index.js.map