@agtlantis/core 0.4.1

package/dist/testing/index.cjs

@@ -0,0 +1,2144 @@
+'use strict';
+
+var test = require('ai/test');
+var ai = require('ai');
+var merge = require('lodash/merge');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var merge__default = /*#__PURE__*/_interopDefault(merge);
+
+// src/session/usage-extractors.ts
+function mergeUsages(usages) {
+  if (usages.length === 0) {
+    return createZeroUsage();
+  }
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let totalTokens = 0;
+  let noCacheTokens = 0;
+  let cacheReadTokens = 0;
+  let cacheWriteTokens = 0;
+  let textTokens = 0;
+  let reasoningTokens = 0;
+  for (const usage of usages) {
+    inputTokens += usage.inputTokens ?? 0;
+    outputTokens += usage.outputTokens ?? 0;
+    totalTokens += usage.totalTokens ?? 0;
+    noCacheTokens += usage.inputTokenDetails?.noCacheTokens ?? 0;
+    cacheReadTokens += usage.inputTokenDetails?.cacheReadTokens ?? 0;
+    cacheWriteTokens += usage.inputTokenDetails?.cacheWriteTokens ?? 0;
+    textTokens += usage.outputTokenDetails?.textTokens ?? 0;
+    reasoningTokens += usage.outputTokenDetails?.reasoningTokens ?? 0;
+  }
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    inputTokenDetails: {
+      noCacheTokens,
+      cacheReadTokens,
+      cacheWriteTokens
+    },
+    outputTokenDetails: {
+      textTokens,
+      reasoningTokens
+    }
+  };
+}
+function createZeroUsage() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    inputTokenDetails: {
+      noCacheTokens: 0,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0
+    },
+    outputTokenDetails: {
+      textTokens: 0,
+      reasoningTokens: 0
+    }
+  };
+}
+
+// src/session/types.ts
+var SessionSummary = class _SessionSummary {
+  totalLLMUsage;
+  llmCallCount;
+  llmCalls;
+  toolCalls;
+  customRecords;
+  llmCost;
+  additionalCosts;
+  metadata;
+  /** Cost breakdown by model. Key format: `${provider}/${model}` */
+  costByModel;
+  startTime;
+  constructor(data, startTime) {
+    this.startTime = startTime;
+    this.totalLLMUsage = data.totalLLMUsage;
+    this.llmCallCount = data.llmCalls.length;
+    this.llmCalls = Object.freeze([...data.llmCalls]);
+    this.toolCalls = Object.freeze([...data.toolCalls]);
+    this.customRecords = Object.freeze([...data.customRecords]);
+    this.llmCost = data.llmCost;
+    this.additionalCosts = Object.freeze([...data.additionalCosts]);
+    this.metadata = Object.freeze({ ...data.metadata });
+    this.costByModel = Object.freeze({ ...data.costByModel });
+  }
+  /**
+   * Total duration from session start to now (computed dynamically).
+   */
+  get totalDuration() {
+    return Date.now() - this.startTime;
+  }
+  /**
+   * Creates an empty SessionSummary.
+   */
+  static empty(startTime) {
+    return new _SessionSummary(
+      {
+        totalLLMUsage: createZeroUsage(),
+        llmCalls: [],
+        toolCalls: [],
+        customRecords: [],
+        llmCost: 0,
+        additionalCosts: [],
+        metadata: {},
+        costByModel: {}
+      },
+      startTime
+    );
+  }
+  /**
+   * Creates a SessionSummary with custom data for testing purposes.
+   * @internal For testing only - do not use in production code.
+   */
+  static forTest(data) {
+    const startTime = data.startTime ?? Date.now() - 1e3;
+    return new _SessionSummary(
+      {
+        totalLLMUsage: data.totalLLMUsage ?? createZeroUsage(),
+        llmCalls: data.llmCalls ?? [],
+        toolCalls: data.toolCalls ?? [],
+        customRecords: data.customRecords ?? [],
+        llmCost: data.llmCost ?? 0,
+        additionalCosts: data.additionalCosts ?? [],
+        metadata: data.metadata ?? {},
+        costByModel: data.costByModel ?? {}
+      },
+      startTime
+    );
+  }
+  /**
+   * Total cost of all additional (non-LLM) operations.
+   */
+  get totalAdditionalCost() {
+    return this.additionalCosts.reduce((sum, c) => sum + c.cost, 0);
+  }
+  /**
+   * Total cost including LLM and additional costs.
+   */
+  get totalCost() {
+    return this.llmCost + this.totalAdditionalCost;
+  }
+  /**
+   * Returns a new SessionSummary with an LLM call added.
+   */
+  withLLMCall(call, newLlmCost, newCostByModel, newTotalUsage) {
+    return new _SessionSummary(
+      {
+        totalLLMUsage: newTotalUsage,
+        llmCalls: [...this.llmCalls, call],
+        toolCalls: [...this.toolCalls],
+        customRecords: [...this.customRecords],
+        llmCost: newLlmCost,
+        additionalCosts: [...this.additionalCosts],
+        metadata: { ...this.metadata },
+        costByModel: newCostByModel
+      },
+      this.startTime
+    );
+  }
+  /**
+   * Returns a new SessionSummary with an additional cost recorded.
+   */
+  withAdditionalCost(cost) {
+    return new _SessionSummary(
+      {
+        totalLLMUsage: this.totalLLMUsage,
+        llmCalls: [...this.llmCalls],
+        toolCalls: [...this.toolCalls],
+        customRecords: [...this.customRecords],
+        llmCost: this.llmCost,
+        additionalCosts: [...this.additionalCosts, cost],
+        metadata: { ...this.metadata },
+        costByModel: { ...this.costByModel }
+      },
+      this.startTime
+    );
+  }
+  /**
+   * Returns a new SessionSummary with metadata updated.
+   */
+  withMetadata(key, value) {
+    return new _SessionSummary(
+      {
+        totalLLMUsage: this.totalLLMUsage,
+        llmCalls: [...this.llmCalls],
+        toolCalls: [...this.toolCalls],
+        customRecords: [...this.customRecords],
+        llmCost: this.llmCost,
+        additionalCosts: [...this.additionalCosts],
+        metadata: { ...this.metadata, [key]: value },
+        costByModel: { ...this.costByModel }
+      },
+      this.startTime
+    );
+  }
+  /**
+   * Returns a new SessionSummary with a tool call added.
+   */
+  withToolCall(call) {
+    return new _SessionSummary(
+      {
+        totalLLMUsage: this.totalLLMUsage,
+        llmCalls: [...this.llmCalls],
+        toolCalls: [...this.toolCalls, call],
+        customRecords: [...this.customRecords],
+        llmCost: this.llmCost,
+        additionalCosts: [...this.additionalCosts],
+        metadata: { ...this.metadata },
+        costByModel: { ...this.costByModel }
+      },
+      this.startTime
+    );
+  }
+  /**
+   * Returns a new SessionSummary with a custom record added.
+   */
+  withCustomRecord(record) {
+    return new _SessionSummary(
+      {
+        totalLLMUsage: this.totalLLMUsage,
+        llmCalls: [...this.llmCalls],
+        toolCalls: [...this.toolCalls],
+        customRecords: [...this.customRecords, record],
+        llmCost: this.llmCost,
+        additionalCosts: [...this.additionalCosts],
+        metadata: { ...this.metadata },
+        costByModel: { ...this.costByModel }
+      },
+      this.startTime
+    );
+  }
+  /**
+   * Serializes to plain JSON object for database storage.
+   */
+  toJSON() {
+    return {
+      totalDuration: this.totalDuration,
+      totalLLMUsage: this.totalLLMUsage,
+      llmCallCount: this.llmCallCount,
+      llmCalls: [...this.llmCalls],
+      toolCalls: [...this.toolCalls],
+      customRecords: [...this.customRecords],
+      llmCost: this.llmCost,
+      additionalCosts: [...this.additionalCosts],
+      metadata: { ...this.metadata },
+      costByModel: { ...this.costByModel },
+      totalCost: this.totalCost,
+      totalAdditionalCost: this.totalAdditionalCost
+    };
+  }
+};
+
+// src/testing/fixtures.ts
+var TEST_API_KEY = "test-api-key";
+function createMockUsage(overrides) {
+  const inputTokens = overrides?.inputTokens ?? 10;
+  const outputTokens = overrides?.outputTokens ?? 5;
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: overrides?.totalTokens ?? inputTokens + outputTokens,
+    inputTokenDetails: {
+      cacheReadTokens: void 0,
+      cacheWriteTokens: void 0,
+      noCacheTokens: void 0,
+      ...overrides?.inputTokenDetails
+    },
+    outputTokenDetails: {
+      textTokens: void 0,
+      reasoningTokens: void 0,
+      ...overrides?.outputTokenDetails
+    }
+  };
+}
+function createTestEvent(type, overrides) {
+  return {
+    type,
+    ...overrides
+  };
+}
+function createDummyLLMCall() {
+  return {
+    startTime: Date.now() - 100,
+    endTime: Date.now(),
+    duration: 100,
+    usage: createMockUsage(),
+    type: "generateText",
+    model: "test-model",
+    provider: "openai"
+  };
+}
+function createMockSessionSummary(overrides) {
+  let startTime = overrides?.startTime;
+  if (startTime === void 0 && overrides?.totalDuration !== void 0) {
+    startTime = Date.now() - overrides.totalDuration;
+  }
+  const llmCost = overrides?.llmCost ?? overrides?.totalCost ?? 0;
+  let llmCalls = overrides?.llmCalls;
+  if (!llmCalls && overrides?.llmCallCount !== void 0) {
+    llmCalls = Array.from({ length: overrides.llmCallCount }, () => createDummyLLMCall());
+  }
+  return SessionSummary.forTest({
+    startTime,
+    totalLLMUsage: overrides?.totalLLMUsage ?? createMockUsage(),
+    llmCalls: llmCalls ?? [],
+    toolCalls: overrides?.toolCalls ?? [],
+    customRecords: overrides?.customRecords ?? [],
+    llmCost,
+    additionalCosts: overrides?.additionalCosts ?? [],
+    metadata: overrides?.metadata ?? {},
+    costByModel: overrides?.costByModel ?? {}
+  });
+}
+
+// src/testing/helpers.ts
+async function collectEvents(execution) {
+  const events = [];
+  const iterable = "stream" in execution && typeof execution.stream === "function" ? execution.stream() : execution;
+  for await (const event of iterable) {
+    events.push(event);
+  }
+  return events;
+}
+async function consumeExecution(execution) {
+  const iterable = "stream" in execution && typeof execution.stream === "function" ? execution.stream() : execution;
+  for await (const _event of iterable) {
+  }
+}
+function expectFileManagerInterface(obj) {
+  const fm = obj;
+  const requiredMethods = ["upload", "delete", "clear", "getUploadedFiles"];
+  for (const method of requiredMethods) {
+    if (typeof fm[method] !== "function") {
+      throw new Error(
+        `Expected FileManager.${method} to be a function, got ${typeof fm[method]}`
+      );
+    }
+  }
+}
+
+// src/observability/logger.ts
+var noopLogger = {};
+
+// src/execution/constants.ts
+var ERRORS = {
+  NO_RESULT: "No result available"};
+
+// src/execution/utils.ts
+function combineSignals(...signals) {
+  const controller = new AbortController();
+  for (const signal of signals) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      return controller.signal;
+    }
+    signal.addEventListener("abort", () => controller.abort(signal.reason), {
+      once: true
+    });
+  }
+  return controller.signal;
+}
+var Deferred = class {
+  promise;
+  resolve;
+  reject;
+  constructor() {
+    let res;
+    let rej;
+    this.promise = new Promise((resolve, reject) => {
+      res = resolve;
+      rej = reject;
+    });
+    this.resolve = res;
+    this.reject = rej;
+  }
+};
+
+// src/execution/shared.ts
+function isAbortError(error, signal) {
+  if (error instanceof Error && error.name === "AbortError") {
+    return true;
+  }
+  return signal.aborted;
+}
+function normalizeError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function createHookRunner(runHooks) {
+  let ran = false;
+  return {
+    ensureRun: async () => {
+      if (!ran) {
+        ran = true;
+        await runHooks();
+      }
+    },
+    hasRun: () => ran
+  };
+}
+
+// src/execution/streaming-host.ts
+var StreamingExecutionHost = class {
+  constructor(createSession, generator, userSignal) {
+    this.createSession = createSession;
+    this.generator = generator;
+    this.effectiveSignal = userSignal ? combineSignals(userSignal, this.abortController.signal) : this.abortController.signal;
+    this.consumerPromise = this.startConsuming();
+  }
+  abortController = new AbortController();
+  effectiveSignal;
+  consumerPromise;
+  eventBuffer = [];
+  subscribers = /* @__PURE__ */ new Set();
+  completed = false;
+  cleaned = false;
+  hookRunner = null;
+  cancelRequested = false;
+  extractedOutcome = null;
+  extractedSummary = null;
+  hasDataField(event) {
+    return "data" in event && event.data !== void 0;
+  }
+  hasSummaryField(event) {
+    return "summary" in event && event.summary !== void 0;
+  }
+  hasErrorField(event) {
+    return "error" in event && event.error instanceof Error;
+  }
+  extractResultAndMetadata(event) {
+    const isCompleteOrError = event.type === "complete" || event.type === "error";
+    if (!isCompleteOrError) {
+      return;
+    }
+    if (this.hasErrorField(event)) {
+      this.extractedOutcome = { type: "error", error: event.error };
+    } else if (this.hasDataField(event)) {
+      this.extractedOutcome = { type: "result", value: event.data };
+    }
+    if (this.hasSummaryField(event)) {
+      this.extractedSummary = event.summary;
+    }
+  }
+  notifySubscribers(event) {
+    this.subscribers.forEach((fn) => fn(event));
+  }
+  async startConsuming() {
+    const session = this.createSession(this.effectiveSignal);
+    this.hookRunner = createHookRunner(() => session.runOnDoneHooks());
+    const gen = this.generator(session);
+    try {
+      let next = await gen.next();
+      while (!next.done) {
+        this.eventBuffer.push(next.value);
+        this.notifySubscribers(next.value);
+        const isTerminal = next.value.type === "complete" || next.value.type === "error";
+        if (isTerminal) {
+          this.extractResultAndMetadata(next.value);
+          this.abortController.abort();
+          break;
+        }
+        if (this.abortController.signal.aborted) {
+          break;
+        }
+        next = await gen.next();
+      }
+      if (next.done && next.value !== void 0) {
+        const finalEvent = await Promise.resolve(next.value);
+        this.eventBuffer.push(finalEvent);
+        this.notifySubscribers(finalEvent);
+        this.extractResultAndMetadata(finalEvent);
+        const isTerminal = finalEvent.type === "complete" || finalEvent.type === "error";
+        if (isTerminal) {
+          this.abortController.abort();
+        }
+      }
+      return this.buildResult(session);
+    } catch (error) {
+      const errorObj = normalizeError(error);
+      if (isAbortError(error, this.abortController.signal)) {
+        return {
+          success: false,
+          aborted: true,
+          error: errorObj,
+          summary: await session.getSummary()
+        };
+      }
+      const errorEvent = await session.fail(errorObj);
+      this.eventBuffer.push(errorEvent);
+      this.notifySubscribers(errorEvent);
+      this.extractResultAndMetadata(errorEvent);
+      this.abortController.abort();
+      return this.buildResult(session);
+    } finally {
+      this.completed = true;
+      await this.hookRunner?.ensureRun();
+      await gen.return(void 0);
+    }
+  }
+  async buildResult(session) {
+    const summary = this.extractedSummary ?? await session.getSummary();
+    if (this.extractedOutcome?.type === "error") {
+      return {
+        success: false,
+        aborted: false,
+        error: this.extractedOutcome.error,
+        summary
+      };
+    }
+    if (this.extractedOutcome?.type === "result") {
+      return {
+        success: true,
+        result: this.extractedOutcome.value,
+        summary
+      };
+    }
+    return {
+      success: false,
+      aborted: true,
+      error: new Error(ERRORS.NO_RESULT),
+      summary
+    };
+  }
+  /**
+   * Get the event stream.
+   * Returns buffered events first, then real-time events.
+   * Can be called multiple times - replays buffer each time.
+   */
+  async *stream() {
+    let index = 0;
+    while (index < this.eventBuffer.length) {
+      yield this.eventBuffer[index++];
+    }
+    if (this.completed) {
+      return;
+    }
+    const queue = [];
+    let pending = new Deferred();
+    const subscriber = (event) => {
+      queue.push(event);
+      pending.resolve();
+    };
+    this.subscribers.add(subscriber);
+    try {
+      while (!this.completed || queue.length > 0) {
+        if (queue.length > 0) {
+          yield queue.shift();
+        } else if (!this.completed) {
+          await pending.promise;
+          pending = new Deferred();
+        }
+      }
+    } finally {
+      this.subscribers.delete(subscriber);
+    }
+  }
+  cancel() {
+    this.cancelRequested = true;
+    this.abortController.abort();
+  }
+  async cleanup() {
+    if (this.cleaned) {
+      return;
+    }
+    this.cleaned = true;
+    if (!this.completed) {
+      this.cancel();
+      await this.consumerPromise.catch(() => {
+      });
+    }
+    this.subscribers.clear();
+    await this.hookRunner?.ensureRun();
+  }
+  async [Symbol.asyncDispose]() {
+    await this.cleanup();
+  }
+  /**
+   * Get the execution result with status, summary, and all events.
+   * Never throws - returns a discriminated union with status.
+   */
+  async result() {
+    const internal = await this.consumerPromise;
+    const events = Object.freeze([...this.eventBuffer]);
+    if (internal.success) {
+      return {
+        status: "succeeded",
+        value: internal.result,
+        summary: internal.summary,
+        events
+      };
+    }
+    if (this.cancelRequested || internal.aborted) {
+      return {
+        status: "canceled",
+        summary: internal.summary,
+        events
+      };
+    }
+    return {
+      status: "failed",
+      error: internal.error,
+      summary: internal.summary,
+      events
+    };
+  }
+};
+
+// src/execution/simple-host.ts
+var SimpleExecutionHost = class {
+  abortController = new AbortController();
+  effectiveSignal;
+  consumerPromise;
+  cachedSession;
+  startTime = Date.now();
+  cancelRequested = false;
+  constructor(createSession, fn, userSignal) {
+    this.effectiveSignal = userSignal ? combineSignals(userSignal, this.abortController.signal) : this.abortController.signal;
+    this.consumerPromise = this.execute(createSession, fn);
+  }
+  async execute(createSession, fn) {
+    const session = createSession(this.effectiveSignal);
+    this.cachedSession = session;
+    const hookRunner = createHookRunner(() => session.runOnDoneHooks());
+    session.notifyExecutionStart();
+    try {
+      const result = await fn(session);
+      await session.notifyExecutionDone(result, this.startTime);
+      return {
+        success: true,
+        result,
+        summary: await session.getSummary()
+      };
+    } catch (error) {
+      const errorObj = normalizeError(error);
+      const isCancellation = isAbortError(error, this.abortController.signal);
+      if (!isCancellation) {
+        await session.notifyExecutionError(errorObj, this.startTime);
+      }
+      return {
+        success: false,
+        error: errorObj,
+        aborted: isCancellation,
+        summary: await session.getSummary()
+      };
+    } finally {
+      await hookRunner.ensureRun();
+    }
+  }
+  /**
+   * Request cancellation of the execution.
+   * Aborts the current LLM call if in progress.
+   * No-op if execution already completed.
+   */
+  cancel() {
+    this.cancelRequested = true;
+    this.abortController.abort();
+  }
+  /**
+   * Get the execution result with status and summary.
+   * Never throws - returns a discriminated union with status.
+   */
+  async result() {
+    const internal = await this.consumerPromise;
+    if (internal.success) {
+      return {
+        status: "succeeded",
+        value: internal.result,
+        summary: internal.summary
+      };
+    }
+    if (this.cancelRequested || internal.aborted) {
+      return {
+        status: "canceled",
+        summary: internal.summary
+      };
+    }
+    return {
+      status: "failed",
+      error: internal.error,
+      summary: internal.summary
+    };
+  }
+  /**
+   * Cleanup resources.
+   * For SimpleExecution, hooks are already run during execution,
+   * so this is intentionally a no-op.
+   */
+  async cleanup() {
+  }
+  async [Symbol.asyncDispose]() {
+    await this.cleanup();
+  }
+};
+
+// src/provider/base-provider.ts
+var BaseProvider = class {
+  streamingExecution(generator, options) {
+    return new StreamingExecutionHost(
+      (signal) => this.createStreamingSession(signal),
+      generator,
+      options?.signal
+    );
+  }
+  /**
+   * Execute a non-streaming function with cancellation support.
+   * Returns immediately - execution starts in the background.
+   */
+  simpleExecution(fn, options) {
+    return new SimpleExecutionHost(
+      (signal) => this.createSimpleSession(signal),
+      fn,
+      options?.signal
+    );
+  }
+};
+
+// src/pricing/defaults.ts
+var OPENAI_PRICING = {
+  "gpt-4o": { inputPricePerMillion: 2.5, outputPricePerMillion: 10 },
+  "gpt-4o-mini": { inputPricePerMillion: 0.15, outputPricePerMillion: 0.6 },
+  "gpt-4-turbo": { inputPricePerMillion: 10, outputPricePerMillion: 30 },
+  "gpt-4-turbo-preview": {
+    inputPricePerMillion: 10,
+    outputPricePerMillion: 30
+  },
+  "gpt-4": { inputPricePerMillion: 30, outputPricePerMillion: 60 },
+  "gpt-4-32k": { inputPricePerMillion: 60, outputPricePerMillion: 120 },
+  "gpt-3.5-turbo": { inputPricePerMillion: 0.5, outputPricePerMillion: 1.5 },
+  "gpt-3.5-turbo-16k": {
+    inputPricePerMillion: 3,
+    outputPricePerMillion: 4
+  },
+  "o1": { inputPricePerMillion: 15, outputPricePerMillion: 60 },
+  "o1-mini": { inputPricePerMillion: 3, outputPricePerMillion: 12 },
+  "o1-preview": { inputPricePerMillion: 15, outputPricePerMillion: 60 },
+  "o3": { inputPricePerMillion: 20, outputPricePerMillion: 80 },
+  "o3-mini": { inputPricePerMillion: 4, outputPricePerMillion: 16 }
+};
+var GOOGLE_PRICING = {
+  "gemini-2.5-flash": {
+    inputPricePerMillion: 0.15,
+    outputPricePerMillion: 0.6,
+    cachedInputPricePerMillion: 0.0375
+  },
+  "gemini-2.5-flash-lite": {
+    inputPricePerMillion: 0.075,
+    outputPricePerMillion: 0.3,
+    cachedInputPricePerMillion: 0.01875
+  },
+  "gemini-2.5-pro": {
+    inputPricePerMillion: 1.25,
+    outputPricePerMillion: 10,
+    cachedInputPricePerMillion: 0.3125
+  },
+  "gemini-2.0-flash": {
+    inputPricePerMillion: 0.1,
+    outputPricePerMillion: 0.4,
+    cachedInputPricePerMillion: 0.025
+  },
+  "gemini-2.0-flash-lite": {
+    inputPricePerMillion: 0.075,
+    outputPricePerMillion: 0.3,
+    cachedInputPricePerMillion: 0.01875
+  },
+  "gemini-1.5-pro": {
+    inputPricePerMillion: 1.25,
+    outputPricePerMillion: 5,
+    cachedInputPricePerMillion: 0.3125
+  },
+  "gemini-1.5-flash": {
+    inputPricePerMillion: 0.075,
+    outputPricePerMillion: 0.3,
+    cachedInputPricePerMillion: 0.01875
+  },
+  "gemini-1.5-flash-8b": {
+    inputPricePerMillion: 0.0375,
+    outputPricePerMillion: 0.15,
+    cachedInputPricePerMillion: 0.01
+  },
+  "gemini-pro": { inputPricePerMillion: 0.5, outputPricePerMillion: 1.5 }
+};
+var ANTHROPIC_PRICING = {
+  "claude-opus-4-5-20250514": {
+    inputPricePerMillion: 15,
+    outputPricePerMillion: 75,
+    cachedInputPricePerMillion: 1.875
+  },
+  "claude-sonnet-4-20250514": {
+    inputPricePerMillion: 3,
+    outputPricePerMillion: 15,
+    cachedInputPricePerMillion: 0.375
+  },
+  "claude-3-5-sonnet-20241022": {
+    inputPricePerMillion: 3,
+    outputPricePerMillion: 15,
+    cachedInputPricePerMillion: 0.375
+  },
+  "claude-3-5-haiku-20241022": {
+    inputPricePerMillion: 0.8,
+    outputPricePerMillion: 4,
+    cachedInputPricePerMillion: 0.1
+  },
+  "claude-3-opus-20240229": {
+    inputPricePerMillion: 15,
+    outputPricePerMillion: 75,
+    cachedInputPricePerMillion: 1.875
+  },
+  "claude-3-sonnet-20240229": {
+    inputPricePerMillion: 3,
+    outputPricePerMillion: 15,
+    cachedInputPricePerMillion: 0.375
+  },
+  "claude-3-haiku-20240307": {
+    inputPricePerMillion: 0.25,
+    outputPricePerMillion: 1.25,
+    cachedInputPricePerMillion: 0.03
+  }
+};
+var DEFAULT_PRICING_CONFIG = {
+  providers: {
+    openai: OPENAI_PRICING,
+    google: GOOGLE_PRICING,
+    anthropic: ANTHROPIC_PRICING
+  },
+  fallback: {
+    inputPricePerMillion: 1,
+    outputPricePerMillion: 5
+  }
+};
+var DEFAULT_FALLBACK_PRICING = {
+  inputPricePerMillion: 1,
+  outputPricePerMillion: 5
+};
+
+// src/pricing/config.ts
+var globalConfig;
+function getPricingConfig() {
+  return globalConfig;
+}
+
+// src/pricing/calculator.ts
+var TOKENS_PER_MILLION = 1e6;
+function getModelPricing(model, provider, providerPricing) {
+  if (providerPricing?.[model]) {
+    return providerPricing[model];
+  }
+  const globalConfig2 = getPricingConfig();
+  const defaultProviderPricing = DEFAULT_PRICING_CONFIG.providers[provider];
+  if (defaultProviderPricing?.[model]) {
+    return defaultProviderPricing[model];
+  }
+  return globalConfig2?.fallback ?? DEFAULT_PRICING_CONFIG.fallback ?? DEFAULT_FALLBACK_PRICING;
+}
+function validateCostParams(params) {
+  const { inputTokens, outputTokens, cachedInputTokens = 0 } = params;
+  if (inputTokens < 0 || outputTokens < 0 || cachedInputTokens < 0) {
+    throw new Error("Token counts must be non-negative");
+  }
+  if (cachedInputTokens > inputTokens) {
+    throw new Error("cachedInputTokens cannot exceed inputTokens");
+  }
+  if (!Number.isFinite(inputTokens) || !Number.isFinite(outputTokens) || !Number.isFinite(cachedInputTokens)) {
+    throw new Error("Token counts must be finite numbers");
+  }
+}
+function calculateCost(params, providerPricing) {
+  validateCostParams(params);
+  const {
+    inputTokens,
+    outputTokens,
+    cachedInputTokens = 0,
+    model,
+    provider
+  } = params;
+  const pricing = getModelPricing(model, provider, providerPricing);
+  const nonCachedInputTokens = inputTokens - cachedInputTokens;
+  const inputCost = nonCachedInputTokens / TOKENS_PER_MILLION * pricing.inputPricePerMillion;
+  const outputCost = outputTokens / TOKENS_PER_MILLION * pricing.outputPricePerMillion;
+  const cachedInputPricePerMillion = pricing.cachedInputPricePerMillion ?? pricing.inputPricePerMillion;
+  const cachedInputCost = cachedInputTokens / TOKENS_PER_MILLION * cachedInputPricePerMillion;
+  return {
+    total: inputCost + outputCost + cachedInputCost,
+    inputCost,
+    outputCost,
+    cachedInputCost
+  };
+}
+function calculateCostFromUsage(usage, model, provider, providerPricing) {
+  return calculateCost(
+    {
+      inputTokens: usage.inputTokens ?? 0,
+      outputTokens: usage.outputTokens ?? 0,
+      cachedInputTokens: usage.inputTokenDetails?.cacheReadTokens ?? 0,
+      model,
+      provider
+    },
+    providerPricing
+  );
+}
+function calculateTotalCost(calls, providerPricing) {
+  const costByModel = {};
+  let totalCost = 0;
+  for (const call of calls) {
+    const cost = calculateCostFromUsage(
+      call.usage,
+      call.model,
+      call.provider,
+      providerPricing
+    );
+    totalCost += cost.total;
+    const key = `${call.provider}/${call.model}`;
+    costByModel[key] = (costByModel[key] ?? 0) + cost.total;
+  }
+  return { totalCost, costByModel };
+}
+
+// src/session/simple-session.ts
+var SimpleSession = class {
+  defaultLanguageModel;
+  modelFactory;
+  providerType;
+  providerPricing;
+  defaultProviderOptions;
+  defaultTools;
+  _fileManager;
+  logger;
+  sessionStartTime;
+  signal;
+  summary;
+  pendingUsagePromises = [];
+  onDoneFns = [];
+  constructor(options) {
+    this.defaultLanguageModel = options.defaultLanguageModel ?? null;
+    this.modelFactory = options.modelFactory ?? null;
+    this.providerType = options.providerType;
+    this.providerPricing = options.providerPricing;
+    this.defaultProviderOptions = options.defaultProviderOptions;
+    this.defaultTools = options.defaultTools;
+    this._fileManager = options.fileManager;
+    this.logger = options.logger ?? noopLogger;
+    this.sessionStartTime = options.startTime ?? Date.now();
+    this.signal = options.signal;
+    this.summary = SessionSummary.empty(this.sessionStartTime);
+  }
+  getModel(requestedModelId) {
+    if (requestedModelId) {
+      if (!this.modelFactory) {
+        throw new Error(
+          `Model '${requestedModelId}' requested but no modelFactory provided. Either use the default model or configure the provider with modelFactory.`
+        );
+      }
+      return this.modelFactory(requestedModelId);
+    }
+    if (!this.defaultLanguageModel) {
+      throw new Error(
+        "No model specified and no default model set. Either specify a model in the call or configure the provider with withDefaultModel()."
+      );
+    }
+    return this.defaultLanguageModel;
+  }
+  extractModelId(model) {
+    const modelWithId = model;
+    if (!modelWithId.modelId) {
+      console.warn(
+        '[SimpleSession] Model does not have modelId property, using "unknown". This may affect cost tracking accuracy.'
+      );
+    }
+    return modelWithId.modelId ?? "unknown";
+  }
+  async generateText(params) {
+    const callStartTime = Date.now();
+    const { model: requestedModel, providerOptions, tools, ...restParams } = params;
+    const languageModel = this.getModel(requestedModel);
+    const modelId = this.extractModelId(languageModel);
+    const mergedProviderOptions = this.defaultProviderOptions || providerOptions ? merge__default.default({}, this.defaultProviderOptions ?? {}, providerOptions ?? {}) : void 0;
+    const mergedTools = this.defaultTools || tools ? { ...this.defaultTools, ...tools } : void 0;
+    this.logger.onLLMCallStart?.({
+      type: "llm_call_start",
+      callType: "generateText",
+      modelId,
+      timestamp: callStartTime,
+      request: { params: restParams }
+    });
+    try {
+      const result = await ai.generateText({
+        ...restParams,
+        tools: mergedTools,
+        providerOptions: mergedProviderOptions,
+        model: languageModel,
+        abortSignal: this.signal
+      });
+      const callEndTime = Date.now();
+      const call = {
+        startTime: callStartTime,
+        endTime: callEndTime,
+        duration: callEndTime - callStartTime,
+        usage: result.usage ?? createZeroUsage(),
+        type: "generateText",
+        model: modelId,
+        provider: this.providerType
+      };
+      this.updateSummaryWithLLMCall(call);
+      this.logger.onLLMCallEnd?.({
+        type: "llm_call_end",
+        callType: "generateText",
+        modelId,
+        timestamp: callEndTime,
+        response: {
+          duration: callEndTime - callStartTime,
+          usage: result.usage,
+          raw: result
+        }
+      });
+      return result;
+    } catch (error) {
+      const callEndTime = Date.now();
+      this.logger.onLLMCallEnd?.({
+        type: "llm_call_end",
+        callType: "generateText",
+        modelId,
+        timestamp: callEndTime,
+        response: {
+          duration: callEndTime - callStartTime,
+          raw: null,
+          error: error instanceof Error ? error : new Error(String(error))
+        }
+      });
+      throw error;
+    }
+  }
+  streamText(params) {
+    const callStartTime = Date.now();
+    const { model: requestedModel, providerOptions, tools, ...restParams } = params;
+    const languageModel = this.getModel(requestedModel);
+    const modelId = this.extractModelId(languageModel);
+    const mergedProviderOptions = this.defaultProviderOptions || providerOptions ? merge__default.default({}, this.defaultProviderOptions ?? {}, providerOptions ?? {}) : void 0;
+    const mergedTools = this.defaultTools || tools ? { ...this.defaultTools, ...tools } : void 0;
+    this.logger.onLLMCallStart?.({
+      type: "llm_call_start",
+      callType: "streamText",
+      modelId,
+      timestamp: callStartTime,
+      request: { params: restParams }
+    });
+    const result = ai.streamText({
+      ...restParams,
+      tools: mergedTools,
+      providerOptions: mergedProviderOptions,
+      model: languageModel,
+      abortSignal: this.signal
+    });
+    const usagePromise = Promise.resolve(result.usage).then((usage) => {
+      const callEndTime = Date.now();
+      const call = {
+        startTime: callStartTime,
+        endTime: callEndTime,
+        duration: callEndTime - callStartTime,
+        usage: usage ?? createZeroUsage(),
+        type: "streamText",
+        model: modelId,
+        provider: this.providerType
+      };
+      this.updateSummaryWithLLMCall(call);
+      this.logger.onLLMCallEnd?.({
+        type: "llm_call_end",
+        callType: "streamText",
+        modelId,
+        timestamp: callEndTime,
+        response: {
+          duration: callEndTime - callStartTime,
+          usage,
+          raw: result
+        }
+      });
+      return usage;
+    });
+    this.pendingUsagePromises.push(usagePromise);
+    return result;
+  }
+  get fileManager() {
+    return this._fileManager;
+  }
+  record(data) {
+    this.summary = this.summary.withCustomRecord(data);
+  }
+  recordToolCall(toolCallSummary) {
+    this.summary = this.summary.withToolCall(toolCallSummary);
+  }
+  recordLLMCall(record) {
+    const call = {
+      ...record,
+      type: record.type ?? "manual"
+    };
+    this.updateSummaryWithLLMCall(call);
+  }
+  recordAdditionalCost(cost) {
+    this.summary = this.summary.withAdditionalCost({
+      ...cost,
+      timestamp: Date.now()
+    });
+  }
+  setMetadata(keyOrData, value) {
+    if (typeof keyOrData === "string") {
+      this.summary = this.summary.withMetadata(keyOrData, value);
+    } else {
+      for (const [k, v] of Object.entries(keyOrData)) {
+        this.summary = this.summary.withMetadata(k, v);
+      }
+    }
+  }
+  updateSummaryWithLLMCall(call) {
+    const newCalls = [...this.summary.llmCalls, call];
+    const { totalCost: llmCost, costByModel } = calculateTotalCost(
+      newCalls.map((c) => ({ usage: c.usage, model: c.model, provider: c.provider })),
+      this.providerPricing
+    );
+    const newTotalUsage = mergeUsages(newCalls.map((c) => c.usage));
+    this.summary = this.summary.withLLMCall(call, llmCost, costByModel, newTotalUsage);
+  }
+  onDone(fn) {
+    this.onDoneFns.push(fn);
+  }
+  async runOnDoneHooks() {
+    const reversedHooks = [...this.onDoneFns].reverse();
+    for (const fn of reversedHooks) {
+      try {
+        await fn();
+      } catch (error) {
+        console.error("[SimpleSession] onDone hook error:", error);
+      }
+    }
+  }
+  async getSummary() {
+    await Promise.all(this.pendingUsagePromises);
+    return this.summary;
+  }
+  /**
+   * Notifies Logger of execution start.
+   * @internal Called by SimpleExecutionHost - not intended for direct use.
+   */
+  notifyExecutionStart() {
+    this._logger.onExecutionStart?.({
+      type: "execution_start",
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Notifies Logger of execution completion with result data and summary.
+   * @param data - The execution result data
+   * @param startTime - Execution start timestamp for duration calculation
+   * @internal Called by SimpleExecutionHost - not intended for direct use.
+   */
+  async notifyExecutionDone(data, startTime) {
+    const summary = await this.getSummary();
+    this._logger.onExecutionDone?.({
+      type: "execution_done",
+      timestamp: Date.now(),
+      duration: Date.now() - startTime,
+      data,
+      summary
+    });
+  }
+  /**
+   * Notifies Logger of execution error with error details and summary (if available).
+   * Gracefully handles getSummary() failures - summary will be undefined if it fails.
+   * @param error - The error that occurred
+   * @param startTime - Execution start timestamp for duration calculation
+   * @internal Called by SimpleExecutionHost - not intended for direct use.
+   */
+  async notifyExecutionError(error, startTime) {
+    let summary;
+    try {
+      summary = await this.getSummary();
+    } catch {
+    }
+    this._logger.onExecutionError?.({
+      type: "execution_error",
+      timestamp: Date.now(),
+      duration: Date.now() - startTime,
+      error,
+      summary
+    });
+  }
+  get _logger() {
+    return this.logger;
+  }
+  get _startTime() {
+    return this.sessionStartTime;
+  }
+  get _modelId() {
+    if (!this.defaultLanguageModel) {
+      return "unknown";
+    }
+    return this.extractModelId(this.defaultLanguageModel);
+  }
+};
+
+// src/session/streaming-session.ts
+var StreamingSession = class extends SimpleSession {
+  lastEventTime;
+  _terminated = false;
+  constructor(options) {
+    super({
+      defaultLanguageModel: options.defaultLanguageModel,
+      modelFactory: options.modelFactory,
+      providerType: options.providerType,
+      providerPricing: options.providerPricing,
+      fileManager: options.fileManager,
+      logger: options.logger,
+      startTime: options.startTime,
+      signal: options.signal,
+      defaultProviderOptions: options.defaultProviderOptions,
+      defaultTools: options.defaultTools
+    });
+    this.lastEventTime = this._startTime;
+    this._logger.onExecutionStart?.({
+      type: "execution_start",
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Emits a streaming event with automatically attached metrics.
+   *
+   * Reserved types ('complete', 'error') throw at runtime - use session.done()
+   * or session.fail() instead.
+   *
+   * @param event - The event to emit (metrics will be added automatically)
+   * @returns The complete event with metrics attached
+   * @throws Error when attempting to emit reserved types ('complete', 'error')
+   */
+  emit(event) {
+    if (this._terminated) {
+      throw new Error("Session already terminated. Cannot call emit() after a terminal operation.");
+    }
+    const eventType = event.type;
+    if (eventType === "complete" || eventType === "error") {
+      throw new Error(
+        `Cannot emit reserved type "${eventType}". Use session.done() for completion or session.fail() for errors.`
+      );
+    }
+    return this.emitInternal(event);
+  }
+  /**
+   * Internal emit method - bypasses reserved type check.
+   * Used by done() and fail() to emit terminal events.
+   */
+  emitInternal(event) {
+    const metrics = this.createMetrics();
+    const fullEvent = { ...event, metrics };
+    this._logger.onExecutionEmit?.({
+      type: "execution_emit",
+      event: fullEvent
+    });
+    return fullEvent;
+  }
+  /**
+   * Signals successful completion of the streaming execution.
+   * Emits a 'complete' event with the result data and session summary.
+   * Also triggers Logger.onExecutionDone for observability.
+   * @param data - The final result data
+   * @returns The complete event with data and summary
+   */
+  async done(data) {
+    if (this._terminated) {
+      throw new Error("Session already terminated. Cannot call done() after a terminal operation.");
+    }
+    this._terminated = true;
+    const summary = await this.getSummary();
+    this._logger.onExecutionDone?.({
+      type: "execution_done",
+      timestamp: Date.now(),
+      duration: summary.totalDuration,
+      data,
+      summary
+    });
+    return this.emitInternal({
+      type: "complete",
+      data,
+      summary
+    });
+  }
+  /**
+   * Signals that the streaming execution failed with an error.
+   * Emits an 'error' event and triggers Logger.onExecutionError for observability.
+   * Gracefully handles getSummary() failures - summary will be undefined if it fails.
+   * @param error - The error that caused the failure
+   * @param data - Optional partial result data (if any was produced before failure)
+   * @returns The error event
+   */
+  async fail(error, data) {
+    if (this._terminated) {
+      throw new Error("Session already terminated. Cannot call fail() after a terminal operation.");
+    }
+    this._terminated = true;
+    let summary;
+    try {
+      summary = await this.getSummary();
+    } catch {
+    }
+    this._logger.onExecutionError?.({
+      type: "execution_error",
+      timestamp: Date.now(),
+      duration: summary?.totalDuration ?? Date.now() - this._startTime,
+      error,
+      data,
+      summary
+    });
+    const errorEvent = {
+      type: "error",
+      error
+    };
+    if (summary) {
+      errorEvent.summary = summary;
+    }
+    if (data !== void 0) {
+      errorEvent.data = data;
+    }
+    return this.emitInternal(errorEvent);
+  }
+  createMetrics() {
+    const now = Date.now();
+    const metrics = {
+      timestamp: now,
+      elapsedMs: now - this._startTime,
+      deltaMs: now - this.lastEventTime
+    };
+    this.lastEventTime = now;
+    return metrics;
+  }
+};
+
+// src/errors/utils.ts
+function wrapAsError(error, ErrorClass, options) {
+  const cause = error instanceof Error ? error : new Error(String(error));
+  return new ErrorClass(cause.message, { ...options, cause });
+}
+
+// src/errors/types.ts
+var AgtlantisError = class extends Error {
+  code;
+  cause;
+  context;
+  constructor(message, options) {
+    super(message);
+    this.name = "AgtlantisError";
+    this.code = options.code;
+    this.cause = options.cause;
+    this.context = options.context;
+    const ErrorWithCapture = Error;
+    ErrorWithCapture.captureStackTrace?.(this, this.constructor);
+  }
+  get isRetryable() {
+    return false;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      isRetryable: this.isRetryable,
+      context: this.context,
+      cause: this.cause?.message,
+      stack: this.stack
+    };
+  }
+};
+var FileError = class _FileError extends AgtlantisError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: options.code ?? "FILE_ERROR" /* FILE_ERROR */,
+      cause: options.cause,
+      context: options.context
+    });
+    this.name = "FileError";
+  }
+  static from(error, code = "FILE_ERROR" /* FILE_ERROR */, context) {
+    if (error instanceof _FileError) {
+      return error;
+    }
+    return wrapAsError(error, _FileError, { code, context });
+  }
+};
+
+// src/provider/noop-file-manager.ts
+var NoOpFileManager = class {
+  upload(_files) {
+    throw new FileError("File upload not supported by this provider", {
+      code: "UNSUPPORTED_TYPE" /* UNSUPPORTED_TYPE */,
+      context: {
+        provider: "noop",
+        suggestion: "Use a provider with file support (e.g., Google) or pass files inline"
+      }
+    });
+  }
+  delete(_fileId) {
+    throw new FileError("File delete not supported by this provider", {
+      code: "UNSUPPORTED_TYPE" /* UNSUPPORTED_TYPE */,
+      context: {
+        provider: "noop"
+      }
+    });
+  }
+  clear() {
+    return Promise.resolve();
+  }
+  getUploadedFiles() {
+    return [];
+  }
+};
+
+// src/testing/mock-provider.ts
+var MockProvider = class _MockProvider extends BaseProvider {
+  calls = [];
+  modelSource;
+  fileManagerInstance;
+  loggerInstance;
+  defaultModelId;
+  pricingConfig;
+  providerTypeId;
+  constructor(config) {
+    super();
+    if (!config.model && !config.modelFactory) {
+      throw new Error("MockProvider requires either model or modelFactory");
+    }
+    this.modelSource = config.modelFactory ?? config.model;
+    this.fileManagerInstance = config.fileManager ?? new NoOpFileManager();
+    this.loggerInstance = config.logger ?? noopLogger;
+    this.defaultModelId = null;
+    this.providerTypeId = config.providerType ?? "mock";
+  }
+  /**
+   * Creates instance for fluent API without calling constructor.
+   * Shares calls array between fluent instances for tracking.
+   */
+  static createWithConfig(modelSource, fileManager, logger, defaultModelId, pricingConfig, providerType, existingCalls) {
+    const provider = Object.create(_MockProvider.prototype);
+    Object.assign(provider, {
+      modelSource,
+      fileManagerInstance: fileManager,
+      loggerInstance: logger,
+      defaultModelId,
+      pricingConfig,
+      providerTypeId: providerType,
+      calls: existingCalls
+    });
+    return provider;
+  }
+  getCalls() {
+    return [...this.calls];
+  }
+  clearCalls() {
+    this.calls.length = 0;
+  }
+  withDefaultModel(modelId) {
+    return _MockProvider.createWithConfig(
+      this.modelSource,
+      this.fileManagerInstance,
+      this.loggerInstance,
+      modelId,
+      this.pricingConfig,
+      this.providerTypeId,
+      this.calls
+    );
+  }
+  withLogger(logger) {
+    return _MockProvider.createWithConfig(
+      this.modelSource,
+      this.fileManagerInstance,
+      logger,
+      this.defaultModelId,
+      this.pricingConfig,
+      this.providerTypeId,
+      this.calls
+    );
+  }
+  withPricing(pricing) {
+    return _MockProvider.createWithConfig(
+      this.modelSource,
+      this.fileManagerInstance,
+      this.loggerInstance,
+      this.defaultModelId,
+      pricing,
+      this.providerTypeId,
+      this.calls
+    );
+  }
+  /**
+   * Mock implementation - returns same provider since mocks don't use provider options.
+   */
+  withDefaultOptions(_options) {
+    return this;
+  }
+  createSimpleSession(signal) {
+    return new SimpleSession({ ...this.buildSessionConfig(), signal });
+  }
+  createStreamingSession(signal) {
+    return new StreamingSession({ ...this.buildSessionConfig(), signal });
+  }
+  buildSessionConfig() {
+    const effectiveModelId = this.defaultModelId ?? "default";
+    return {
+      defaultLanguageModel: this.createTrackingModel(effectiveModelId),
+      modelFactory: (modelId) => this.createTrackingModel(modelId),
+      providerType: this.providerTypeId,
+      providerPricing: this.pricingConfig,
+      fileManager: this.fileManagerInstance,
+      logger: this.loggerInstance
+    };
+  }
+  getBaseModel(modelId) {
+    if (typeof this.modelSource === "function") {
+      return this.modelSource(modelId);
+    }
+    return this.modelSource;
+  }
+  createTrackingModel(modelId) {
+    const baseModel = this.getBaseModel(modelId);
+    const calls = this.calls;
+    return {
+      ...baseModel,
+      specificationVersion: baseModel.specificationVersion,
+      provider: baseModel.provider,
+      modelId: baseModel.modelId,
+      supportedUrls: baseModel.supportedUrls,
+      doGenerate: async (params) => {
+        calls.push({
+          modelId,
+          type: "generate",
+          timestamp: Date.now(),
+          params
+        });
+        return baseModel.doGenerate(params);
+      },
+      doStream: async (params) => {
+        calls.push({
+          modelId,
+          type: "stream",
+          timestamp: Date.now(),
+          params
+        });
+        return baseModel.doStream(params);
+      }
+    };
+  }
+};
+function createMockProvider(configOrModel) {
+  if (typeof configOrModel === "function") {
+    return new MockProvider({ modelFactory: configOrModel });
+  }
+  if (configOrModel instanceof test.MockLanguageModelV3) {
+    return new MockProvider({ model: configOrModel });
+  }
+  return new MockProvider(configOrModel);
+}
+
+// src/testing/mock.ts
+var DEFAULT_USAGE = {
+  inputTokens: { total: 0, noCache: 0, cacheRead: void 0, cacheWrite: void 0 },
+  outputTokens: { total: 0, text: 0, reasoning: void 0 }
+};
+var DEFAULT_FINISH = {
+  unified: "stop",
+  raw: void 0
+};
+var mock = {
+  /**
+   * Creates a MockLanguageModelV3 that returns text content.
+   *
+   * @param text - The text to return from generateText
+   * @param options - Optional overrides for usage, finishReason, etc.
+   *
+   * @example
+   * const model = mock.text('Hello, world!');
+   *
+   * @example
+   * // With custom usage for cost calculation tests
+   * const model = mock.text('Hello', {
+   *   usage: {
+   *     inputTokens: { total: 100 },
+   *     outputTokens: { total: 50 },
+   *   },
+   * });
+   */
+  text(text, options) {
+    return new test.MockLanguageModelV3({
+      doGenerate: async () => ({
+        content: [{ type: "text", text }],
+        finishReason: options?.finishReason ?? DEFAULT_FINISH,
+        usage: options?.usage ?? DEFAULT_USAGE,
+        warnings: options?.warnings ?? [],
+        providerMetadata: options?.providerMetadata
+      })
+    });
+  },
+  /**
+   * Creates a MockLanguageModelV3 that returns JSON content.
+   *
+   * Automatically stringifies the data. Use with generateObject or
+   * generateText + Output.object.
+   *
+   * @param data - The object to return as JSON
+   * @param options - Optional overrides for usage, finishReason, etc.
+   *
+   * @example
+   * const model = mock.json({ name: 'Alice', age: 30 });
+   */
+  json(data, options) {
+    return mock.text(JSON.stringify(data), options);
+  },
+  /**
+   * Creates a MockLanguageModelV3 that streams text chunks.
+   *
+   * @param chunks - Array of text strings to stream
+   * @param options - Optional overrides for finishReason, usage, etc.
+   *
+   * @example
+   * const model = mock.stream(['Hello', ', ', 'world!']);
+   */
+  stream(chunks, options) {
+    return new test.MockLanguageModelV3({
+      doStream: async () => ({
+        stream: test.simulateReadableStream({
+          chunks: [
+            { type: "text-start", id: "text-1" },
+            ...chunks.map((chunk) => ({
+              type: "text-delta",
+              id: "text-1",
+              delta: chunk
+            })),
+            { type: "text-end", id: "text-1" },
+            {
+              type: "finish",
+              finishReason: options?.finishReason ?? DEFAULT_FINISH,
+              usage: options?.usage ?? DEFAULT_USAGE,
+              logprobs: void 0
+            }
+          ]
+        })
+      })
+    });
+  },
+  /**
+   * Creates a MockLanguageModelV3 that throws an error.
+   *
+   * @param error - The error to throw
+   *
+   * @example
+   * const model = mock.error(new Error('Rate limit exceeded'));
+   *
+   * await expect(generateText({ model, prompt: 'Hi' }))
+   *   .rejects.toThrow('Rate limit exceeded');
+   */
+  error(error) {
+    return new test.MockLanguageModelV3({
+      doGenerate: async () => {
+        throw error;
+      },
+      doStream: async () => {
+        throw error;
+      }
+    });
+  },
+  /**
+   * Creates a MockProvider with call tracking.
+   *
+   * Supports three input styles:
+   * - Single model: `mock.provider(mock.text('Hello'))`
+   * - Model factory: `mock.provider((modelId) => mock.text(modelId))`
+   * - Full config: `mock.provider({ model, fileManager, logger })`
+   *
+   * @example
+   * ```typescript
+   * // Basic usage
+   * const provider = mock.provider(mock.text('Hello!'));
+   * const execution = provider.simpleExecution(async (session) => {
+   *   const { text } = await session.generateText({ prompt: 'Say hi' });
+   *   return text;
+   * });
+   * expect(await execution.toResult()).toBe('Hello!');
+   * expect(provider.getCalls()).toHaveLength(1);
+   *
+   * // With model factory for different responses per model
+   * const provider = mock.provider((modelId) => {
+   *   if (modelId === 'gpt-4') return mock.text('GPT-4 response');
+   *   return mock.text('Default response');
+   * });
+   * ```
+   */
+  provider(configOrModel) {
+    return createMockProvider(configOrModel);
+  }
+};
+
+// src/execution/testing/helpers.ts
+function createAbortScenario() {
+  const controller = new AbortController();
+  return {
+    controller,
+    signal: controller.signal,
+    abort: (reason) => controller.abort(reason),
+    isAborted: () => controller.signal.aborted
+  };
+}
+function createAlreadyAbortedSignal(reason = "Already aborted") {
+  const controller = new AbortController();
+  controller.abort(reason);
+  return controller.signal;
+}
+function createSimpleGenerator(result, events = []) {
+  return async function* (session) {
+    for (const event of events) {
+      yield session.emit(event);
+    }
+    return session.done(result);
+  };
+}
+function createErrorGenerator(error, eventsBeforeError = []) {
+  return async function* (session) {
+    for (const event of eventsBeforeError) {
+      yield session.emit(event);
+    }
+    throw error;
+  };
+}
+function createCancelableGenerator(abortScenario, onCancel, eventsBeforeWait = []) {
+  return async function* (session) {
+    for (const event of eventsBeforeWait) {
+      yield session.emit(event);
+    }
+    await new Promise((_, reject) => {
+      const signal = abortScenario.signal;
+      if (signal.aborted) {
+        onCancel?.();
+        reject(new DOMException("Aborted", "AbortError"));
+        return;
+      }
+      signal.addEventListener("abort", () => {
+        onCancel?.();
+        reject(new DOMException("Aborted", "AbortError"));
+      });
+    });
+  };
+}
+function createCancelableFunction(abortScenario, onCancel) {
+  return async () => {
+    await new Promise((_, reject) => {
+      const signal = abortScenario.signal;
+      if (signal.aborted) {
+        onCancel?.();
+        reject(new DOMException("Aborted", "AbortError"));
+        return;
+      }
+      signal.addEventListener("abort", () => {
+        onCancel?.();
+        reject(new DOMException("Aborted", "AbortError"));
+      });
+    });
+    return "should-not-reach";
+  };
+}
+function createDelayedGenerator(delayMs, result, abortScenario) {
+  return async function* (session) {
+    await new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(resolve, delayMs);
+      if (abortScenario) {
+        abortScenario.signal.addEventListener("abort", () => {
+          clearTimeout(timeoutId);
+          reject(new DOMException("Aborted", "AbortError"));
+        });
+      }
+    });
+    return session.done(result);
+  };
+}
+function createSlowGenerator(events, delayBetweenEventsMs, abortScenario) {
+  return async function* (session) {
+    for (const event of events) {
+      if (abortScenario?.isAborted()) {
+        throw new DOMException("Aborted", "AbortError");
+      }
+      await new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(resolve, delayBetweenEventsMs);
+        if (abortScenario) {
+          if (abortScenario.signal.aborted) {
+            clearTimeout(timeoutId);
+            reject(new DOMException("Aborted", "AbortError"));
+            return;
+          }
+          abortScenario.signal.addEventListener(
+            "abort",
+            () => {
+              clearTimeout(timeoutId);
+              reject(new DOMException("Aborted", "AbortError"));
+            },
+            { once: true }
+          );
+        }
+      });
+      yield session.emit(event);
+    }
+    return void 0;
+  };
+}
+async function collectStreamAsync(stream) {
+  const collected = [];
+  for await (const event of stream) {
+    collected.push(event);
+  }
+  return collected;
+}
+function createNeverEndingGenerator(eventsBeforeWait = [], abortScenario) {
+  return async function* (session) {
+    for (const event of eventsBeforeWait) {
+      yield session.emit(event);
+    }
+    await new Promise((_, reject) => {
+      if (abortScenario) {
+        if (abortScenario.signal.aborted) {
+          reject(new DOMException("Aborted", "AbortError"));
+          return;
+        }
+        abortScenario.signal.addEventListener(
+          "abort",
+          () => reject(new DOMException("Aborted", "AbortError")),
+          { once: true }
+        );
+      }
+    });
+    return void 0;
+  };
+}
+function createOrderTrackingLogger() {
+  const callOrder = [];
+  const logger = {
+    onLLMCallStart: () => {
+    },
+    onLLMCallEnd: () => {
+    },
+    onExecutionStart: () => {
+      callOrder.push("start");
+    },
+    onExecutionEmit: () => {
+      callOrder.push("emit");
+    },
+    onExecutionDone: () => {
+      callOrder.push("done");
+    },
+    onExecutionError: () => {
+      callOrder.push("error");
+    }
+  };
+  return {
+    logger,
+    getCallOrder: () => [...callOrder]
+  };
+}
+
+// src/execution/testing/fixtures.ts
+var TEST_PROVIDER_TYPE = "google";
+var noop = () => {
+};
+var noopFactory = () => noop;
+function createNoopWithReturn(value) {
+  return () => value;
+}
+function createNoopAsync(value) {
+  return () => Promise.resolve(value);
+}
+function createMockModel(options = {}) {
+  const { mockFn = noopFactory } = options;
+  return {
+    specificationVersion: "v1",
+    provider: "test-provider",
+    modelId: "test-model",
+    defaultObjectGenerationMode: "json",
+    doGenerate: mockFn(),
+    doStream: mockFn()
+  };
+}
+function createMockFileManager(options = {}) {
+  const { mockFn } = options;
+  if (mockFn) {
+    return {
+      upload: mockFn(),
+      delete: mockFn(),
+      clear: mockFn(),
+      getUploadedFiles: mockFn()
+    };
+  }
+  return {
+    upload: createNoopAsync([]),
+    delete: createNoopAsync(void 0),
+    clear: createNoopAsync(void 0),
+    getUploadedFiles: createNoopWithReturn([])
+  };
+}
+function createMockLogger(options = {}) {
+  const { mockFn = noopFactory } = options;
+  return {
+    onLLMCallStart: mockFn(),
+    onLLMCallEnd: mockFn(),
+    onExecutionStart: mockFn(),
+    onExecutionEmit: mockFn(),
+    onExecutionDone: mockFn(),
+    onExecutionError: mockFn()
+  };
+}
+function createMockUsage2(overrides = {}) {
+  return {
+    inputTokens: 100,
+    outputTokens: 50,
+    totalTokens: 150,
+    inputTokenDetails: {
+      noCacheTokens: 100,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0
+    },
+    outputTokenDetails: {
+      textTokens: 50,
+      reasoningTokens: 0
+    },
+    ...overrides
+  };
+}
+function createSimpleSessionFactory(options = {}) {
+  const { mockFn, logger } = options;
+  return (signal) => new SimpleSession({
+    defaultLanguageModel: createMockModel({ mockFn }),
+    providerType: TEST_PROVIDER_TYPE,
+    fileManager: createMockFileManager({ mockFn }),
+    signal,
+    logger
+  });
+}
+function createStreamingSessionFactory(options = {}) {
+  const { mockFn, logger } = options;
+  return () => new StreamingSession({
+    defaultLanguageModel: createMockModel({ mockFn }),
+    providerType: TEST_PROVIDER_TYPE,
+    fileManager: createMockFileManager({ mockFn }),
+    logger
+  });
+}
+function createStreamingSessionFactoryWithSignal(options = {}) {
+  const { mockFn, logger, onSignalCapture } = options;
+  return (signal) => {
+    onSignalCapture?.(signal);
+    return new StreamingSession({
+      defaultLanguageModel: createMockModel({ mockFn }),
+      providerType: TEST_PROVIDER_TYPE,
+      fileManager: createMockFileManager({ mockFn }),
+      signal,
+      logger
+    });
+  };
+}
+async function collectEvents2(stream) {
+  const events = [];
+  for await (const event of stream) {
+    events.push(event);
+  }
+  return events;
+}
+function createControllablePromise() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+// src/testing/test-execution.ts
+function createTestMetrics() {
+  return { timestamp: Date.now(), elapsedMs: 0, deltaMs: 0 };
+}
+function createTestExecution(result, events = []) {
+  const summary = SessionSummary.forTest({});
+  const completionEvent = {
+    type: "complete",
+    data: result,
+    summary,
+    metrics: createTestMetrics()
+  };
+  const allEvents = [
+    ...events.map(
+      (e) => ({ ...e, metrics: createTestMetrics() })
+    ),
+    completionEvent
+  ];
+  return {
+    stream() {
+      return {
+        [Symbol.asyncIterator]() {
+          let index = 0;
+          return {
+            async next() {
+              if (index < allEvents.length) {
+                return { value: allEvents[index++], done: false };
+              }
+              return { value: void 0, done: true };
+            }
+          };
+        }
+      };
+    },
+    async result() {
+      return { status: "succeeded", value: result, events: allEvents, summary };
+    },
+    cancel() {
+    },
+    async cleanup() {
+    },
+    async [Symbol.asyncDispose]() {
+    }
+  };
+}
+function createTestErrorExecution(error, options = {}) {
+  const summary = SessionSummary.forTest({});
+  const errorEvent = {
+    type: "error",
+    error,
+    summary,
+    metrics: createTestMetrics()
+  };
+  if (options.data !== void 0) {
+    errorEvent.data = options.data;
+  }
+  const typedErrorEvent = errorEvent;
+  const allEvents = [
+    ...(options.events ?? []).map(
+      (e) => ({ ...e, metrics: createTestMetrics() })
+    ),
+    typedErrorEvent
+  ];
+  return {
+    stream() {
+      return {
+        [Symbol.asyncIterator]() {
+          let index = 0;
+          return {
+            async next() {
+              if (index < allEvents.length) {
+                return { value: allEvents[index++], done: false };
+              }
+              return { value: void 0, done: true };
+            }
+          };
+        }
+      };
+    },
+    async result() {
+      return { status: "failed", error, events: allEvents, summary };
+    },
+    cancel() {
+    },
+    async cleanup() {
+    },
+    async [Symbol.asyncDispose]() {
+    }
+  };
+}
+function createTestCanceledExecution(events = []) {
+  const summary = SessionSummary.forTest({});
+  const allEvents = events.map(
+    (e) => ({ ...e, metrics: createTestMetrics() })
+  );
+  return {
+    stream() {
+      return {
+        [Symbol.asyncIterator]() {
+          let index = 0;
+          return {
+            async next() {
+              if (index < allEvents.length) {
+                return { value: allEvents[index++], done: false };
+              }
+              return { value: void 0, done: true };
+            }
+          };
+        }
+      };
+    },
+    async result() {
+      return { status: "canceled", events: allEvents, summary };
+    },
+    cancel() {
+    },
+    async cleanup() {
+    },
+    async [Symbol.asyncDispose]() {
+    }
+  };
+}
+
+Object.defineProperty(exports, "MockLanguageModelV3", {
+  enumerable: true,
+  get: function () { return test.MockLanguageModelV3; }
+});
+Object.defineProperty(exports, "simulateReadableStream", {
+  enumerable: true,
+  get: function () { return test.simulateReadableStream; }
+});
+exports.MockProvider = MockProvider;
+exports.TEST_API_KEY = TEST_API_KEY;
+exports.TEST_PROVIDER_TYPE = TEST_PROVIDER_TYPE;
+exports.collectEvents = collectEvents;
+exports.collectExecutionEvents = collectEvents2;
+exports.collectStreamAsync = collectStreamAsync;
+exports.consumeExecution = consumeExecution;
+exports.createAbortScenario = createAbortScenario;
+exports.createAlreadyAbortedSignal = createAlreadyAbortedSignal;
+exports.createCancelableFunction = createCancelableFunction;
+exports.createCancelableGenerator = createCancelableGenerator;
+exports.createControllablePromise = createControllablePromise;
+exports.createDelayedGenerator = createDelayedGenerator;
+exports.createErrorGenerator = createErrorGenerator;
+exports.createMockFileManager = createMockFileManager;
+exports.createMockLanguageModelUsage = createMockUsage2;
+exports.createMockLogger = createMockLogger;
+exports.createMockModel = createMockModel;
+exports.createMockProvider = createMockProvider;
+exports.createMockSessionSummary = createMockSessionSummary;
+exports.createMockUsage = createMockUsage;
+exports.createNeverEndingGenerator = createNeverEndingGenerator;
+exports.createOrderTrackingLogger = createOrderTrackingLogger;
+exports.createSimpleGenerator = createSimpleGenerator;
+exports.createSimpleSessionFactory = createSimpleSessionFactory;
+exports.createSlowGenerator = createSlowGenerator;
+exports.createStreamingSessionFactory = createStreamingSessionFactory;
+exports.createStreamingSessionFactoryWithSignal = createStreamingSessionFactoryWithSignal;
+exports.createTestCanceledExecution = createTestCanceledExecution;
+exports.createTestErrorExecution = createTestErrorExecution;
+exports.createTestEvent = createTestEvent;
+exports.createTestExecution = createTestExecution;
+exports.expectFileManagerInterface = expectFileManagerInterface;
+exports.mock = mock;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map