@agtlantis/core 0.5.0 → 0.5.1

package/dist/index.cjs

@@ -1,3085 +0,0 @@
-'use strict';
-
-var ai = require('ai');
-var zod = require('zod');
-var Handlebars = require('handlebars');
-var fs = require('fs/promises');
-var path3 = require('path');
-var yaml = require('yaml');
-var crypto = require('crypto');
-var google = require('@ai-sdk/google');
-var genai = require('@google/genai');
-var openai = require('@ai-sdk/openai');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var Handlebars__default = /*#__PURE__*/_interopDefault(Handlebars);
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
-var path3__namespace = /*#__PURE__*/_interopNamespace(path3);
-var yaml__namespace = /*#__PURE__*/_interopNamespace(yaml);
-
-// 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 ExecutionErrorCode = /* @__PURE__ */ ((ExecutionErrorCode2) => {
-  ExecutionErrorCode2["EXECUTION_ERROR"] = "EXECUTION_ERROR";
-  ExecutionErrorCode2["STREAM_ERROR"] = "STREAM_ERROR";
-  ExecutionErrorCode2["RESULT_EXTRACTION_ERROR"] = "RESULT_EXTRACTION_ERROR";
-  ExecutionErrorCode2["CANCELLED"] = "CANCELLED";
-  ExecutionErrorCode2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
-  return ExecutionErrorCode2;
-})(ExecutionErrorCode || {});
-var ConfigurationErrorCode = /* @__PURE__ */ ((ConfigurationErrorCode2) => {
-  ConfigurationErrorCode2["CONFIG_ERROR"] = "CONFIG_ERROR";
-  ConfigurationErrorCode2["MISSING_API_KEY"] = "MISSING_API_KEY";
-  ConfigurationErrorCode2["INVALID_CONFIG"] = "INVALID_CONFIG";
-  ConfigurationErrorCode2["MISSING_REQUIRED"] = "MISSING_REQUIRED";
-  return ConfigurationErrorCode2;
-})(ConfigurationErrorCode || {});
-var FileErrorCode = /* @__PURE__ */ ((FileErrorCode2) => {
-  FileErrorCode2["FILE_ERROR"] = "FILE_ERROR";
-  FileErrorCode2["UPLOAD_ERROR"] = "UPLOAD_ERROR";
-  FileErrorCode2["DELETE_ERROR"] = "DELETE_ERROR";
-  FileErrorCode2["NOT_FOUND"] = "NOT_FOUND";
-  FileErrorCode2["TOO_LARGE"] = "TOO_LARGE";
-  FileErrorCode2["UNSUPPORTED_TYPE"] = "UNSUPPORTED_TYPE";
-  return FileErrorCode2;
-})(FileErrorCode || {});
-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 ExecutionError = class _ExecutionError extends AgtlantisError {
-  constructor(message, options = {}) {
-    super(message, {
-      code: options.code ?? "EXECUTION_ERROR" /* EXECUTION_ERROR */,
-      cause: options.cause,
-      context: options.context
-    });
-    this.name = "ExecutionError";
-  }
-  static from(error, code = "EXECUTION_ERROR" /* EXECUTION_ERROR */, context) {
-    if (error instanceof _ExecutionError) {
-      return error;
-    }
-    return wrapAsError(error, _ExecutionError, { code, context });
-  }
-};
-var ConfigurationError = class _ConfigurationError extends AgtlantisError {
-  constructor(message, options = {}) {
-    super(message, {
-      code: options.code ?? "CONFIG_ERROR" /* CONFIG_ERROR */,
-      cause: options.cause,
-      context: options.context
-    });
-    this.name = "ConfigurationError";
-  }
-  static from(error, code = "CONFIG_ERROR" /* CONFIG_ERROR */, context) {
-    if (error instanceof _ConfigurationError) {
-      return error;
-    }
-    return wrapAsError(error, _ConfigurationError, { code, context });
-  }
-};
-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/execution/constants.ts
-var ERRORS = {
-  ALREADY_CONSUMED: "Execution already consumed",
-  METADATA_NOT_AVAILABLE: "Metadata not available yet. Consume the execution first.",
-  NO_RESULT: "No result available",
-  UNKNOWN_ERROR: "Execution failed with unknown error"
-};
-
-// src/execution/utils.ts
-function getDuration(startTime) {
-  return Date.now() - startTime;
-}
-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((resolve2, reject) => {
-      res = resolve2;
-      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 determineResultStatus(cancelRequested, aborted, hasError) {
-  if (cancelRequested || aborted) {
-    return "canceled";
-  }
-  if (hasError) {
-    return "failed";
-  }
-  return "succeeded";
-}
-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/execution/mapping.ts
-function mapExecution(execution, fn) {
-  if ("stream" in execution) {
-    return mapStreamingExecution(execution, fn);
-  }
-  return mapSimpleExecution(execution, fn);
-}
-function mapExecutionResult(execution, fn) {
-  if ("stream" in execution) {
-    return mapStreamingExecutionResult(execution, fn);
-  }
-  return mapSimpleExecution(execution, fn);
-}
-function mapStreamingExecution(execution, fn) {
-  return {
-    stream() {
-      const original = execution.stream();
-      return {
-        [Symbol.asyncIterator]() {
-          const iter = original[Symbol.asyncIterator]();
-          return {
-            async next() {
-              const { value, done } = await iter.next();
-              if (done) return { value: void 0, done: true };
-              const event = value;
-              if (event.type === "error") {
-                return { value: event, done: false };
-              }
-              const { metrics, ...pureEvent } = event;
-              try {
-                const mapped = await fn(pureEvent);
-                return {
-                  value: { ...mapped, metrics },
-                  done: false
-                };
-              } catch (err) {
-                const errorEvent = {
-                  type: "error",
-                  error: normalizeError(err),
-                  metrics
-                };
-                return { value: errorEvent, done: false };
-              }
-            }
-          };
-        }
-      };
-    },
-    async result() {
-      const original = await execution.result();
-      if (original.status !== "succeeded") {
-        return original;
-      }
-      try {
-        const mappedEvents = [];
-        for (const event of original.events) {
-          if (event.type === "error") {
-            mappedEvents.push(event);
-            continue;
-          }
-          const { metrics, ...pureEvent } = event;
-          const mapped = await fn(pureEvent);
-          mappedEvents.push({ ...mapped, metrics });
-        }
-        const completionEvent = mappedEvents.find((e) => e.type === "complete");
-        return {
-          status: "succeeded",
-          value: completionEvent.data,
-          events: mappedEvents,
-          summary: original.summary
-        };
-      } catch (err) {
-        return {
-          status: "failed",
-          error: normalizeError(err),
-          events: original.events,
-          summary: original.summary
-        };
-      }
-    },
-    cancel: () => execution.cancel(),
-    cleanup: () => execution.cleanup(),
-    [Symbol.asyncDispose]: () => execution[Symbol.asyncDispose]()
-  };
-}
-function mapStreamingExecutionResult(execution, fn) {
-  return {
-    stream() {
-      const original = execution.stream();
-      return {
-        [Symbol.asyncIterator]() {
-          const iter = original[Symbol.asyncIterator]();
-          return {
-            async next() {
-              const { value, done } = await iter.next();
-              if (done) return { value: void 0, done: true };
-              const event = value;
-              if (event.type === "complete") {
-                const { metrics, ...rest } = event;
-                try {
-                  const mapped = await fn(rest.data);
-                  return {
-                    value: { type: "complete", data: mapped, summary: rest.summary, metrics },
-                    done: false
-                  };
-                } catch (err) {
-                  const errorEvent = {
-                    type: "error",
-                    error: normalizeError(err),
-                    metrics
-                  };
-                  return { value: errorEvent, done: false };
-                }
-              }
-              return { value: event, done: false };
-            }
-          };
-        }
-      };
-    },
-    async result() {
-      const original = await execution.result();
-      if (original.status !== "succeeded") {
-        return original;
-      }
-      try {
-        const mapped = await fn(original.value);
-        const mappedEvents = original.events.map((event) => {
-          if (event.type === "complete") {
-            return { ...event, data: mapped };
-          }
-          return event;
-        });
-        return {
-          status: "succeeded",
-          value: mapped,
-          events: mappedEvents,
-          summary: original.summary
-        };
-      } catch (err) {
-        return {
-          status: "failed",
-          error: normalizeError(err),
-          events: original.events,
-          summary: original.summary
-        };
-      }
-    },
-    cancel: () => execution.cancel(),
-    cleanup: () => execution.cleanup(),
-    [Symbol.asyncDispose]: () => execution[Symbol.asyncDispose]()
-  };
-}
-function mapSimpleExecution(execution, fn) {
-  return {
-    async result() {
-      const original = await execution.result();
-      if (original.status !== "succeeded") {
-        return original;
-      }
-      try {
-        const mapped = await fn(original.value);
-        return {
-          status: "succeeded",
-          value: mapped,
-          summary: original.summary
-        };
-      } catch (err) {
-        return {
-          status: "failed",
-          error: normalizeError(err),
-          summary: original.summary
-        };
-      }
-    },
-    cancel: () => execution.cancel(),
-    cleanup: () => execution.cleanup(),
-    [Symbol.asyncDispose]: () => execution[Symbol.asyncDispose]()
-  };
-}
-
-// src/observability/logger.ts
-var noopLogger = {};
-function createLogger(handlers) {
-  return handlers;
-}
-var TOOL_DESCRIPTIONS = {
-  reportProgress: "[OPTIONAL] Report progress during task execution. Use this to show intermediate work. You may call this multiple times, then you MUST call tools::submitResult.",
-  submitResult: "[REQUIRED] Submit the final result. You MUST call this exactly once to complete the task. Without this call, the task FAILS."
-};
-var TOOL_CALLING_PROTOCOL = `## CRITICAL INSTRUCTION - READ CAREFULLY
-
-You have 2 tools available:
-1. reportProgress - [OPTIONAL] Show intermediate work (multiple times)
-2. submitResult - [REQUIRED] Submit your final answer
-
-\u26A0\uFE0F IMPORTANT RULES:
-- You may call reportProgress 0-3 times to show progress
-- You MUST call submitResult exactly once to complete the task
-- After calling reportProgress, you MUST call submitResult in your NEXT response
-- If you call reportProgress more than 3 times without submitResult, the task FAILS
-- The task is NOT complete until submitResult is called
-
-CORRECT SEQUENCE:
-1. [Optional] reportProgress
-2. [Required] submitResult (exactly once)
-
-\u274C WRONG: reportProgress \u2192 reportProgress \u2192 reportProgress \u2192 reportProgress (no submitResult = FAIL)
-\u2705 CORRECT: reportProgress \u2192 submitResult (SUCCESS)`;
-function defineProgressivePattern(config) {
-  return new ProgressivePattern(config.progressSchema, config.resultSchema);
-}
-var ProgressivePattern = class {
-  constructor(progressSchema, resultSchema) {
-    this.progressSchema = progressSchema;
-    this.resultSchema = resultSchema;
-  }
-  lastParseError = null;
-  /**
-   * Runs the pattern within an existing session. Use this for composing
-   * multiple patterns or when you need fine-grained control over the session.
-   *
-   * @param session - The streaming session to run within
-   * @param options - Stream options including:
-   *   - `stopWhen` - Additional stop conditions (combined with default `hasToolCall('submitResult')`)
-   *   - `protocol` - Custom protocol instructions (replaces default `TOOL_CALLING_PROTOCOL`)
-   *   - All other `streamText` options except `tools`, `toolChoice`, `stopWhen`
-   *
-   * @example Basic usage
-   * ```typescript
-   * provider.streamingExecution(async function*(session) {
-   *   yield* pattern.runInSession(session, {
-   *     system: 'You are an analyzer.',
-   *     messages: [{ role: 'user', content: 'Analyze...' }],
-   *   });
-   * });
-   * ```
-   *
-   * @example With custom stopWhen
-   * ```typescript
-   * yield* pattern.runInSession(session, {
-   *   prompt: 'Analyze...',
-   *   stopWhen: stepCountIs(5), // Combined: submitResult OR 5 steps
-   * });
-   * ```
-   */
-  async *runInSession(session, options) {
-    const {
-      tools: userTools,
-      system,
-      stopWhen: userStopWhen,
-      protocol,
-      ...restOptions
-    } = options;
-    const internalTools = this.createTools();
-    const allTools = { ...userTools, ...internalTools };
-    const systemString = typeof system === "string" ? system : void 0;
-    const fullSystem = this.renderSystemPrompt(systemString, protocol);
-    const defaultStopCondition = ai.hasToolCall("submitResult");
-    const stopConditions = this.combineStopConditions(defaultStopCondition, userStopWhen);
-    const stream = session.streamText({
-      ...restOptions,
-      system: fullSystem,
-      tools: allTools,
-      toolChoice: "required",
-      stopWhen: stopConditions
-    });
-    let result = null;
-    for await (const part of stream.fullStream) {
-      if (part.type === "tool-call") {
-        if (part.toolName === "reportProgress") {
-          const input = "input" in part ? part.input : void 0;
-          const progressData = this.parseProgressInput(input);
-          if (progressData !== null) {
-            yield session.emit({
-              type: "progress",
-              data: progressData
-            });
-          }
-        } else if (part.toolName === "submitResult") {
-          const input = "input" in part ? part.input : void 0;
-          result = this.parseResultInput(input);
-        }
-      }
-    }
-    if (result === null) {
-      const baseMsg = "ProgressivePattern: No result received.";
-      const detail = this.lastParseError ? ` Last parse error: ${this.lastParseError.message}` : " The LLM did not call submitResult tool.";
-      throw new Error(baseMsg + detail);
-    }
-    const completeEvent = await session.done(result);
-    yield completeEvent;
-    return completeEvent;
-  }
-  /**
-   * Standalone execution that creates a new session internally.
-   * Use this for simple, single-pattern executions.
-   *
-   * @param provider - The AI provider to use
-   * @param options - Stream options including:
-   *   - `stopWhen` - Additional stop conditions (combined with default `hasToolCall('submitResult')`)
-   *   - `protocol` - Custom protocol instructions (replaces default `TOOL_CALLING_PROTOCOL`)
-   *
-   * @example Basic usage
-   * ```typescript
-   * for await (const event of pattern.run(provider, {
-   *   system: 'You are an analyzer.',
-   *   prompt: 'Analyze this document...',
-   * })) {
-   *   if (event.type === 'progress') {
-   *     console.log('Progress:', event.data);
-   *   } else if (event.type === 'complete') {
-   *     console.log('Result:', event.data);
-   *   }
-   * }
-   * ```
-   *
-   * @example With step limit
-   * ```typescript
-   * import { stepCountIs } from 'ai';
-   *
-   * for await (const event of pattern.run(provider, {
-   *   prompt: 'Analyze...',
-   *   stopWhen: stepCountIs(10),
-   * })) { ... }
-   * ```
-   */
-  run(provider, options) {
-    const self = this;
-    const execution = provider.streamingExecution(async function* (session) {
-      return yield* self.runInSession(session, options);
-    });
-    return execution.stream();
-  }
-  createTools() {
-    return {
-      reportProgress: ai.tool({
-        description: TOOL_DESCRIPTIONS.reportProgress,
-        inputSchema: zod.z.object({
-          data: this.progressSchema
-        }),
-        execute: async () => ({
-          status: "progress_recorded",
-          instruction: "After all progress reports, you MUST call tools::submitResult to complete the task."
-        })
-      }),
-      submitResult: ai.tool({
-        description: TOOL_DESCRIPTIONS.submitResult,
-        inputSchema: zod.z.object({
-          data: this.resultSchema
-        }),
-        execute: async () => ({
-          status: "result_submitted",
-          message: "Task completed successfully."
-        })
-      })
-    };
-  }
-  parseJsonWrapper(input, schema) {
-    try {
-      if (!input || typeof input !== "object") return null;
-      const wrapper = input;
-      if (wrapper.data === void 0) return null;
-      const parsed = typeof wrapper.data === "string" ? JSON.parse(wrapper.data) : wrapper.data;
-      return schema.parse(parsed);
-    } catch (error) {
-      this.lastParseError = error instanceof Error ? error : new Error(String(error));
-      return null;
-    }
-  }
-  parseProgressInput(input) {
-    return this.parseJsonWrapper(input, this.progressSchema);
-  }
-  parseResultInput(input) {
-    return this.parseJsonWrapper(input, this.resultSchema);
-  }
-  combineStopConditions(defaultCondition, userConditions) {
-    if (!userConditions) {
-      return [defaultCondition];
-    }
-    const userArray = Array.isArray(userConditions) ? userConditions : [userConditions];
-    return [defaultCondition, ...userArray];
-  }
-  renderSystemPrompt(userSystem, protocol) {
-    const protocolText = protocol ?? TOOL_CALLING_PROTOCOL;
-    return userSystem ? `${userSystem}
-
-${protocolText}` : protocolText;
-  }
-};
-
-// src/pricing/validator.ts
-function validatePriceValue(value, fieldName, context) {
-  if (!Number.isFinite(value)) {
-    throw new Error(`${context}: ${fieldName} must be a finite number`);
-  }
-  if (value < 0) {
-    throw new Error(`${context}: ${fieldName} cannot be negative`);
-  }
-}
-function validateModelPricing(pricing, context) {
-  validatePriceValue(
-    pricing.inputPricePerMillion,
-    "inputPricePerMillion",
-    context
-  );
-  validatePriceValue(
-    pricing.outputPricePerMillion,
-    "outputPricePerMillion",
-    context
-  );
-  if (pricing.cachedInputPricePerMillion !== void 0) {
-    validatePriceValue(
-      pricing.cachedInputPricePerMillion,
-      "cachedInputPricePerMillion",
-      context
-    );
-  }
-}
-function validateProviderPricing(pricing, providerContext) {
-  for (const [model, modelPricing] of Object.entries(pricing)) {
-    const context = providerContext ? `${providerContext}/${model}` : model;
-    validateModelPricing(modelPricing, context);
-  }
-}
-function validatePricingConfig(config) {
-  if (config.providers) {
-    for (const [providerKey, pricing] of Object.entries(config.providers)) {
-      if (pricing) {
-        validateProviderPricing(pricing, providerKey);
-      }
-    }
-  }
-  if (config.fallback) {
-    validateModelPricing(config.fallback, "fallback");
-  }
-}
-
-// 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 configurePricing(config) {
-  if (config) {
-    validatePricingConfig(config);
-  }
-  globalConfig = config;
-}
-function getPricingConfig() {
-  return globalConfig;
-}
-function resetPricingConfig() {
-  globalConfig = void 0;
-}
-function getEffectivePricing(model, provider) {
-  if (globalConfig?.providers?.[provider]?.[model]) {
-    return {
-      pricing: globalConfig.providers[provider][model],
-      source: "global"
-    };
-  }
-  const defaultPricing = DEFAULT_PRICING_CONFIG.providers[provider];
-  if (defaultPricing?.[model]) {
-    return {
-      pricing: defaultPricing[model],
-      source: "default"
-    };
-  }
-  return {
-    pricing: globalConfig?.fallback ?? DEFAULT_PRICING_CONFIG.fallback ?? DEFAULT_FALLBACK_PRICING,
-    source: "fallback"
-  };
-}
-
-// src/pricing/calculator.ts
-var TOKENS_PER_MILLION = 1e6;
-function getModelPricing(model, provider, providerPricing) {
-  if (providerPricing?.[model]) {
-    return providerPricing[model];
-  }
-  const globalConfig2 = getPricingConfig();
-  if (globalConfig2?.providers?.[provider]?.[model]) {
-    return globalConfig2.providers[provider][model];
-  }
-  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/prompt/errors.ts
-var PromptErrorCode = /* @__PURE__ */ ((PromptErrorCode2) => {
-  PromptErrorCode2["PROMPT_ERROR"] = "PROMPT_ERROR";
-  PromptErrorCode2["NOT_FOUND"] = "PROMPT_NOT_FOUND";
-  PromptErrorCode2["INVALID_FORMAT"] = "PROMPT_INVALID_FORMAT";
-  PromptErrorCode2["TEMPLATE_ERROR"] = "PROMPT_TEMPLATE_ERROR";
-  PromptErrorCode2["IO_ERROR"] = "PROMPT_IO_ERROR";
-  return PromptErrorCode2;
-})(PromptErrorCode || {});
-var PromptError = class _PromptError extends AgtlantisError {
-  constructor(message, options = {}) {
-    super(message, {
-      code: options.code ?? "PROMPT_ERROR" /* PROMPT_ERROR */,
-      cause: options.cause,
-      context: options.context
-    });
-    this.name = "PromptError";
-  }
-  /**
-   * Creates a PromptError from an unknown error.
-   */
-  static from(error, code = "PROMPT_ERROR" /* PROMPT_ERROR */, context) {
-    if (error instanceof _PromptError) {
-      return error;
-    }
-    const cause = error instanceof Error ? error : new Error(String(error));
-    return new _PromptError(cause.message, { code, cause, context });
-  }
-};
-var PromptNotFoundError = class extends PromptError {
-  promptId;
-  version;
-  constructor(promptId, version, options = {}) {
-    const message = version ? `Prompt '${promptId}' version '${version}' not found` : `Prompt '${promptId}' not found`;
-    super(message, {
-      code: "PROMPT_NOT_FOUND" /* NOT_FOUND */,
-      cause: options.cause,
-      context: { promptId, version, ...options.context }
-    });
-    this.name = "PromptNotFoundError";
-    this.promptId = promptId;
-    this.version = version;
-  }
-};
-var PromptInvalidFormatError = class extends PromptError {
-  promptId;
-  details;
-  constructor(promptId, details, options = {}) {
-    super(`Invalid format for prompt '${promptId}': ${details}`, {
-      code: "PROMPT_INVALID_FORMAT" /* INVALID_FORMAT */,
-      cause: options.cause,
-      context: { promptId, details, ...options.context }
-    });
-    this.name = "PromptInvalidFormatError";
-    this.promptId = promptId;
-    this.details = details;
-  }
-};
-var PromptTemplateError = class extends PromptError {
-  promptId;
-  details;
-  constructor(promptId, details, options = {}) {
-    super(`Template compilation failed for prompt '${promptId}': ${details}`, {
-      code: "PROMPT_TEMPLATE_ERROR" /* TEMPLATE_ERROR */,
-      cause: options.cause,
-      context: { promptId, details, ...options.context }
-    });
-    this.name = "PromptTemplateError";
-    this.promptId = promptId;
-    this.details = details;
-  }
-};
-var PromptIOError = class extends PromptError {
-  operation;
-  path;
-  constructor(operation, path5, options = {}) {
-    const opText = operation === "list" ? "list prompts in" : `${operation} prompt file`;
-    super(`Failed to ${opText}: ${path5}`, {
-      code: "PROMPT_IO_ERROR" /* IO_ERROR */,
-      cause: options.cause,
-      context: { operation, path: path5, ...options.context }
-    });
-    this.name = "PromptIOError";
-    this.operation = operation;
-    this.path = path5;
-  }
-};
-
-// src/prompt/template.ts
-var handlebars = Handlebars__default.default.create();
-handlebars.registerHelper("add", (a, b) => {
-  const numA = Number(a);
-  const numB = Number(b);
-  if (Number.isNaN(numA) || Number.isNaN(numB)) {
-    return NaN;
-  }
-  return numA + numB;
-});
-function wrapTemplateError(promptId, error) {
-  const message = error instanceof Error ? error.message : String(error);
-  const cause = error instanceof Error ? error : void 0;
-  return new PromptTemplateError(promptId, message, { cause });
-}
-function compileTemplate(template, promptId) {
-  try {
-    const compiled = handlebars.compile(template, {
-      strict: true,
-      noEscape: true
-    });
-    return (input) => {
-      try {
-        return compiled(input);
-      } catch (error) {
-        throw wrapTemplateError(promptId, error);
-      }
-    };
-  } catch (error) {
-    throw wrapTemplateError(promptId, error);
-  }
-}
-
-// src/prompt/prompt-template.ts
-var PromptTemplate = class _PromptTemplate {
-  constructor(id, version, system, userTemplate) {
-    this.id = id;
-    this.version = version;
-    this.system = system;
-    this.userTemplate = userTemplate;
-  }
-  /**
-   * Creates a PromptTemplate instance from raw data.
-   *
-   * @param data - Raw prompt template data
-   * @returns PromptTemplate instance
-   */
-  static from(data) {
-    return new _PromptTemplate(data.id, data.version, data.system, data.userTemplate);
-  }
-  /**
-   * Compiles templates and returns a PromptRenderer.
-   *
-   * @typeParam TSystemInput - Type of input for system prompt template
-   * @typeParam TUserInput - Type of input for user prompt template (defaults to TSystemInput)
-   * @returns Compiled prompt renderer with renderSystemPrompt and renderUserPrompt functions
-   * @throws {PromptTemplateError} If template compilation fails
-   *
-   * @example
-   * ```typescript
-   * // Different input types for system and user prompts
-   * const renderer = template.compile<SessionCtx, TurnCtx>();
-   *
-   * // Same input type for both
-   * const simpleRenderer = template.compile<CommonCtx>();
-   * ```
-   */
-  compile() {
-    return {
-      id: this.id,
-      version: this.version,
-      renderSystemPrompt: compileTemplate(this.system, this.id),
-      renderUserPrompt: compileTemplate(this.userTemplate, this.id)
-    };
-  }
-  /**
-   * Returns raw data representation.
-   * Useful for serialization or passing to repository.write().
-   */
-  toData() {
-    return {
-      id: this.id,
-      version: this.version,
-      system: this.system,
-      userTemplate: this.userTemplate
-    };
-  }
-};
-function toErrorCause(error) {
-  return error instanceof Error ? error : void 0;
-}
-function toErrorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-var defaultFileSystem = {
-  readFile: (filePath) => fs__namespace.readFile(filePath, "utf-8"),
-  writeFile: (filePath, content) => fs__namespace.writeFile(filePath, content, "utf-8"),
-  readdir: (dirPath) => fs__namespace.readdir(dirPath)
-};
-function parseVersion(version) {
-  const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
-  if (!match) return null;
-  return [parseInt(match[1], 10), parseInt(match[2], 10), parseInt(match[3], 10)];
-}
-function compareVersions(a, b) {
-  const parsedA = parseVersion(a);
-  const parsedB = parseVersion(b);
-  if (!parsedA && !parsedB) return 0;
-  if (!parsedA) return 1;
-  if (!parsedB) return -1;
-  for (let i = 0; i < 3; i++) {
-    if (parsedA[i] !== parsedB[i]) {
-      return parsedA[i] - parsedB[i];
-    }
-  }
-  return 0;
-}
-var FILE_EXTENSION = ".yaml";
-function getFileName(id, version) {
-  return `${id}-${version}${FILE_EXTENSION}`;
-}
-function parseFileName(fileName) {
-  if (!fileName.endsWith(FILE_EXTENSION)) return null;
-  const baseName = fileName.slice(0, -FILE_EXTENSION.length);
-  const lastDash = baseName.lastIndexOf("-");
-  if (lastDash === -1) return null;
-  const id = baseName.slice(0, lastDash);
-  const version = baseName.slice(lastDash + 1);
-  if (!id || !parseVersion(version)) return null;
-  return { id, version };
-}
-function parsePromptYaml(content, promptId) {
-  let parsed;
-  try {
-    parsed = yaml__namespace.parse(content);
-  } catch (error) {
-    throw new PromptInvalidFormatError(promptId, `Invalid YAML: ${toErrorMessage(error)}`, {
-      cause: toErrorCause(error)
-    });
-  }
-  if (!parsed || typeof parsed !== "object") {
-    throw new PromptInvalidFormatError(promptId, "Expected YAML object");
-  }
-  const obj = parsed;
-  const requiredFields = ["id", "version", "system", "userTemplate"];
-  for (const field of requiredFields) {
-    if (typeof obj[field] !== "string") {
-      throw new PromptInvalidFormatError(
-        promptId,
-        `Missing or invalid required field: ${field} (expected string)`
-      );
-    }
-  }
-  return {
-    id: obj.id,
-    version: obj.version,
-    system: obj.system,
-    userTemplate: obj.userTemplate
-  };
-}
-function serializePromptYaml(content) {
-  return yaml__namespace.stringify(content);
-}
-var FilePromptRepository = class {
-  directory;
-  fileSystem;
-  cacheEnabled;
-  contentCache = /* @__PURE__ */ new Map();
-  constructor(options) {
-    this.directory = options.directory;
-    this.fileSystem = options.fs ?? defaultFileSystem;
-    this.cacheEnabled = options.cache ?? true;
-  }
-  /**
-   * Generates file name from prompt id and version.
-   * Override this along with `parseFileName` to change file naming convention.
-   */
-  getFileName(id, version) {
-    return getFileName(id, version);
-  }
-  /**
-   * Parses file name into id and version.
-   * Override this along with `getFileName` to change file naming convention.
-   */
-  parseFileName(fileName) {
-    return parseFileName(fileName);
-  }
-  /**
-   * Parses raw file content into PromptTemplateData.
-   * Override this to support different file formats (e.g., JSON, TOML).
-   */
-  parseContent(content, promptId) {
-    return parsePromptYaml(content, promptId);
-  }
-  /**
-   * Serializes PromptTemplateData to file content string.
-   * Override this to support different file formats (e.g., JSON, TOML).
-   */
-  serializeContent(content) {
-    return serializePromptYaml(content);
-  }
-  getCacheKey(id, version) {
-    return `${id}:${version}`;
-  }
-  async read(id, version) {
-    if (version) {
-      const cacheKey = this.getCacheKey(id, version);
-      if (this.cacheEnabled) {
-        const cached = this.contentCache.get(cacheKey);
-        if (cached) {
-          return cached;
-        }
-      }
-      const fileName = this.getFileName(id, version);
-      const filePath = path3__namespace.join(this.directory, fileName);
-      let content;
-      try {
-        content = await this.fileSystem.readFile(filePath);
-      } catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-          throw new PromptNotFoundError(id, version);
-        }
-        throw new PromptIOError("read", filePath, { cause: toErrorCause(error) });
-      }
-      const promptTemplate = this.parseContent(content, id);
-      if (promptTemplate.id !== id || promptTemplate.version !== version) {
-        throw new PromptInvalidFormatError(
-          id,
-          `File content mismatch: expected id='${id}' version='${version}', got id='${promptTemplate.id}' version='${promptTemplate.version}'`
-        );
-      }
-      if (this.cacheEnabled) {
-        this.contentCache.set(cacheKey, promptTemplate);
-      }
-      return promptTemplate;
-    }
-    let files;
-    try {
-      files = await this.fileSystem.readdir(this.directory);
-    } catch (error) {
-      throw new PromptIOError("list", this.directory, { cause: toErrorCause(error) });
-    }
-    const versions = [];
-    for (const file of files) {
-      const parsed = this.parseFileName(file);
-      if (parsed && parsed.id === id) {
-        versions.push(parsed.version);
-      }
-    }
-    if (versions.length === 0) {
-      throw new PromptNotFoundError(id);
-    }
-    versions.sort((a, b) => compareVersions(b, a));
-    const latestVersion = versions[0];
-    return this.read(id, latestVersion);
-  }
-  async write(content) {
-    if (this.cacheEnabled) {
-      this.contentCache.delete(this.getCacheKey(content.id, content.version));
-    }
-    const fileName = this.getFileName(content.id, content.version);
-    const filePath = path3__namespace.join(this.directory, fileName);
-    if (!parseVersion(content.version)) {
-      throw new PromptInvalidFormatError(
-        content.id,
-        `Invalid version format: '${content.version}' (expected semver like '1.0.0')`
-      );
-    }
-    compileTemplate(content.system, content.id);
-    compileTemplate(content.userTemplate, content.id);
-    const yamlContent = this.serializeContent(content);
-    try {
-      await this.fileSystem.writeFile(filePath, yamlContent);
-    } catch (error) {
-      throw new PromptIOError("write", filePath, { cause: toErrorCause(error) });
-    }
-  }
-};
-function createFilePromptRepository(options) {
-  return new FilePromptRepository(options);
-}
-
-// src/provider/types.ts
-var FILE_SOURCE_TYPES = /* @__PURE__ */ new Set(["path", "data", "base64", "url"]);
-function isFileSource(v) {
-  return typeof v === "object" && v !== null && FILE_SOURCE_TYPES.has(v.source);
-}
-function isFileSourcePath(v) {
-  return v.source === "path";
-}
-function isFileSourceData(v) {
-  return v.source === "data";
-}
-function isFileSourceBase64(v) {
-  return v.source === "base64";
-}
-function isFileSourceUrl(v) {
-  return v.source === "url";
-}
-async function computeFileSourceHash(source) {
-  if (source.hash) {
-    return source.hash;
-  }
-  const hash = crypto.createHash("sha256");
-  switch (source.source) {
-    case "path": {
-      const fullPath = path3__namespace.default.isAbsolute(source.path) ? source.path : path3__namespace.default.resolve(process.cwd(), source.path);
-      const content = await fs.readFile(fullPath);
-      hash.update(content);
-      break;
-    }
-    case "data": {
-      hash.update(source.data);
-      break;
-    }
-    case "base64": {
-      const buffer = Buffer.from(source.data, "base64");
-      hash.update(buffer);
-      break;
-    }
-    case "url": {
-      hash.update(source.url);
-      break;
-    }
-  }
-  return hash.digest("hex");
-}
-
-// src/provider/file-cache.ts
-var InMemoryFileCache = class {
-  cache = /* @__PURE__ */ new Map();
-  defaultTTL;
-  constructor(options) {
-    this.defaultTTL = options?.defaultTTL;
-  }
-  get(hash) {
-    const entry = this.cache.get(hash);
-    if (!entry) return null;
-    if (entry.expiresAt !== void 0 && Date.now() > entry.expiresAt) {
-      this.cache.delete(hash);
-      return null;
-    }
-    return entry.file;
-  }
-  set(hash, file, ttl) {
-    const effectiveTTL = ttl ?? this.defaultTTL;
-    const expiresAt = effectiveTTL !== void 0 ? Date.now() + effectiveTTL : void 0;
-    this.cache.set(hash, { file, expiresAt });
-  }
-  delete(hash) {
-    this.cache.delete(hash);
-  }
-  clear() {
-    this.cache.clear();
-  }
-};
-
-// 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/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 [];
-  }
-};
-var EXTENSION_TO_MIME = {
-  ".pdf": "application/pdf",
-  ".html": "text/html",
-  ".htm": "text/html",
-  ".txt": "text/plain",
-  ".json": "application/json",
-  ".xml": "application/xml",
-  ".csv": "text/csv",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".svg": "image/svg+xml",
-  ".bmp": "image/bmp",
-  ".zip": "application/zip"
-};
-function inferMediaType(filePath) {
-  const ext = path3__namespace.extname(filePath).toLowerCase();
-  return EXTENSION_TO_MIME[ext];
-}
-function scanForFileSources(input, currentPath = []) {
-  if (isFileSource(input)) {
-    return [{ part: input, path: currentPath }];
-  }
-  if (input === null || typeof input !== "object") {
-    return [];
-  }
-  if (Buffer.isBuffer(input) || input instanceof Uint8Array || input instanceof URL) {
-    return [];
-  }
-  const results = [];
-  if (Array.isArray(input)) {
-    for (let i = 0; i < input.length; i++) {
-      results.push(...scanForFileSources(input[i], [...currentPath, i]));
-    }
-  } else {
-    for (const key of Object.keys(input)) {
-      results.push(
-        ...scanForFileSources(input[key], [
-          ...currentPath,
-          key
-        ])
-      );
-    }
-  }
-  return results;
-}
-var DEFAULT_MAX_SIZE = 50 * 1024 * 1024;
-async function resolveFileSource(part, options = {}) {
-  const { basePath = process.cwd(), maxSize = DEFAULT_MAX_SIZE } = options;
-  if (!isFileSourcePath(part)) {
-    return part;
-  }
-  const fullPath = path3__namespace.isAbsolute(part.path) ? part.path : path3__namespace.resolve(basePath, part.path);
-  const stats = await fs.stat(fullPath).catch((err) => {
-    throw new FileError(`File not found: ${part.path}`, {
-      code: "NOT_FOUND" /* NOT_FOUND */,
-      context: { path: part.path, fullPath },
-      cause: err
-    });
-  });
-  if (stats.size > maxSize) {
-    throw new FileError(`File too large: ${stats.size} bytes > ${maxSize} bytes`, {
-      code: "TOO_LARGE" /* TOO_LARGE */,
-      context: { path: part.path, size: stats.size, maxSize }
-    });
-  }
-  const buffer = await fs.readFile(fullPath);
-  const mediaType = part.mediaType ?? inferMediaType(part.path) ?? "application/octet-stream";
-  const filename = part.filename ?? path3__namespace.basename(part.path);
-  const result = {
-    source: "data",
-    data: buffer,
-    mediaType,
-    filename
-  };
-  return result;
-}
-function deepClone(value) {
-  if (value === null || typeof value !== "object") return value;
-  if (Buffer.isBuffer(value)) return Buffer.from(value);
-  if (value instanceof URL) return new URL(value.href);
-  if (value instanceof Uint8Array) return new Uint8Array(value);
-  if (Array.isArray(value)) return value.map(deepClone);
-  const result = {};
-  for (const key of Object.keys(value)) {
-    result[key] = deepClone(value[key]);
-  }
-  return result;
-}
-function setAtPath(obj, targetPath, value) {
-  if (targetPath.length === 0) {
-    return value;
-  }
-  let current = obj;
-  for (let i = 0; i < targetPath.length - 1; i++) {
-    current = current[targetPath[i]];
-  }
-  current[targetPath[targetPath.length - 1]] = value;
-  return obj;
-}
-async function resolveFileSourcesInInput(input, options = {}) {
-  const found = scanForFileSources(input);
-  if (found.length === 0) {
-    return input;
-  }
-  const resolved = await Promise.all(found.map(({ part }) => resolveFileSource(part, options)));
-  if (found.length === 1 && found[0].path.length === 0) {
-    return resolved[0];
-  }
-  const result = deepClone(input);
-  for (let i = 0; i < found.length; i++) {
-    setAtPath(result, found[i].path, resolved[i]);
-  }
-  return result;
-}
-function getFileSourceDisplayInfo(part) {
-  switch (part.source) {
-    case "path":
-      return {
-        source: "path",
-        description: part.path,
-        mediaType: part.mediaType ?? inferMediaType(part.path) ?? "unknown",
-        filename: part.filename ?? path3__namespace.basename(part.path)
-      };
-    case "url":
-      return {
-        source: "url",
-        description: part.url,
-        mediaType: part.mediaType ?? "unknown",
-        filename: part.filename
-      };
-    case "base64": {
-      const sizeKB = (part.data.length * 3 / 4 / 1024).toFixed(1);
-      return {
-        source: "base64",
-        description: `[base64 data, ~${sizeKB}KB]`,
-        mediaType: part.mediaType,
-        filename: part.filename
-      };
-    }
-    case "data": {
-      const size = Buffer.isBuffer(part.data) ? part.data.length : part.data.length;
-      const sizeKB = (size / 1024).toFixed(1);
-      return {
-        source: "data",
-        description: `[Buffer, ${sizeKB}KB]`,
-        mediaType: part.mediaType,
-        filename: part.filename
-      };
-    }
-  }
-}
-function getFileSourcesDisplayInfo(input) {
-  const found = scanForFileSources(input);
-  return found.map(({ part }) => getFileSourceDisplayInfo(part));
-}
-function assertValidUploadResponse(response, context) {
-  if (!response.name || !response.uri || !response.mimeType) {
-    throw new FileError("Invalid upload response from Google API: missing required fields", {
-      code: "UPLOAD_ERROR" /* UPLOAD_ERROR */,
-      context: {
-        ...context,
-        hasName: !!response.name,
-        hasUri: !!response.uri,
-        hasMediaType: !!response.mimeType
-      }
-    });
-  }
-}
-function isImageMediaType(mediaType) {
-  return mediaType.startsWith("image/");
-}
-function createPart(uri, mediaType) {
-  const url = new URL(uri);
-  if (isImageMediaType(mediaType)) {
-    return { type: "image", image: url, mediaType };
-  }
-  return { type: "file", data: url, mediaType };
-}
-var GoogleFileManager = class {
-  uploadedFiles = [];
-  client;
-  cache;
-  constructor(apiKey, options) {
-    this.client = new genai.GoogleGenAI({ apiKey });
-    this.cache = options?.cache ?? null;
-  }
-  async uploadOne(fileSource, index, hash) {
-    if (this.cache) {
-      const cached = this.cache.get(hash);
-      if (cached) return cached;
-    }
-    if (fileSource.source === "url") {
-      const mediaType = fileSource.mediaType ?? "application/octet-stream";
-      const result = {
-        id: null,
-        part: createPart(fileSource.url, mediaType)
-      };
-      if (this.cache) {
-        this.cache.set(hash, result);
-      }
-      return result;
-    }
-    if (fileSource.source === "path") {
-      const fullPath = path3__namespace.default.isAbsolute(fileSource.path) ? fileSource.path : path3__namespace.default.resolve(process.cwd(), fileSource.path);
-      try {
-        const uploaded = await this.client.files.upload({
-          file: fullPath,
-          config: {
-            mimeType: fileSource.mediaType,
-            displayName: fileSource.filename ?? path3__namespace.default.basename(fileSource.path)
-          }
-        });
-        assertValidUploadResponse(uploaded, {
-          source: "path",
-          path: fileSource.path
-        });
-        const result = {
-          id: uploaded.name,
-          part: createPart(uploaded.uri, uploaded.mimeType)
-        };
-        if (this.cache) {
-          this.cache.set(hash, result);
-        }
-        return result;
-      } catch (error) {
-        if (error instanceof FileError) throw error;
-        throw FileError.from(error, "UPLOAD_ERROR" /* UPLOAD_ERROR */, {
-          source: "path",
-          path: fileSource.path,
-          mediaType: fileSource.mediaType
-        });
-      }
-    }
-    const buffer = fileSource.source === "base64" ? Buffer.from(fileSource.data, "base64") : fileSource.data;
-    const arrayBuffer = buffer.buffer.slice(
-      buffer.byteOffset,
-      buffer.byteOffset + buffer.byteLength
-    );
-    const blob = new Blob([arrayBuffer], { type: fileSource.mediaType });
-    try {
-      const uploaded = await this.client.files.upload({
-        file: blob,
-        config: {
-          mimeType: fileSource.mediaType,
-          displayName: fileSource.filename ?? `upload-${Date.now()}-${index}`
-        }
-      });
-      assertValidUploadResponse(uploaded, {
-        source: fileSource.source,
-        mediaType: fileSource.mediaType
-      });
-      const result = {
-        id: uploaded.name,
-        part: createPart(uploaded.uri, uploaded.mimeType)
-      };
-      if (this.cache) {
-        this.cache.set(hash, result);
-      }
-      return result;
-    } catch (error) {
-      if (error instanceof FileError) throw error;
-      throw FileError.from(error, "UPLOAD_ERROR" /* UPLOAD_ERROR */, {
-        source: fileSource.source,
-        mediaType: fileSource.mediaType,
-        filename: fileSource.filename
-      });
-    }
-  }
-  async upload(files) {
-    const hashes = await Promise.all(files.map((file) => computeFileSourceHash(file)));
-    const results = await Promise.allSettled(
-      files.map((file, i) => this.uploadOne(file, i, hashes[i]))
-    );
-    const successful = [];
-    const failed = [];
-    for (let i = 0; i < results.length; i++) {
-      const result = results[i];
-      if (result.status === "fulfilled") {
-        successful.push({ file: result.value, hash: hashes[i] });
-      } else {
-        failed.push(result);
-      }
-    }
-    if (failed.length > 0) {
-      await Promise.all(
-        successful.filter(({ file }) => file.id !== null).map(async ({ file, hash }) => {
-          await this.client.files.delete({ name: file.id }).catch(() => {
-          });
-          if (this.cache) {
-            this.cache.delete(hash);
-          }
-        })
-      );
-      const firstError = failed[0].reason;
-      throw new FileError(
-        `Failed to upload ${failed.length} file(s): ${firstError instanceof Error ? firstError.message : String(firstError)}`,
-        {
-          code: "UPLOAD_ERROR" /* UPLOAD_ERROR */,
-          cause: firstError instanceof Error ? firstError : void 0,
-          context: {
-            totalFiles: files.length,
-            failedCount: failed.length,
-            successCount: successful.length
-          }
-        }
-      );
-    }
-    this.uploadedFiles.push(...successful.filter(({ file }) => file.id !== null).map(({ file }) => file));
-    return successful.map(({ file }) => file);
-  }
-  async delete(fileId) {
-    try {
-      await this.client.files.delete({ name: fileId });
-      this.uploadedFiles = this.uploadedFiles.filter((f) => f.id !== fileId);
-    } catch (error) {
-      throw FileError.from(error, "DELETE_ERROR" /* DELETE_ERROR */, {
-        fileId
-      });
-    }
-  }
-  async clear() {
-    await Promise.all(
-      this.uploadedFiles.filter((f) => f.id !== null).map((f) => this.delete(f.id).catch(() => {
-      }))
-    );
-    this.uploadedFiles = [];
-  }
-  getUploadedFiles() {
-    return [...this.uploadedFiles];
-  }
-};
-
-// 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/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
-    }
-  };
-}
-function detectProviderType(modelId) {
-  const lowerModel = modelId.toLowerCase();
-  if (lowerModel.startsWith("gpt-") || lowerModel === "o1" || lowerModel.startsWith("o1-") || lowerModel === "o3" || lowerModel.startsWith("o3-")) {
-    return "openai";
-  }
-  if (lowerModel.startsWith("gemini")) {
-    return "google";
-  }
-  if (lowerModel.startsWith("claude")) {
-    return "anthropic";
-  }
-  return void 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/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;
-  }
-};
-function createStreamingSession(options) {
-  const session = new StreamingSession({
-    defaultLanguageModel: options.defaultLanguageModel,
-    providerType: options.providerType,
-    fileManager: options.fileManager,
-    logger: options.logger ?? noopLogger,
-    startTime: options.startTime,
-    signal: options.signal
-  });
-  return session;
-}
-
-// src/provider/google/factory.ts
-var GoogleProvider = class _GoogleProvider extends BaseProvider {
-  constructor(config) {
-    super();
-    this.config = config;
-    this.google = google.createGoogleGenerativeAI({ apiKey: config.apiKey });
-  }
-  google;
-  withDefaultModel(modelId) {
-    return new _GoogleProvider({ ...this.config, defaultModelId: modelId });
-  }
-  withLogger(newLogger) {
-    return new _GoogleProvider({ ...this.config, logger: newLogger });
-  }
-  withPricing(pricing) {
-    validateProviderPricing(pricing, "google");
-    return new _GoogleProvider({ ...this.config, pricingConfig: pricing });
-  }
-  /**
-   * Set default provider-specific options for all LLM calls.
-   * These options will be deep-merged with per-call providerOptions.
-   *
-   * @example
-   * ```typescript
-   * createGoogleProvider({ apiKey: 'xxx' })
-   *   .withDefaultModel('gemini-2.0-flash-thinking-exp')
-   *   .withDefaultOptions({
-   *     thinkingConfig: { includeThoughts: true, thinkingLevel: 'low' }
-   *   })
-   * ```
-   */
-  withDefaultOptions(options) {
-    return new _GoogleProvider({ ...this.config, defaultOptions: options });
-  }
-  withDefaultGenerationOptions(options) {
-    return new _GoogleProvider({ ...this.config, defaultGenOptions: options });
-  }
-  /**
-   * Enable Google Search grounding for all LLM calls.
-   * Allows the model to access real-time web information.
-   *
-   * @example
-   * ```typescript
-   * createGoogleProvider({ apiKey: 'xxx' })
-   *   .withDefaultModel('gemini-2.5-flash')
-   *   .withSearchEnabled()
-   * ```
-   */
-  withSearchEnabled() {
-    return new _GoogleProvider({ ...this.config, searchEnabled: true });
-  }
-  /**
-   * Enable URL Context grounding for all LLM calls.
-   * Allows the model to retrieve and use content from URLs in the prompt.
-   *
-   * @example
-   * ```typescript
-   * createGoogleProvider({ apiKey: 'xxx' })
-   *   .withDefaultModel('gemini-2.5-flash')
-   *   .withUrlContextEnabled()
-   * ```
-   */
-  withUrlContextEnabled() {
-    return new _GoogleProvider({ ...this.config, urlContextEnabled: true });
-  }
-  /**
-   * Set a file cache for reusing uploaded files across sessions.
-   * If no cache is provided, creates a new InMemoryFileCache.
-   *
-   * @example
-   * ```typescript
-   * // Use default InMemoryFileCache
-   * createGoogleProvider({ apiKey: 'xxx' })
-   *   .withFileCache()
-   *
-   * // Use custom cache with TTL
-   * const cache = new InMemoryFileCache({ defaultTTL: 3600000 });
-   * createGoogleProvider({ apiKey: 'xxx' })
-   *   .withFileCache(cache)
-   * ```
-   */
-  withFileCache(cache) {
-    return new _GoogleProvider({ ...this.config, fileCache: cache ?? new InMemoryFileCache() });
-  }
-  getSessionConfig() {
-    const { searchEnabled, urlContextEnabled } = this.config;
-    const defaultTools = {
-      ...searchEnabled && { google_search: this.google.tools.googleSearch({}) },
-      ...urlContextEnabled && { url_context: this.google.tools.urlContext({}) }
-    };
-    const hasDefaultTools = searchEnabled || urlContextEnabled;
-    return {
-      defaultLanguageModel: this.config.defaultModelId ? this.createModel(this.config.defaultModelId) : null,
-      modelFactory: (modelId) => this.createModel(modelId),
-      providerType: "google",
-      providerPricing: this.config.pricingConfig,
-      fileManager: new GoogleFileManager(this.config.apiKey, { cache: this.config.fileCache }),
-      logger: this.config.logger,
-      defaultProviderOptions: this.config.defaultOptions ? { google: this.config.defaultOptions } : void 0,
-      defaultTools: hasDefaultTools ? defaultTools : void 0,
-      defaultGenerationOptions: this.config.defaultGenOptions
-    };
-  }
-  createStreamingSession(signal) {
-    return new StreamingSession({ ...this.getSessionConfig(), signal });
-  }
-  createSimpleSession(signal) {
-    return new SimpleSession({ ...this.getSessionConfig(), signal });
-  }
-  /**
-   * Type assertion needed because @ai-sdk/google's type signature doesn't
-   * include the second parameter, but it's supported at runtime.
-   */
-  createModel(modelId) {
-    if (this.config.safetySettings) {
-      return this.google(modelId, { safetySettings: this.config.safetySettings });
-    }
-    return this.google(modelId);
-  }
-};
-function createGoogleProvider(config) {
-  return new GoogleProvider({
-    apiKey: config.apiKey,
-    defaultModelId: null,
-    logger: noopLogger,
-    safetySettings: config.safetySettings,
-    searchEnabled: false,
-    urlContextEnabled: false
-  });
-}
-var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
-  constructor(config) {
-    super();
-    this.config = config;
-    this.openai = openai.createOpenAI({
-      apiKey: config.apiKey,
-      baseURL: config.baseURL,
-      organization: config.organization
-    });
-  }
-  openai;
-  withDefaultModel(modelId) {
-    return new _OpenAIProvider({ ...this.config, defaultModelId: modelId });
-  }
-  withLogger(newLogger) {
-    return new _OpenAIProvider({ ...this.config, logger: newLogger });
-  }
-  withPricing(pricing) {
-    validateProviderPricing(pricing, "openai");
-    return new _OpenAIProvider({ ...this.config, pricingConfig: pricing });
-  }
-  /**
-   * Set default provider-specific options for all LLM calls.
-   * These options will be deep-merged with per-call providerOptions.
-   *
-   * @example
-   * ```typescript
-   * createOpenAIProvider({ apiKey: 'xxx' })
-   *   .withDefaultModel('gpt-4o')
-   *   .withDefaultOptions({
-   *     reasoningEffort: 'high',
-   *     parallelToolCalls: true,
-   *   })
-   * ```
-   */
-  withDefaultOptions(options) {
-    return new _OpenAIProvider({ ...this.config, defaultOptions: options });
-  }
-  withDefaultGenerationOptions(options) {
-    return new _OpenAIProvider({ ...this.config, defaultGenOptions: options });
-  }
-  /**
-   * Set a file cache for API consistency with GoogleProvider.
-   * Note: OpenAI does not support file caching, so this is a no-op.
-   *
-   * @example
-   * ```typescript
-   * createOpenAIProvider({ apiKey: 'xxx' })
-   *   .withFileCache()
-   * ```
-   */
-  withFileCache(cache) {
-    return new _OpenAIProvider({ ...this.config, fileCache: cache });
-  }
-  getSessionConfig() {
-    return {
-      defaultLanguageModel: this.config.defaultModelId ? this.openai(this.config.defaultModelId) : null,
-      modelFactory: (modelId) => this.openai(modelId),
-      providerType: "openai",
-      providerPricing: this.config.pricingConfig,
-      fileManager: new NoOpFileManager(),
-      logger: this.config.logger,
-      defaultProviderOptions: this.config.defaultOptions ? { openai: this.config.defaultOptions } : void 0,
-      defaultGenerationOptions: this.config.defaultGenOptions
-    };
-  }
-  createStreamingSession(signal) {
-    return new StreamingSession({ ...this.getSessionConfig(), signal });
-  }
-  createSimpleSession(signal) {
-    return new SimpleSession({ ...this.getSessionConfig(), signal });
-  }
-};
-function createOpenAIProvider(config) {
-  return new OpenAIProvider({
-    apiKey: config.apiKey,
-    defaultModelId: null,
-    logger: noopLogger,
-    baseURL: config.baseURL,
-    organization: config.organization
-  });
-}
-
-// src/validation/validation-history.ts
-var ValidationHistory = class {
-  attempts = [];
-  get nextAttempt() {
-    return this.attempts.length + 1;
-  }
-  get last() {
-    return this.attempts.at(-1);
-  }
-  get all() {
-    return this.attempts;
-  }
-  get failureReasons() {
-    return this.attempts.filter((a) => !a.valid && a.reason).map((a) => a.reason);
-  }
-  get isRetry() {
-    return this.attempts.length > 0;
-  }
-  /** Internal use only - not exposed via ReadonlyValidationHistory. */
-  add(result, validation) {
-    this.attempts.push({
-      result,
-      ...validation,
-      attempt: this.attempts.length + 1
-    });
-  }
-};
-
-// src/validation/errors.ts
-var ValidationErrorCode = /* @__PURE__ */ ((ValidationErrorCode2) => {
-  ValidationErrorCode2["VALIDATION_EXHAUSTED"] = "VALIDATION_EXHAUSTED";
-  return ValidationErrorCode2;
-})(ValidationErrorCode || {});
-var ValidationExhaustedError = class extends AgtlantisError {
-  constructor(message, history) {
-    super(message, {
-      code: "VALIDATION_EXHAUSTED" /* VALIDATION_EXHAUSTED */,
-      context: {
-        attempts: history.all.length,
-        failureReasons: history.failureReasons
-      }
-    });
-    this.history = history;
-    this.name = "ValidationExhaustedError";
-  }
-};
-
-// src/validation/with-validation.ts
-async function withValidation(execute, options) {
-  const { validate, maxAttempts: rawMax, signal, retryDelay, onAttempt } = options;
-  const maxAttempts = Math.max(1, rawMax ?? 3);
-  const history = new ValidationHistory();
-  while (history.nextAttempt <= maxAttempts) {
-    signal?.throwIfAborted();
-    const result = await execute(history);
-    const validation = await validate(result, history);
-    history.add(result, validation);
-    onAttempt?.(history.last);
-    if (validation.valid) {
-      return result;
-    }
-    const hasMoreAttempts = history.nextAttempt <= maxAttempts;
-    if (retryDelay && hasMoreAttempts) {
-      await new Promise((resolve2) => setTimeout(resolve2, retryDelay));
-    }
-  }
-  throw new ValidationExhaustedError(
-    `Validation failed after ${history.all.length} attempts`,
-    history
-  );
-}
-
-exports.ANTHROPIC_PRICING = ANTHROPIC_PRICING;
-exports.AgtlantisError = AgtlantisError;
-exports.BaseProvider = BaseProvider;
-exports.ConfigurationError = ConfigurationError;
-exports.ConfigurationErrorCode = ConfigurationErrorCode;
-exports.DEFAULT_FALLBACK_PRICING = DEFAULT_FALLBACK_PRICING;
-exports.DEFAULT_MAX_SIZE = DEFAULT_MAX_SIZE;
-exports.DEFAULT_PRICING_CONFIG = DEFAULT_PRICING_CONFIG;
-exports.ERRORS = ERRORS;
-exports.EXTENSION_TO_MIME = EXTENSION_TO_MIME;
-exports.ExecutionError = ExecutionError;
-exports.ExecutionErrorCode = ExecutionErrorCode;
-exports.FileError = FileError;
-exports.FileErrorCode = FileErrorCode;
-exports.FilePromptRepository = FilePromptRepository;
-exports.GOOGLE_PRICING = GOOGLE_PRICING;
-exports.GoogleFileManager = GoogleFileManager;
-exports.GoogleProvider = GoogleProvider;
-exports.InMemoryFileCache = InMemoryFileCache;
-exports.NoOpFileManager = NoOpFileManager;
-exports.OPENAI_PRICING = OPENAI_PRICING;
-exports.ProgressivePattern = ProgressivePattern;
-exports.PromptError = PromptError;
-exports.PromptErrorCode = PromptErrorCode;
-exports.PromptIOError = PromptIOError;
-exports.PromptInvalidFormatError = PromptInvalidFormatError;
-exports.PromptNotFoundError = PromptNotFoundError;
-exports.PromptTemplate = PromptTemplate;
-exports.PromptTemplateError = PromptTemplateError;
-exports.SessionSummary = SessionSummary;
-exports.SimpleExecutionHost = SimpleExecutionHost;
-exports.SimpleSession = SimpleSession;
-exports.StreamingExecutionHost = StreamingExecutionHost;
-exports.StreamingSession = StreamingSession;
-exports.TOOL_CALLING_PROTOCOL = TOOL_CALLING_PROTOCOL;
-exports.ValidationErrorCode = ValidationErrorCode;
-exports.ValidationExhaustedError = ValidationExhaustedError;
-exports.ValidationHistory = ValidationHistory;
-exports.calculateCost = calculateCost;
-exports.calculateCostFromUsage = calculateCostFromUsage;
-exports.calculateTotalCost = calculateTotalCost;
-exports.combineSignals = combineSignals;
-exports.compileTemplate = compileTemplate;
-exports.computeFileSourceHash = computeFileSourceHash;
-exports.configurePricing = configurePricing;
-exports.createFilePromptRepository = createFilePromptRepository;
-exports.createGoogleProvider = createGoogleProvider;
-exports.createHookRunner = createHookRunner;
-exports.createLogger = createLogger;
-exports.createOpenAIProvider = createOpenAIProvider;
-exports.createStreamingSession = createStreamingSession;
-exports.createZeroUsage = createZeroUsage;
-exports.defineProgressivePattern = defineProgressivePattern;
-exports.detectProviderType = detectProviderType;
-exports.determineResultStatus = determineResultStatus;
-exports.getDuration = getDuration;
-exports.getEffectivePricing = getEffectivePricing;
-exports.getFileSourceDisplayInfo = getFileSourceDisplayInfo;
-exports.getFileSourcesDisplayInfo = getFileSourcesDisplayInfo;
-exports.getModelPricing = getModelPricing;
-exports.getPricingConfig = getPricingConfig;
-exports.inferMediaType = inferMediaType;
-exports.isAbortError = isAbortError;
-exports.isFileSource = isFileSource;
-exports.isFileSourceBase64 = isFileSourceBase64;
-exports.isFileSourceData = isFileSourceData;
-exports.isFileSourcePath = isFileSourcePath;
-exports.isFileSourceUrl = isFileSourceUrl;
-exports.mapExecution = mapExecution;
-exports.mapExecutionResult = mapExecutionResult;
-exports.mergeUsages = mergeUsages;
-exports.noopLogger = noopLogger;
-exports.normalizeError = normalizeError;
-exports.resetPricingConfig = resetPricingConfig;
-exports.resolveFileSource = resolveFileSource;
-exports.resolveFileSourcesInInput = resolveFileSourcesInInput;
-exports.scanForFileSources = scanForFileSources;
-exports.validateModelPricing = validateModelPricing;
-exports.validatePricingConfig = validatePricingConfig;
-exports.validateProviderPricing = validateProviderPricing;
-exports.withValidation = withValidation;
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map