@synergenius/flow-weaver 0.33.2 → 0.44.0

package/dist/testing/index.js

@@ -1,24 +1,582 @@
-/**
- * Flow Weaver Testing Utilities
- *
- * Deterministic testing for agent workflows.
- *
- * ```typescript
- * import {
- *   createMockLlmProvider,
- *   createRecordingProvider,
- *   createReplayProvider,
- *   loadRecording,
- *   expectAgentResult,
- *   expectMockLlm,
- *   TokenTracker,
- * } from 'flow-weaver/testing';
- * ```
- */
-export { createMockLlmProvider } from './mock-llm.js';
-export { expectAgentResult, expectMockLlm } from './assertions.js';
-export { TokenTracker } from './token-tracker.js';
-export { createRecordingProvider } from './recorder.js';
-export { createReplayProvider, loadRecording } from './replayer.js';
-export { createMockApprovalProvider } from './mock-approval.js';
-//# sourceMappingURL=index.js.map
+import "../chunks/chunk-SEWDMQ6Q.js";
+
+// src/testing/mock-llm.ts
+var DEFAULT_USAGE = {
+  promptTokens: 50,
+  completionTokens: 25,
+  totalTokens: 75
+};
+var FALLBACK_RESPONSE = {
+  content: "[Mock: no matching response configured]",
+  toolCalls: [],
+  finishReason: "stop",
+  usage: DEFAULT_USAGE
+};
+function createMockLlmProvider(responses = [], options) {
+  const calls = [];
+  const useCounts = /* @__PURE__ */ new Map();
+  const defaultUsage = options?.defaultUsage ?? DEFAULT_USAGE;
+  const fallback = {
+    ...FALLBACK_RESPONSE,
+    ...options?.fallbackResponse ?? {},
+    usage: options?.fallbackResponse?.usage ?? defaultUsage
+  };
+  function findMatch(lastMessage) {
+    for (let i = 0; i < responses.length; i++) {
+      const def = responses[i];
+      if (def.maxUses !== void 0) {
+        const used = useCounts.get(i) ?? 0;
+        if (used >= def.maxUses) continue;
+      }
+      const matches = typeof def.match === "string" ? lastMessage.includes(def.match) : def.match.test(lastMessage);
+      if (matches) {
+        return { index: i, response: def };
+      }
+    }
+    return null;
+  }
+  return {
+    async chat(messages, chatOptions) {
+      const lastUserMessage = [...messages].reverse().find((m) => m.role === "user")?.content ?? "";
+      const match = findMatch(lastUserMessage);
+      let response;
+      let matchedIndex;
+      if (match) {
+        matchedIndex = match.index;
+        useCounts.set(matchedIndex, (useCounts.get(matchedIndex) ?? 0) + 1);
+        response = {
+          content: match.response.response.content ?? null,
+          toolCalls: match.response.response.toolCalls ?? [],
+          finishReason: match.response.response.finishReason ?? "stop",
+          usage: match.response.usage ?? defaultUsage
+        };
+      } else {
+        matchedIndex = -1;
+        response = { ...fallback };
+      }
+      calls.push({
+        messages: [...messages],
+        options: chatOptions,
+        matchedIndex,
+        response,
+        timestamp: Date.now()
+      });
+      return response;
+    },
+    getCalls() {
+      return [...calls];
+    },
+    getCallCount() {
+      return calls.length;
+    },
+    getTotalTokens() {
+      return calls.reduce((sum, call) => sum + (call.response.usage?.totalTokens ?? 0), 0);
+    },
+    getTokenUsage() {
+      return calls.map((call) => call.response.usage ?? defaultUsage);
+    },
+    reset() {
+      calls.length = 0;
+      useCounts.clear();
+    },
+    getCallsForResponse(index) {
+      return calls.filter((c) => c.matchedIndex === index);
+    }
+  };
+}
+
+// src/testing/assertions.ts
+function expectAgentResult(result) {
+  const assertions = {
+    toHaveSucceeded() {
+      if (result.onSuccess !== true) {
+        throw new Error(
+          `Expected workflow to succeed (onSuccess === true), but got onSuccess=${result.onSuccess}, onFailure=${result.onFailure}`
+        );
+      }
+      return assertions;
+    },
+    toHaveFailed() {
+      if (result.onFailure !== true) {
+        throw new Error(
+          `Expected workflow to fail (onFailure === true), but got onSuccess=${result.onSuccess}, onFailure=${result.onFailure}`
+        );
+      }
+      return assertions;
+    },
+    toHaveOutput(portName, expectedValue) {
+      if (!(portName in result)) {
+        throw new Error(
+          `Expected output port '${portName}' to exist, but result only has: ${Object.keys(result).join(", ")}`
+        );
+      }
+      if (result[portName] === null || result[portName] === void 0) {
+        throw new Error(
+          `Expected output port '${portName}' to have a value, but got ${result[portName]}`
+        );
+      }
+      if (expectedValue !== void 0) {
+        const actual = result[portName];
+        const expected = expectedValue;
+        if (typeof expected === "object" && expected !== null) {
+          if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+            throw new Error(
+              `Expected output '${portName}' to equal ${JSON.stringify(expected)}, but got ${JSON.stringify(actual)}`
+            );
+          }
+        } else if (actual !== expected) {
+          throw new Error(
+            `Expected output '${portName}' to equal ${JSON.stringify(expected)}, but got ${JSON.stringify(actual)}`
+          );
+        }
+      }
+      return assertions;
+    },
+    toNotHaveOutput(portName) {
+      if (portName in result && result[portName] !== null && result[portName] !== void 0) {
+        throw new Error(
+          `Expected output port '${portName}' to be absent or null, but got ${JSON.stringify(result[portName])}`
+        );
+      }
+      return assertions;
+    }
+  };
+  return assertions;
+}
+function expectMockLlm(mockLlm) {
+  const assertions = {
+    toHaveBeenCalledTimes(n) {
+      const actual = mockLlm.getCallCount();
+      if (actual !== n) {
+        throw new Error(`Expected LLM to be called ${n} time(s), but was called ${actual} time(s)`);
+      }
+      return assertions;
+    },
+    toHaveUsedTool(toolName) {
+      const calls = mockLlm.getCalls();
+      const found = calls.some(
+        (call) => call.response.toolCalls.some((tc) => tc.name === toolName)
+      );
+      if (!found) {
+        const usedTools = [
+          ...new Set(
+            calls.flatMap((c) => c.response.toolCalls.map((tc) => tc.name))
+          )
+        ];
+        throw new Error(
+          `Expected tool '${toolName}' to have been used, but only these tools were used: ${usedTools.length > 0 ? usedTools.join(", ") : "(none)"}`
+        );
+      }
+      return assertions;
+    },
+    toNotHaveUsedTool(toolName) {
+      const calls = mockLlm.getCalls();
+      const found = calls.some(
+        (call) => call.response.toolCalls.some((tc) => tc.name === toolName)
+      );
+      if (found) {
+        throw new Error(`Expected tool '${toolName}' to NOT have been used, but it was`);
+      }
+      return assertions;
+    },
+    toHaveTokenUsageBelow(maxTokens) {
+      const total = mockLlm.getTotalTokens();
+      if (total > maxTokens) {
+        throw new Error(
+          `Expected token usage below ${maxTokens}, but total was ${total}`
+        );
+      }
+      return assertions;
+    },
+    toHaveReceivedMessage(pattern, callIndex) {
+      const calls = mockLlm.getCalls();
+      const targetCalls = callIndex !== void 0 ? [calls[callIndex]] : calls;
+      if (callIndex !== void 0 && !calls[callIndex]) {
+        throw new Error(
+          `Expected call at index ${callIndex}, but only ${calls.length} calls were recorded`
+        );
+      }
+      const found = targetCalls.some(
+        (call) => call?.messages.some((msg) => {
+          if (typeof pattern === "string") {
+            return msg.content.includes(pattern);
+          }
+          return pattern.test(msg.content);
+        })
+      );
+      if (!found) {
+        const scope = callIndex !== void 0 ? `call #${callIndex}` : "any call";
+        throw new Error(
+          `Expected ${scope} to contain a message matching ${pattern}, but none matched`
+        );
+      }
+      return assertions;
+    }
+  };
+  return assertions;
+}
+
+// src/testing/token-tracker.ts
+var TokenTracker = class {
+  steps = [];
+  /** Track token usage for a step */
+  track(step, usage) {
+    const normalized = {
+      promptTokens: usage?.promptTokens ?? 0,
+      completionTokens: usage?.completionTokens ?? 0,
+      totalTokens: usage?.totalTokens ?? 0
+    };
+    this.steps.push({ step, usage: normalized, timestamp: Date.now() });
+  }
+  /** Total tokens across all tracked steps */
+  get total() {
+    return this.steps.reduce((sum, s) => sum + s.usage.totalTokens, 0);
+  }
+  /** Total prompt tokens */
+  get promptTokens() {
+    return this.steps.reduce((sum, s) => sum + s.usage.promptTokens, 0);
+  }
+  /** Total completion tokens */
+  get completionTokens() {
+    return this.steps.reduce((sum, s) => sum + s.usage.completionTokens, 0);
+  }
+  /** Number of tracked steps */
+  get stepCount() {
+    return this.steps.length;
+  }
+  /** Get all tracked steps */
+  getSteps() {
+    return [...this.steps];
+  }
+  /** Get usage for a specific step by name */
+  getStep(step) {
+    return this.steps.find((s) => s.step === step);
+  }
+  /**
+   * Assert total tokens are below a budget.
+   * Throws with a descriptive message if exceeded.
+   */
+  assertBelow(maxTokens) {
+    if (this.total > maxTokens) {
+      const breakdown = this.steps.map((s) => `  ${s.step}: ${s.usage.totalTokens} tokens`).join("\n");
+      throw new Error(
+        `Token budget exceeded: ${this.total} > ${maxTokens}
+Breakdown (${this.steps.length} steps):
+${breakdown}`
+      );
+    }
+  }
+  /**
+   * Assert total tokens are above a minimum.
+   * Useful to verify the LLM was actually called.
+   */
+  assertAbove(minTokens) {
+    if (this.total < minTokens) {
+      throw new Error(
+        `Token usage too low: ${this.total} < ${minTokens}. Was the LLM actually called?`
+      );
+    }
+  }
+  /** Reset all tracking data */
+  reset() {
+    this.steps.length = 0;
+  }
+  /**
+   * Convenience: track all calls from a mock LLM provider.
+   * Uses call index as step name unless a nameResolver is provided.
+   */
+  trackFromCalls(calls, nameResolver) {
+    calls.forEach((call, i) => {
+      const step = nameResolver ? nameResolver(i) : `call-${i}`;
+      this.track(step, call.response.usage);
+    });
+  }
+};
+
+// src/testing/recorder.ts
+function createRecordingProvider(realProvider, metadata) {
+  const steps = [];
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  const provider = {
+    async chat(messages, options) {
+      const startTime = Date.now();
+      const timestamp = new Date(startTime).toISOString();
+      const response = await realProvider.chat(messages, options);
+      const durationMs = Date.now() - startTime;
+      steps.push({
+        index: steps.length,
+        input: {
+          messages: [...messages],
+          ...options ? { options: { ...options } } : {}
+        },
+        output: { ...response },
+        timestamp,
+        durationMs
+      });
+      return response;
+    }
+  };
+  return {
+    provider,
+    getRecording() {
+      return {
+        steps: steps.map((s) => ({ ...s })),
+        metadata: { ...metadata ?? {} },
+        createdAt
+      };
+    },
+    getCallCount() {
+      return steps.length;
+    },
+    reset() {
+      steps.length = 0;
+    }
+  };
+}
+
+// src/testing/replayer.ts
+var ZERO_USAGE = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+function createReplayProvider(recording, options) {
+  const strict = options?.strict ?? true;
+  const defaultUsage = options?.defaultUsage ?? ZERO_USAGE;
+  const steps = [...recording.steps];
+  let callIndex = 0;
+  const calls = [];
+  return {
+    async chat(messages, chatOptions) {
+      if (callIndex >= steps.length) {
+        if (strict) {
+          throw new Error(
+            `Replay exhausted: recording has ${steps.length} step(s) but call #${callIndex} was attempted. Set strict: false to return a fallback response instead.`
+          );
+        }
+        const fallback = {
+          content: `[Replay exhausted at call #${callIndex}]`,
+          toolCalls: [],
+          finishReason: "stop",
+          usage: defaultUsage
+        };
+        calls.push({
+          messages: [...messages],
+          options: chatOptions,
+          matchedIndex: -1,
+          response: fallback,
+          timestamp: Date.now()
+        });
+        callIndex++;
+        return fallback;
+      }
+      const step = steps[callIndex];
+      const response = {
+        content: step.output.content,
+        toolCalls: step.output.toolCalls ?? [],
+        finishReason: step.output.finishReason ?? "stop",
+        usage: step.output.usage ?? defaultUsage
+      };
+      calls.push({
+        messages: [...messages],
+        options: chatOptions,
+        matchedIndex: callIndex,
+        response,
+        timestamp: Date.now()
+      });
+      callIndex++;
+      return response;
+    },
+    getCalls() {
+      return [...calls];
+    },
+    getCallCount() {
+      return calls.length;
+    },
+    getTotalTokens() {
+      return calls.reduce((sum, call) => sum + (call.response.usage?.totalTokens ?? 0), 0);
+    },
+    getTokenUsage() {
+      return calls.map((call) => call.response.usage ?? defaultUsage);
+    },
+    reset() {
+      calls.length = 0;
+      callIndex = 0;
+    },
+    getCallsForResponse(index) {
+      return calls.filter((c) => c.matchedIndex === index);
+    }
+  };
+}
+function loadRecording(data) {
+  const parsed = typeof data === "string" ? JSON.parse(data) : data;
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("Invalid recording: expected an object");
+  }
+  const rec = parsed;
+  if (!Array.isArray(rec.steps)) {
+    throw new Error('Invalid recording: missing or invalid "steps" array');
+  }
+  for (let i = 0; i < rec.steps.length; i++) {
+    const step = rec.steps[i];
+    if (!step.output || typeof step.output !== "object") {
+      throw new Error(`Invalid recording step ${i}: missing "output" object`);
+    }
+  }
+  return {
+    steps: rec.steps.map((step, i) => ({
+      index: step.index ?? i,
+      input: step.input ?? { messages: [] },
+      output: step.output,
+      timestamp: step.timestamp ?? "",
+      durationMs: step.durationMs ?? 0
+    })),
+    metadata: rec.metadata ?? {},
+    createdAt: rec.createdAt ?? ""
+  };
+}
+
+// src/testing/run-store-check.ts
+import assert from "node:assert/strict";
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function record(runId, over = {}) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    formatVersion: 1,
+    runId,
+    filePath: "/project/order.ts",
+    workflowName: "placeOrder",
+    params: { amount: 3 },
+    bundleDigest: "digest",
+    status: "waiting",
+    gate: { id: "g1", kind: "approval", node: "approve", nodeType: "waitForApproval", inputs: { amount: 3 }, absent: [], outputs: ["ok"], hasSuccessPort: true, hasFailurePort: true },
+    // A waiting run carries its continuation in the record: a store that
+    // keeps only the fields it knows would lose it.
+    continuation: { formatVersion: 1, runId, gateId: "g1", state: { completed: [], variables: [] }, receipts: [] },
+    createdAt: now,
+    updatedAt: now,
+    ...over
+  };
+}
+async function checkRunStore(make) {
+  const store = await make();
+  assert.equal(await store.get("missing"), void 0, "get of an unknown run is undefined");
+  const a = record("run-a");
+  await store.put(a);
+  const gotA = await store.get("run-a");
+  assert.deepEqual(gotA, a, "get returns what put stored");
+  gotA.params.amount = 99;
+  assert.equal((await store.get("run-a")).params.amount, 3, "get returns a copy, so mutating it changes nothing");
+  await store.put({ ...a, status: "completed", gate: void 0, result: { ok: true }, updatedAt: new Date(Date.now() + 1e3).toISOString() });
+  assert.equal((await store.get("run-a")).status, "completed", "put replaces the whole record");
+  await sleep(2);
+  const b = record("run-b", { filePath: "/project/other.ts", updatedAt: new Date(Date.now() + 5e3).toISOString() });
+  await store.put(b);
+  const all = await store.list();
+  assert.deepEqual(all.map((r) => r.runId), ["run-b", "run-a"], "list is newest first by updatedAt");
+  assert.deepEqual((await store.list({ filePath: "/project/other.ts" })).map((r) => r.runId), ["run-b"], "list filters by file");
+  assert.deepEqual(await store.list({ filePath: "/nowhere.ts" }), [], "list of an unknown file is empty");
+  assert.equal(await store.getDoc("run-a", "trace"), void 0, "a missing document is undefined");
+  await store.putDoc("run-a", "trace", [{ t: 1, e: { type: "x" } }]);
+  await store.putDoc("run-a", "effect-abc123", { receipt: 1 });
+  await store.putDoc("run-a", "continuation", { frames: [] });
+  assert.deepEqual(await store.getDoc("run-a", "trace"), [{ t: 1, e: { type: "x" } }], "a document reads back as written");
+  assert.deepEqual(await store.getDoc("run-a", "effect-abc123"), { receipt: 1 }, "an effect receipt reads back");
+  await store.putDoc("run-a", "trace", []);
+  assert.deepEqual(await store.getDoc("run-a", "trace"), [], "a document is replaced, not merged");
+  await store.deleteDoc("run-a", "continuation");
+  assert.equal(await store.getDoc("run-a", "continuation"), void 0, "a deleted document is gone");
+  await store.deleteDoc("run-a", "continuation");
+  await store.putDoc("run-new", "http", { callbackUrl: "https://x" });
+  assert.deepEqual(await store.getDoc("run-new", "http"), { callbackUrl: "https://x" }, "a document may precede its record");
+  await assert.rejects(store.putDoc("run-a", "../escape", {}), "a name that is not a slug is refused");
+  assert.equal(await store.claim("run-a", "one", 6e4), true, "the first claim is granted");
+  assert.equal(await store.claim("run-a", "two", 6e4), false, "a second owner is refused while the first holds it");
+  assert.equal(await store.claim("run-a", "one", 6e4), true, "the holder may claim again");
+  await store.release("run-a", "two");
+  assert.equal(await store.claim("run-a", "two", 6e4), false, "a release by a non-holder changes nothing");
+  await store.release("run-a", "one");
+  assert.equal(await store.claim("run-a", "two", 6e4), true, "after release another owner may claim");
+  await store.release("run-a", "two");
+  assert.equal(await store.claim("run-b", "short", 20), true, "a claim may be short");
+  await sleep(40);
+  assert.equal(await store.claim("run-b", "late", 6e4), true, "a lapsed claim may be taken by another owner");
+  await store.release("run-b", "late");
+  assert.equal(await store.claim("run-unknown", "x", 6e4), true, "a run may be claimed before it has a record");
+  await store.release("run-unknown", "x");
+  const race = await Promise.all(["p", "q", "r", "s"].map((o) => store.claim("run-a", o, 6e4)));
+  assert.equal(race.filter(Boolean).length, 1, "of concurrent claimers exactly one wins");
+  await store.remove("run-a");
+  assert.equal(await store.get("run-a"), void 0, "a removed run has no record");
+  assert.equal(await store.getDoc("run-a", "trace"), void 0, "a removed run has no documents");
+  assert.equal(await store.claim("run-a", "after", 6e4), true, "a removed run has no claim");
+  await store.release("run-a", "after");
+  await store.remove("never-existed");
+}
+
+// src/testing/mock-approval.ts
+var FALLBACK_RESULT = {
+  approved: false,
+  response: "[Mock: no matching approval response configured]"
+};
+function createMockApprovalProvider(responses = [], options) {
+  const calls = [];
+  const useCounts = /* @__PURE__ */ new Map();
+  const fallback = options?.fallbackResponse ?? FALLBACK_RESULT;
+  function findMatch(prompt) {
+    for (let i = 0; i < responses.length; i++) {
+      const def = responses[i];
+      if (def.maxUses !== void 0) {
+        const used = useCounts.get(i) ?? 0;
+        if (used >= def.maxUses) continue;
+      }
+      const matches = typeof def.match === "string" ? prompt.includes(def.match) : def.match.test(prompt);
+      if (matches) {
+        return { index: i, response: def };
+      }
+    }
+    return null;
+  }
+  return {
+    async requestApproval(request) {
+      const match = findMatch(request.prompt);
+      let result;
+      let matchedIndex;
+      if (match) {
+        matchedIndex = match.index;
+        useCounts.set(matchedIndex, (useCounts.get(matchedIndex) ?? 0) + 1);
+        result = { ...match.response.response };
+      } else {
+        matchedIndex = -1;
+        result = { ...fallback };
+      }
+      calls.push({
+        request: { ...request },
+        matchedIndex,
+        result,
+        timestamp: Date.now()
+      });
+      return result;
+    },
+    getCalls() {
+      return [...calls];
+    },
+    getCallCount() {
+      return calls.length;
+    },
+    reset() {
+      calls.length = 0;
+      useCounts.clear();
+    },
+    getCallsForResponse(index) {
+      return calls.filter((c) => c.matchedIndex === index);
+    }
+  };
+}
+export {
+  TokenTracker,
+  checkRunStore,
+  createMockApprovalProvider,
+  createMockLlmProvider,
+  createRecordingProvider,
+  createReplayProvider,
+  expectAgentResult,
+  expectMockLlm,
+  loadRecording
+};

