@tuttiai/core 0.4.0 → 0.6.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";
 
@@ -129,14 +233,16 @@ var DEFAULT_MAX_TURNS = 10;
 var DEFAULT_MAX_TOOL_CALLS = 20;
 var DEFAULT_TOOL_TIMEOUT_MS = 3e4;
 var AgentRunner = class {
-  constructor(provider, events, sessions) {
+  constructor(provider, events, sessions, semanticMemory) {
     this.provider = provider;
     this.events = events;
     this.sessions = sessions;
+    this.semanticMemory = semanticMemory;
   }
   provider;
   events;
   sessions;
+  semanticMemory;
   async run(agent, input, session_id) {
     const session = session_id ? this.sessions.get(session_id) : this.sessions.create(agent.name);
     if (!session) {
@@ -146,123 +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
       });
-      const request = {
-        model: agent.model,
-        system: agent.system_prompt,
-        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 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
+        };
+        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",
+          () => 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 toolResults = await Promise.all(
-        toolUseBlocks.map(
-          (block) => this.executeTool(allTools, block, {
-            session_id: session.id,
-            agent_name: agent.name
-          }, 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
+      };
     });
-    return {
-      session_id: session.id,
-      output,
-      messages,
-      turns,
-      usage: totalUsage
-    };
   }
   async executeWithTimeout(fn, timeoutMs, toolName) {
     return Promise.race([
@@ -291,55 +455,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: "security:injection_detected",
+          type: "tool:end",
           agent_name: context.agent_name,
           tool_name: block.name,
-          patterns: scan.found
+          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: "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
+        };
       }
-      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) {
@@ -430,6 +603,141 @@ var InMemorySessionStore = class {
   }
 };
 
+// src/memory/postgres.ts
+import pg from "pg";
+import { randomUUID as randomUUID2 } from "crypto";
+var { Pool } = pg;
+var PostgresSessionStore = class {
+  pool;
+  constructor(connectionString) {
+    this.pool = new Pool({ connectionString });
+  }
+  /**
+   * Create the tutti_sessions table if it doesn't exist.
+   * Call this once before using the store.
+   */
+  async initialize() {
+    await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS tutti_sessions (
+        id TEXT PRIMARY KEY,
+        agent_name TEXT NOT NULL,
+        messages JSONB NOT NULL DEFAULT '[]',
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `);
+  }
+  create(agent_name) {
+    const session = {
+      id: randomUUID2(),
+      agent_name,
+      messages: [],
+      created_at: /* @__PURE__ */ new Date(),
+      updated_at: /* @__PURE__ */ new Date()
+    };
+    this.pool.query(
+      `INSERT INTO tutti_sessions (id, agent_name, messages, created_at, updated_at)
+         VALUES ($1, $2, $3, $4, $5)`,
+      [
+        session.id,
+        session.agent_name,
+        JSON.stringify(session.messages),
+        session.created_at,
+        session.updated_at
+      ]
+    ).catch((err) => {
+      logger.error(
+        { error: err instanceof Error ? err.message : String(err), session: session.id },
+        "Failed to persist session to Postgres"
+      );
+    });
+    return session;
+  }
+  get(_id) {
+    return void 0;
+  }
+  /**
+   * Async version of get() that queries Postgres directly.
+   * Use this when you need to load a session from the database.
+   */
+  async getAsync(id) {
+    const result = await this.pool.query(
+      `SELECT id, agent_name, messages, created_at, updated_at
+       FROM tutti_sessions WHERE id = $1`,
+      [id]
+    );
+    if (result.rows.length === 0) return void 0;
+    const row = result.rows[0];
+    return {
+      id: row.id,
+      agent_name: row.agent_name,
+      messages: row.messages,
+      created_at: new Date(row.created_at),
+      updated_at: new Date(row.updated_at)
+    };
+  }
+  update(id, messages) {
+    this.pool.query(
+      `UPDATE tutti_sessions
+         SET messages = $1, updated_at = NOW()
+         WHERE id = $2`,
+      [JSON.stringify(messages), id]
+    ).catch((err) => {
+      logger.error(
+        { error: err instanceof Error ? err.message : String(err), session: id },
+        "Failed to update session in Postgres"
+      );
+    });
+  }
+  /** Close the connection pool. Call on shutdown. */
+  async close() {
+    await this.pool.end();
+  }
+};
+
+// src/memory/in-memory-semantic.ts
+import { randomUUID as randomUUID3 } from "crypto";
+var InMemorySemanticStore = class {
+  entries = [];
+  async add(entry) {
+    const full = {
+      ...entry,
+      id: randomUUID3(),
+      created_at: /* @__PURE__ */ new Date()
+    };
+    this.entries.push(full);
+    return full;
+  }
+  async search(query, agent_name, limit = 5) {
+    const queryTokens = tokenize(query);
+    if (queryTokens.size === 0) return [];
+    const agentEntries = this.entries.filter(
+      (e) => e.agent_name === agent_name
+    );
+    const scored = agentEntries.map((entry) => {
+      const entryTokens = tokenize(entry.content);
+      let overlap = 0;
+      for (const token of queryTokens) {
+        if (entryTokens.has(token)) overlap++;
+      }
+      const score = overlap / queryTokens.size;
+      return { entry, score };
+    });
+    return scored.filter((s) => s.score > 0).sort((a, b) => b.score - a.score).slice(0, limit).map((s) => s.entry);
+  }
+  async delete(id) {
+    this.entries = this.entries.filter((e) => e.id !== id);
+  }
+  async clear(agent_name) {
+    this.entries = this.entries.filter((e) => e.agent_name !== agent_name);
+  }
+};
+function tokenize(text) {
+  return new Set(
+    text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 1)
+  );
+}
+
 // src/permission-guard.ts
 var PermissionGuard = class {
   static check(voice, granted) {
@@ -447,24 +755,66 @@ 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"
       );
     }
   }
 };
 
 // src/runtime.ts
-var TuttiRuntime = class {
+var TuttiRuntime = class _TuttiRuntime {
   events;
+  semanticMemory;
   _sessions;
   _runner;
   _score;
   constructor(score) {
     this._score = score;
     this.events = new EventBus();
-    this._sessions = new InMemorySessionStore();
-    this._runner = new AgentRunner(score.provider, this.events, this._sessions);
+    this._sessions = _TuttiRuntime.createStore(score);
+    this.semanticMemory = new InMemorySemanticStore();
+    this._runner = new AgentRunner(
+      score.provider,
+      this.events,
+      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).
+   * Prefer this over `new TuttiRuntime()` when using a database-backed store.
+   */
+  static async create(score) {
+    const runtime = new _TuttiRuntime(score);
+    if (runtime._sessions instanceof PostgresSessionStore) {
+      await runtime._sessions.initialize();
+    }
+    return runtime;
+  }
+  static createStore(score) {
+    const memory = score.memory;
+    if (!memory || memory.provider === "in-memory") {
+      return new InMemorySessionStore();
+    }
+    if (memory.provider === "postgres") {
+      const url = memory.url ?? process.env.DATABASE_URL;
+      if (!url) {
+        throw new Error(
+          "PostgreSQL session store requires a connection URL.\nSet memory.url in your score, or DATABASE_URL in your .env file."
+        );
+      }
+      return new PostgresSessionStore(url);
+    }
+    throw new Error(
+      `Unsupported memory provider: "${memory.provider}".
+Supported: "in-memory", "postgres"`
+    );
   }
   /** The score configuration this runtime was created with. */
   get score() {
@@ -644,6 +994,11 @@ var AgentSchema = z2.object({
   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?"
@@ -655,7 +1010,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);
@@ -752,6 +1108,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.`
@@ -864,6 +1221,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.`
@@ -1000,6 +1358,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.`
@@ -1061,15 +1420,22 @@ export {
   AnthropicProvider,
   EventBus,
   GeminiProvider,
+  InMemorySemanticStore,
   InMemorySessionStore,
   OpenAIProvider,
   PermissionGuard,
+  PostgresSessionStore,
   PromptGuard,
   ScoreLoader,
   SecretsManager,
   TokenBudget,
   TuttiRuntime,
+  TuttiTracer,
+  createLogger,
   defineScore,
+  initTelemetry,
+  logger,
+  shutdownTelemetry,
   validateScore
 };
 //# sourceMappingURL=index.js.map