@kb-labs/agent-tracing 0.2.0

package/dist/index.js

@@ -0,0 +1,873 @@
+import { appendFileSync, readFileSync, promises, mkdirSync, statSync } from 'fs';
+import * as path3 from 'path';
+import path3__default from 'path';
+import * as fs2 from 'fs/promises';
+
+// src/incremental-trace-writer.ts
+
+// src/privacy-redactor.ts
+var DEFAULT_SECRET_PATTERNS = [
+  // API keys
+  /sk-[A-Za-z0-9]{20,}/g,
+  // OpenAI API keys
+  /sk_live_[A-Za-z0-9]{24,}/g,
+  // Stripe API keys
+  /ghp_[A-Za-z0-9]{36}/g,
+  // GitHub personal access tokens
+  // Authentication tokens
+  /Bearer\s+[A-Za-z0-9\-._~+/]+=*/g,
+  /token[=:]\s*[A-Za-z0-9\-._~+/]+=*/gi,
+  // Passwords
+  /password[=:]\s*["']?[^"'\s]+["']?/gi,
+  /passwd[=:]\s*["']?[^"'\s]+["']?/gi,
+  /pwd[=:]\s*["']?[^"'\s]+["']?/gi,
+  // Connection strings
+  /mongodb(\+srv)?:\/\/[^@]+@[^\s]+/g,
+  /postgres(ql)?:\/\/[^@]+@[^\s]+/g,
+  /mysql:\/\/[^@]+@[^\s]+/g,
+  // Email addresses (PII)
+  /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g
+  // Note: Generic long alphanumeric pattern removed to avoid false positives
+  // (would match file hashes, UUIDs, legitimate data)
+  // Credit card numbers removed - too many false positives
+];
+function redactSecretsFromString(str, patterns = DEFAULT_SECRET_PATTERNS) {
+  let result = str;
+  for (const pattern of patterns) {
+    result = result.replace(pattern, "[REDACTED]");
+  }
+  return result;
+}
+function redactPaths(str, replacements) {
+  let result = str;
+  for (const [absolute, relative] of Object.entries(replacements)) {
+    result = result.replace(new RegExp(absolute.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), relative);
+  }
+  return result;
+}
+function redactValue(value, config, depth = 0) {
+  if (depth > 10) {
+    return "[REDACTED:TOO_DEEP]";
+  }
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value === "string") {
+    let result = value;
+    if (config.redactSecrets) {
+      const patterns = config.secretPatterns.map((p) => new RegExp(p, "g"));
+      result = redactSecretsFromString(result, [...DEFAULT_SECRET_PATTERNS, ...patterns]);
+    }
+    if (config.redactPaths) {
+      result = redactPaths(result, config.pathReplacements);
+    }
+    return result === value ? value : result;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    let changed = false;
+    const result = value.map((item) => {
+      const redacted = redactValue(item, config, depth + 1);
+      if (redacted !== item) {
+        changed = true;
+      }
+      return redacted;
+    });
+    return changed ? result : value;
+  }
+  if (typeof value === "object") {
+    let changed = false;
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      const redacted = redactValue(val, config, depth + 1);
+      result[key] = redacted;
+      if (redacted !== val) {
+        changed = true;
+      }
+    }
+    return changed ? result : value;
+  }
+  return value;
+}
+function redactTraceEvent(event, config) {
+  if (!config.redactSecrets && !config.redactPaths) {
+    return event;
+  }
+  const eventStr = JSON.stringify(event);
+  const MAX_STRING_SIZE = 1e5;
+  const testStr = eventStr.length > MAX_STRING_SIZE ? eventStr.substring(0, MAX_STRING_SIZE) : eventStr;
+  let needsRedaction = false;
+  if (config.redactSecrets) {
+    const patterns = config.secretPatterns.map((p) => new RegExp(p, "g"));
+    needsRedaction = [...DEFAULT_SECRET_PATTERNS, ...patterns].some((p) => p.test(testStr));
+  }
+  if (!needsRedaction && config.redactPaths) {
+    needsRedaction = Object.keys(config.pathReplacements).some((path4) => testStr.includes(path4));
+  }
+  if (!needsRedaction) {
+    return event;
+  }
+  return redactValue(event, config, 0);
+}
+function createDefaultPrivacyConfig() {
+  return {
+    redactSecrets: true,
+    redactPaths: true,
+    secretPatterns: [],
+    pathReplacements: {
+      "/Users": "~",
+      "/home": "~",
+      "C:\\Users": "~"
+    }
+  };
+}
+
+// src/incremental-trace-writer.ts
+var DEFAULT_TRACE_CONFIG = {
+  version: "1.0.0",
+  enabled: true,
+  level: "detailed",
+  incremental: {
+    enabled: true,
+    flushIntervalMs: 100,
+    maxBufferSize: 10,
+    format: "ndjson"
+  },
+  capture: {
+    prompts: true,
+    toolOutputs: true,
+    memorySnapshots: true,
+    decisions: true
+  },
+  retention: {
+    maxTraces: 30,
+    maxDays: 30,
+    cleanupOnFinalize: true,
+    archiveOlderThan: 7,
+    compressArchived: true
+  },
+  privacy: {
+    redactSecrets: true,
+    redactPaths: true,
+    secretPatterns: [
+      "sk-[a-zA-Z0-9]{20,}",
+      // OpenAI API keys
+      "Bearer\\s+[a-zA-Z0-9_-]+",
+      // Bearer tokens
+      `password['"]?\\s*[:=]\\s*['"][^'"]+(['"]})`,
+      // Passwords
+      `api[_-]?key['"]?\\s*[:=]\\s*['"][^'"]+['"]`
+      // Generic API keys
+    ],
+    pathReplacements: {
+      "/Users/": "~/",
+      "/home/": "~/",
+      "\\Users\\": "~\\"
+    }
+  },
+  storage: {
+    path: ".kb/traces/incremental",
+    indexPath: ".kb/traces/incremental"
+  }
+};
+var IncrementalTraceWriter = class {
+  seq = 0;
+  filepath;
+  indexPath;
+  config;
+  taskId;
+  startTime;
+  constructor(taskId, config = {}, outputDir) {
+    this.taskId = taskId;
+    this.config = { ...DEFAULT_TRACE_CONFIG, ...config };
+    this.startTime = (/* @__PURE__ */ new Date()).toISOString();
+    const dir = outputDir || this.config.storage.path;
+    this.filepath = path3__default.join(dir, `${taskId}.ndjson`);
+    this.indexPath = path3__default.join(dir, `${taskId}-index.json`);
+    this.ensureDirectoryExists(dir);
+  }
+  /**
+   * Record a trace entry — writes synchronously to disk.
+   *
+   * Every call = one appendFileSync. No buffering, no async, no lost events.
+   * If the agent crashes on iteration 5, you have all events from iterations 1-5.
+   */
+  trace(entry) {
+    try {
+      const seq = ++this.seq;
+      const timestamp = entry.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+      const fullEntry = {
+        ...entry,
+        seq,
+        timestamp
+      };
+      const redacted = this.redact(fullEntry);
+      appendFileSync(this.filepath, JSON.stringify(redacted) + "\n", "utf-8");
+    } catch (error) {
+      console.error("[IncrementalTraceWriter] trace() error:", error);
+    }
+  }
+  /**
+   * Get all trace entries (reads from NDJSON file to avoid memory leak)
+   * Returns TraceEntry[] for backward compatibility, but actual format is DetailedTraceEntry[]
+   */
+  getEntries() {
+    try {
+      const content = readFileSync(this.filepath, "utf-8");
+      const lines = content.split("\n").filter(Boolean);
+      return lines.map((line) => JSON.parse(line));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Save trace to file (backward compat — no-op, already written synchronously)
+   */
+  async save(_filePath) {
+  }
+  /**
+   * Clear all entries
+   */
+  clear() {
+    this.seq = 0;
+  }
+  /**
+   * Finalize trace (generate index, cleanup old traces)
+   */
+  async finalize() {
+    try {
+      await this.createIndex();
+      if (this.config.retention.cleanupOnFinalize) {
+        await this.cleanupOldTraces();
+      }
+    } catch (error) {
+      console.error("[IncrementalTraceWriter] finalize() error:", error);
+    }
+  }
+  /**
+   * Create index file for fast CLI queries
+   */
+  async createIndex() {
+    try {
+      const entries = this.getEntries();
+      if (entries.length === 0) {
+        console.warn("[IncrementalTraceWriter] No entries to index");
+        return;
+      }
+      const stats = this.calculateIndexStatistics(entries);
+      const index = {
+        version: "1.0.0",
+        taskId: this.taskId,
+        createdAt: this.startTime,
+        finalizedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        summary: {
+          totalEvents: entries.length,
+          iterations: stats.iterations.size,
+          status: stats.errors > 0 ? "failed" : "success",
+          eventCounts: stats.eventCounts
+        },
+        timing: {
+          startedAt: this.startTime,
+          completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          totalDurationMs: Date.now() - new Date(this.startTime).getTime()
+        },
+        cost: {
+          totalCost: stats.totalCost,
+          currency: "USD"
+        },
+        errors: stats.errors,
+        memory: stats.memory,
+        iterations: Array.from(stats.iterations.entries()).map(([iteration, iterStats]) => ({ iteration, ...iterStats })).sort((a, b) => a.iteration - b.iteration)
+      };
+      const indexDir = path3__default.dirname(this.indexPath);
+      this.ensureDirectoryExists(indexDir);
+      await promises.writeFile(this.indexPath, JSON.stringify(index, null, 2), "utf-8");
+    } catch (error) {
+      console.error("[IncrementalTraceWriter] createIndex() error:", error);
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Private Methods
+  // ═══════════════════════════════════════════════════════════════════════
+  /**
+   * Cleanup old traces (keep last N traces)
+   */
+  async cleanupOldTraces() {
+    try {
+      const dir = path3__default.dirname(this.filepath);
+      const files = await promises.readdir(dir);
+      const traceFiles = files.filter((f) => f.endsWith(".ndjson"));
+      if (traceFiles.length <= this.config.retention.maxTraces) {
+        return;
+      }
+      const filesWithStats = await Promise.all(
+        traceFiles.map(async (file) => {
+          const filepath = path3__default.join(dir, file);
+          const stats = await promises.stat(filepath);
+          return { file, mtime: stats.mtime.getTime(), filepath };
+        })
+      );
+      filesWithStats.sort((a, b) => b.mtime - a.mtime);
+      const toDelete = filesWithStats.slice(this.config.retention.maxTraces);
+      await Promise.allSettled(
+        toDelete.map(async ({ file, filepath }) => {
+          try {
+            await promises.unlink(filepath);
+            const indexFile = filepath.replace(".ndjson", "-index.json");
+            try {
+              await promises.unlink(indexFile);
+            } catch {
+            }
+          } catch (error) {
+            console.error(`[IncrementalTraceWriter] Failed to delete ${file}:`, error);
+          }
+        })
+      );
+      if (toDelete.length > 0) {
+        console.log(
+          `[IncrementalTraceWriter] Cleaned up ${toDelete.length} old traces (kept last ${this.config.retention.maxTraces})`
+        );
+      }
+    } catch (error) {
+      console.error("[IncrementalTraceWriter] cleanupOldTraces() error:", error);
+    }
+  }
+  /**
+   * Redact sensitive data from entry using optimized privacy-redactor
+   *
+   * Uses shallow clone optimization - only clones objects that need redaction,
+   * not the entire trace event tree. Returns original if no secrets found.
+   */
+  redact(entry) {
+    if (!this.config.privacy.redactSecrets && !this.config.privacy.redactPaths) {
+      return entry;
+    }
+    try {
+      return redactTraceEvent(entry, this.config.privacy);
+    } catch (error) {
+      console.warn("[IncrementalTraceWriter] redact() error:", error);
+      return entry;
+    }
+  }
+  /**
+   * Calculate index statistics from trace entries
+   */
+  calculateIndexStatistics(entries) {
+    const eventCounts = {};
+    const iterations = /* @__PURE__ */ new Map();
+    let totalCost = 0;
+    let errors = 0;
+    let totalFactsAdded = 0;
+    let totalArchiveStores = 0;
+    let summarizationRuns = 0;
+    let compressionRatioSum = 0;
+    let newFactRateSum = 0;
+    let lastFactSheetSize = 0;
+    let lastFactSheetTokens = 0;
+    let lastArchiveEntries = 0;
+    let lastArchiveUniqueFiles = 0;
+    for (const entry of entries) {
+      eventCounts[entry.type] = (eventCounts[entry.type] || 0) + 1;
+      if (entry.iteration !== void 0) {
+        if (!iterations.has(entry.iteration)) {
+          iterations.set(entry.iteration, { eventCount: 0, llmCalls: 0, toolCalls: 0 });
+        }
+        const iter = iterations.get(entry.iteration);
+        iter.eventCount++;
+        if (entry.type === "llm:end") {
+          iter.llmCalls++;
+          if ("cost" in entry && entry.cost) {
+            totalCost += entry.cost.totalCost || 0;
+          }
+        }
+        if (entry.type === "tool:end") {
+          iter.toolCalls++;
+        }
+      }
+      if (entry.type === "error:captured") {
+        errors++;
+      }
+      if (entry.type === "memory:fact_added") {
+        totalFactsAdded++;
+        if (entry.factSheetStats) {
+          lastFactSheetSize = entry.factSheetStats.totalFacts || 0;
+          lastFactSheetTokens = entry.factSheetStats.estimatedTokens || 0;
+        }
+      }
+      if (entry.type === "memory:archive_store") {
+        totalArchiveStores++;
+        if (entry.archiveStats) {
+          lastArchiveEntries = entry.archiveStats.totalEntries || 0;
+          lastArchiveUniqueFiles = entry.archiveStats.uniqueFiles || 0;
+        }
+      }
+      if (entry.type === "memory:summarization_result") {
+        summarizationRuns++;
+        if (entry.efficiency) {
+          compressionRatioSum += entry.efficiency.compressionRatio || 0;
+          newFactRateSum += entry.efficiency.newFactRate || 0;
+        }
+      }
+    }
+    const hasMemoryEvents = totalFactsAdded > 0 || totalArchiveStores > 0 || summarizationRuns > 0;
+    return {
+      eventCounts,
+      iterations,
+      totalCost,
+      errors,
+      memory: hasMemoryEvents ? {
+        totalFactsAdded,
+        totalArchiveStores,
+        summarizationRuns,
+        avgCompressionRatio: summarizationRuns > 0 ? compressionRatioSum / summarizationRuns : 0,
+        avgNewFactRate: summarizationRuns > 0 ? newFactRateSum / summarizationRuns : 0,
+        finalFactSheetSize: lastFactSheetSize,
+        finalFactSheetTokens: lastFactSheetTokens,
+        finalArchiveEntries: lastArchiveEntries,
+        finalArchiveUniqueFiles: lastArchiveUniqueFiles
+      } : void 0
+    };
+  }
+  /**
+   * Ensure directory exists
+   */
+  ensureDirectoryExists(dir) {
+    try {
+      mkdirSync(dir, { recursive: true });
+    } catch (error) {
+      try {
+        const stats = statSync(dir);
+        if (!stats.isDirectory()) {
+          throw new Error(`Path exists but is not a directory: ${dir}`);
+        }
+      } catch {
+        throw new Error(`Failed to create trace directory: ${dir}. Error: ${error}`);
+      }
+    }
+  }
+};
+var FileTracer = class {
+  entries = [];
+  taskId;
+  sessionId;
+  constructor(taskId, sessionId) {
+    this.taskId = taskId;
+    this.sessionId = sessionId;
+  }
+  /**
+   * Record a trace entry
+   */
+  trace(entry) {
+    this.entries.push(entry);
+  }
+  /**
+   * Get all trace entries
+   */
+  getEntries() {
+    return this.entries;
+  }
+  /**
+   * Save trace to file
+   */
+  async save(filePath) {
+    const dir = path3.dirname(filePath);
+    await fs2.mkdir(dir, { recursive: true });
+    const traceData = {
+      taskId: this.taskId,
+      sessionId: this.sessionId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      totalEntries: this.entries.length,
+      entries: this.entries
+    };
+    await fs2.writeFile(filePath, JSON.stringify(traceData, null, 2), "utf-8");
+  }
+  /**
+   * Clear all entries
+   */
+  clear() {
+    this.entries = [];
+  }
+  /**
+   * Get trace summary statistics
+   */
+  getSummary() {
+    const llmCalls = this.entries.filter((e) => e.type === "llm:call");
+    const toolCalls = this.entries.filter((e) => e.type === "tool:execution");
+    const getDuration = (e) => {
+      if (e.type === "llm:call" || e.type === "tool:execution") {
+        return e.timing?.durationMs ?? 0;
+      }
+      return 0;
+    };
+    const totalDuration = this.entries.reduce((sum, e) => sum + getDuration(e), 0);
+    const llmDuration = llmCalls.reduce((sum, e) => sum + getDuration(e), 0);
+    const toolDuration = toolCalls.reduce((sum, e) => sum + getDuration(e), 0);
+    return {
+      totalEntries: this.entries.length,
+      llmCalls: llmCalls.length,
+      toolCalls: toolCalls.length,
+      totalDuration,
+      avgLLMDuration: llmCalls.length > 0 ? llmDuration / llmCalls.length : 0,
+      avgToolDuration: toolCalls.length > 0 ? toolDuration / toolCalls.length : 0
+    };
+  }
+};
+var TRACE_DIR_RELATIVE = path3__default.join(".kb", "traces", "incremental");
+var TASK_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+var MAX_FILE_SIZE_BYTES = 100 * 1024 * 1024;
+async function loadTrace(taskId, workingDir = process.cwd()) {
+  if (!taskId) {
+    return { ok: false, error: { kind: "invalid_task_id", message: "Missing required --task-id" } };
+  }
+  if (!TASK_ID_PATTERN.test(taskId)) {
+    return {
+      ok: false,
+      error: {
+        kind: "invalid_task_id",
+        message: "Task ID must contain only alphanumeric characters, hyphens, and underscores"
+      }
+    };
+  }
+  const traceDir = path3__default.join(workingDir, TRACE_DIR_RELATIVE);
+  const filePath = path3__default.join(traceDir, `${taskId}.ndjson`);
+  const resolvedFile = path3__default.resolve(filePath);
+  const resolvedDir = path3__default.resolve(traceDir);
+  if (!resolvedFile.startsWith(resolvedDir + path3__default.sep) && resolvedFile !== resolvedDir) {
+    return { ok: false, error: { kind: "invalid_task_id", message: "Path traversal detected" } };
+  }
+  let stat;
+  try {
+    stat = await promises.stat(filePath);
+  } catch {
+    return { ok: false, error: { kind: "not_found", taskId } };
+  }
+  if (stat.size > MAX_FILE_SIZE_BYTES) {
+    return { ok: false, error: { kind: "too_large", sizeBytes: stat.size } };
+  }
+  let content;
+  try {
+    content = await promises.readFile(filePath, "utf-8");
+  } catch (e) {
+    return { ok: false, error: { kind: "io_error", message: e.message } };
+  }
+  const events = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) {
+      continue;
+    }
+    try {
+      events.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  if (events.length === 0) {
+    return { ok: false, error: { kind: "empty", taskId } };
+  }
+  return { ok: true, events, taskId, filePath };
+}
+function formatTraceLoadError(error) {
+  switch (error.kind) {
+    case "invalid_task_id":
+      return `Invalid task ID: ${error.message}`;
+    case "not_found":
+      return `Trace not found: ${error.taskId}`;
+    case "too_large":
+      return `Trace file too large: ${Math.round(error.sizeBytes / 1024 / 1024)} MB (limit 100 MB)`;
+    case "empty":
+      return `Trace file is empty: ${error.taskId}`;
+    case "io_error":
+      return `IO error reading trace: ${error.message}`;
+  }
+}
+
+// src/trace-helpers.ts
+function createIterationDetailEvent(params) {
+  return {
+    type: "iteration:detail",
+    iteration: params.iteration,
+    config: {
+      maxIterations: params.maxIterations,
+      mode: params.mode,
+      temperature: params.temperature
+    },
+    availableTools: {
+      total: params.availableTools.length,
+      tools: params.availableTools
+    },
+    context: {
+      messagesCount: params.messages.length,
+      totalTokens: params.totalTokens,
+      conversationSummary: params.messages.slice(-2).map((m) => `${m.role}: ${m.content?.substring(0, 100) || ""}`).join(" | ")
+    }
+  };
+}
+function createLLMCallEvent(params) {
+  const durationMs = params.endTime - params.startTime;
+  const inputCost = (params.response.usage?.promptTokens || 0) * 3e-6;
+  const outputCost = (params.response.usage?.completionTokens || 0) * 15e-6;
+  return {
+    type: "llm:call",
+    iteration: params.iteration,
+    request: {
+      model: params.model,
+      temperature: params.temperature,
+      maxTokens: params.maxTokens,
+      tools: params.tools
+    },
+    response: {
+      content: params.response.content || null,
+      toolCalls: params.response.toolCalls?.map((tc) => ({
+        id: tc.id,
+        name: tc.name,
+        input: tc.input
+      })),
+      stopReason: params.response.toolCalls && params.response.toolCalls.length > 0 ? "tool_use" : "end_turn",
+      usage: {
+        inputTokens: params.response.usage.promptTokens,
+        outputTokens: params.response.usage.completionTokens,
+        totalTokens: params.response.usage.promptTokens + params.response.usage.completionTokens
+      }
+    },
+    timing: {
+      startedAt: new Date(params.startTime).toISOString(),
+      completedAt: new Date(params.endTime).toISOString(),
+      durationMs
+    },
+    cost: {
+      inputCost,
+      outputCost,
+      totalCost: inputCost + outputCost,
+      currency: "USD"
+    }
+  };
+}
+function createToolExecutionEvent(params) {
+  const durationMs = params.endTime - params.startTime;
+  const resultStr = typeof params.output.result === "string" ? params.output.result : JSON.stringify(params.output.result || "");
+  const TRACE_OUTPUT_LIMIT = 5e4;
+  const truncated = resultStr.length > TRACE_OUTPUT_LIMIT;
+  return {
+    type: "tool:execution",
+    iteration: params.iteration,
+    tool: {
+      name: params.toolName,
+      callId: params.callId
+    },
+    input: params.input,
+    output: {
+      success: params.output.success,
+      result: truncated ? resultStr.substring(0, TRACE_OUTPUT_LIMIT) + `
+... (truncated from ${resultStr.length} chars)` : params.output.result,
+      error: params.output.error,
+      truncated,
+      originalLength: resultStr.length
+    },
+    timing: {
+      startedAt: new Date(params.startTime).toISOString(),
+      completedAt: new Date(params.endTime).toISOString(),
+      durationMs
+    },
+    metadata: params.metadata
+  };
+}
+function createMemorySnapshotEvent(params) {
+  return {
+    type: "memory:snapshot",
+    iteration: params.iteration,
+    sessionMemory: {
+      conversationHistory: params.conversationHistory,
+      userPreferences: params.userPreferences
+    },
+    sharedMemory: {
+      facts: params.facts,
+      findings: params.findings
+    },
+    executionMemory: {
+      filesRead: params.filesRead,
+      searchesMade: params.searchesMade,
+      toolsUsed: params.toolsUsed
+    }
+  };
+}
+function createDecisionPointEvent(params) {
+  return {
+    type: "decision:point",
+    iteration: params.iteration,
+    decision: params.decision,
+    toolSelection: params.toolSelection,
+    stoppingCondition: params.stoppingCondition
+  };
+}
+function createSynthesisForcedEvent(params) {
+  return {
+    type: "synthesis:forced",
+    iteration: params.iteration,
+    trigger: {
+      reason: params.reason,
+      lastIteration: params.lastIteration,
+      lastToolCall: params.lastToolCall
+    },
+    synthesisPrompt: params.synthesisPrompt,
+    synthesisResponse: params.synthesisResponse
+  };
+}
+function createErrorCapturedEvent(params) {
+  return {
+    type: "error:captured",
+    iteration: params.iteration,
+    error: {
+      message: params.error.message,
+      stack: params.error.stack || "",
+      code: params.error.code,
+      name: params.error.name
+    },
+    context: {
+      lastLLMCall: params.lastLLMCall,
+      lastToolCall: params.lastToolCall,
+      currentMessages: params.currentMessages.slice(-5).map((m) => ({
+        role: m.role === "tool" ? "assistant" : m.role,
+        contentPreview: m.content?.substring(0, 100) || ""
+      })),
+      memoryState: params.memoryState,
+      availableTools: params.availableTools
+    },
+    agentStack: params.agentStack
+  };
+}
+function createPromptDiffEvent(params) {
+  return {
+    type: "prompt:diff",
+    iteration: params.iteration,
+    diff: {
+      messagesAdded: params.messagesAdded,
+      messagesRemoved: params.messagesRemoved,
+      totalMessages: params.totalMessages,
+      changes: params.changes,
+      contextGrowth: {
+        tokensBefore: params.tokensBefore,
+        tokensAfter: params.tokensAfter,
+        delta: params.tokensAfter - params.tokensBefore
+      }
+    }
+  };
+}
+function createToolFilterEvent(params) {
+  return {
+    type: "tool:filter",
+    iteration: params.iteration,
+    filtering: {
+      before: {
+        totalTools: params.beforeTools.length,
+        tools: params.beforeTools
+      },
+      after: {
+        totalTools: params.afterTools.length,
+        tools: params.afterTools
+      },
+      filtered: params.filtered
+    }
+  };
+}
+function createContextTrimEvent(params) {
+  return {
+    type: "context:trim",
+    iteration: params.iteration,
+    trimming: {
+      trigger: params.trigger,
+      before: {
+        messageCount: params.messageCountBefore,
+        estimatedTokens: params.tokensBefore
+      },
+      after: {
+        messageCount: params.messageCountAfter,
+        estimatedTokens: params.tokensAfter
+      },
+      removed: {
+        messageCount: params.messagesRemoved,
+        tokensRemoved: params.tokensRemoved,
+        contentPreview: params.contentPreview
+      },
+      strategy: params.strategy
+    }
+  };
+}
+function createStoppingAnalysisEvent(params) {
+  return {
+    type: "stopping:analysis",
+    iteration: params.iteration,
+    conditions: params.conditions,
+    reasoning: params.reasoning,
+    metrics: {
+      iterationsUsed: params.iterationsUsed,
+      iterationsRemaining: params.iterationsRemaining,
+      timeElapsedMs: params.timeElapsedMs,
+      timeRemainingMs: params.timeRemainingMs,
+      toolCallsInLast3Iterations: params.toolCallsInLast3Iterations,
+      confidenceScore: params.confidenceScore
+    }
+  };
+}
+function createLLMValidationEvent(params) {
+  return {
+    type: "llm:validation",
+    iteration: params.iteration,
+    validation: {
+      stopReason: params.stopReason,
+      isValid: params.isValid,
+      checks: {
+        hasContent: params.hasContent,
+        hasToolCalls: params.hasToolCalls,
+        toolCallsValid: params.toolCallsValid,
+        jsonParseable: params.jsonParseable,
+        schemaValid: params.schemaValid
+      },
+      issues: params.issues
+    }
+  };
+}
+function createFactAddedEvent(params) {
+  return {
+    type: "memory:fact_added",
+    iteration: params.iteration,
+    fact: params.fact,
+    factSheetStats: params.factSheetStats
+  };
+}
+function createArchiveStoreEvent(params) {
+  return {
+    type: "memory:archive_store",
+    iteration: params.iteration,
+    entry: params.entry,
+    archiveStats: params.archiveStats
+  };
+}
+function createSummarizationLLMCallEvent(params) {
+  return {
+    type: "memory:summarization_llm_call",
+    iteration: params.iteration,
+    prompt: params.prompt,
+    rawResponse: params.rawResponse,
+    parseSuccess: params.parseSuccess,
+    parseError: params.parseError,
+    timing: {
+      durationMs: params.durationMs,
+      outputTokens: params.outputTokens
+    }
+  };
+}
+function createSummarizationResultEvent(params) {
+  return {
+    type: "memory:summarization_result",
+    iteration: params.iteration,
+    input: params.input,
+    output: params.output,
+    delta: params.delta,
+    efficiency: params.efficiency
+  };
+}
+
+export { DEFAULT_TRACE_CONFIG, FileTracer, IncrementalTraceWriter, TRACE_DIR_RELATIVE, createArchiveStoreEvent, createContextTrimEvent, createDecisionPointEvent, createDefaultPrivacyConfig, createErrorCapturedEvent, createFactAddedEvent, createIterationDetailEvent, createLLMCallEvent, createLLMValidationEvent, createMemorySnapshotEvent, createPromptDiffEvent, createStoppingAnalysisEvent, createSummarizationLLMCallEvent, createSummarizationResultEvent, createSynthesisForcedEvent, createToolExecutionEvent, createToolFilterEvent, formatTraceLoadError, loadTrace, redactPaths, redactSecretsFromString, redactTraceEvent, redactValue };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map