package/dist/testing/mock-approval.d.ts

@@ -1,12 +1,12 @@
 /**
  * Mock Approval Provider for deterministic human-approval workflow testing.
  *
- * Mirrors the mock LLM provider pattern — pattern matching on prompts,
+ * Mirrors the mock LLM provider pattern: pattern matching on prompts,
  * call recording, and configurable responses.
  *
  * Usage in vitest/jest tests:
  * ```typescript
- * import { createMockApprovalProvider } from 'flow-weaver/testing';
+ * import { createMockApprovalProvider } from '@synergenius/flow-weaver/testing';
  *
  * const mockApproval = createMockApprovalProvider([
  *   { match: /expense/, response: { approved: true, reviewer: 'alice' } },
@@ -14,9 +14,7 @@
  *   { match: /./, response: { approved: true } },
  * ]);
  *
- * // Inject globally for compiled workflows
- * (globalThis as unknown as { __fw_approval_provider__?: ApprovalProvider })
- *   .__fw_approval_provider__ = mockApproval;
+ * // Pass mockApproval to the approval adapter under test.
  *
  * // After test
  * expect(mockApproval.getCallCount()).toBe(2);

package/dist/testing/mock-llm.d.ts

@@ -3,15 +3,14 @@
  *
  * Usage in vitest/jest tests:
  * ```typescript
- * import { createMockLlmProvider } from 'flow-weaver/testing';
+ * import { createMockLlmProvider } from '@synergenius/flow-weaver/testing';
  *
  * const mockLlm = createMockLlmProvider([
  *   { match: /search/, response: { content: null, toolCalls: [{ id: '1', name: 'search', arguments: { q: 'test' } }], finishReason: 'tool_calls' } },
  *   { match: /./, response: { content: 'Default answer', toolCalls: [], finishReason: 'stop' } },
  * ]);
  *
- * // Inject globally for compiled workflows
- * (globalThis as unknown as { __fw_llm_provider__?: LLMProvider }).__fw_llm_provider__ = mockLlm;
+ * // Pass mockLlm to the node or adapter under test.
  *
  * // After test
  * expect(mockLlm.getCallCount()).toBe(2);

package/dist/testing/recorder.d.ts

@@ -1,14 +1,13 @@
 /**
- * Recording LLM Provider — wraps a real provider and records all interactions.
+ * Recording LLM Provider: wraps a real provider and records all interactions.
  *
  * Usage:
  * ```typescript
- * import { createRecordingProvider } from 'flow-weaver/testing';
+ * import { createRecordingProvider } from '@synergenius/flow-weaver/testing';
  *
  * const recorder = createRecordingProvider(realLlmProvider);
  *
- * // Use recorder.provider as the LLM provider in your workflow
- * (globalThis as unknown as { __fw_llm_provider__?: LLMProvider }).__fw_llm_provider__ = recorder.provider;
+ * // Pass recorder.provider to the node or adapter under test.
  *
  * // Run workflow...
  *
@@ -18,7 +17,7 @@
  * // Save to disk, fixture file, etc.
  * ```
  */
-import type { LLMMessage, LLMProvider, LLMResponse, LLMTool } from './mock-llm.js';
+import type { LLMMessage, LLMProvider, LLMResponse, LLMTool } from './mock-llm';
 export interface LlmRecordingStep {
     /** Sequential index of this call */
     index: number;
@@ -49,7 +48,7 @@ export interface LlmRecording {
     createdAt: string;
 }
 export interface RecordingLlmProvider {
-    /** The wrapped provider — use this as your LLMProvider */
+    /** The wrapped provider: use this as your LLMProvider */
     provider: LLMProvider;
     /** Get the current recording */
     getRecording(): LlmRecording;