@agtlantis/core 0.5.0 → 0.5.1

package/dist/testing/index.cjs

@@ -1,2167 +0,0 @@
-'use strict';
-
-var test = require('ai/test');
-var ai = require('ai');
-
-// 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/utils/deep-merge.ts
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function deepMerge(...sources) {
-  const result = {};
-  for (const source of sources) {
-    if (!source) continue;
-    for (const key of Object.keys(source)) {
-      const existing = result[key];
-      const incoming = source[key];
-      result[key] = isPlainObject(existing) && isPlainObject(incoming) ? deepMerge(existing, incoming) : incoming;
-    }
-  }
-  return result;
-}
-
-// 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;
-  defaultGenerationOptions;
-  _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.defaultGenerationOptions = options.defaultGenerationOptions;
-    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 ? deepMerge(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({
-        ...this.defaultGenerationOptions,
-        ...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 ? deepMerge(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({
-      ...this.defaultGenerationOptions,
-      ...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,
-      defaultGenerationOptions: options.defaultGenerationOptions
-    });
-    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;
-  }
-  /**
-   * Mock implementation - returns same provider since mocks don't use generation options.
-   */
-  withDefaultGenerationOptions(_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