@agtlantis/core 0.4.1

package/dist/index.cjs

@@ -0,0 +1,3188 @@
+'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 merge = require('lodash/merge');
+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);
+var merge__default = /*#__PURE__*/_interopDefault(merge);
+
+// 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 promptContent = this.parseContent(content, id);
+      if (promptContent.id !== id || promptContent.version !== version) {
+        throw new PromptInvalidFormatError(
+          id,
+          `File content mismatch: expected id='${id}' version='${version}', got id='${promptContent.id}' version='${promptContent.version}'`
+        );
+      }
+      if (this.cacheEnabled) {
+        this.contentCache.set(cacheKey, promptContent);
+      }
+      return promptContent;
+    }
+    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/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;
+  _fileManager;
+  logger;
+  sessionStartTime;
+  signal;
+  summary;
+  pendingUsagePromises = [];
+  onDoneFns = [];
+  constructor(options) {
+    this.defaultLanguageModel = options.defaultLanguageModel ?? null;
+    this.modelFactory = options.modelFactory ?? null;
+    this.providerType = options.providerType;
+    this.providerPricing = options.providerPricing;
+    this.defaultProviderOptions = options.defaultProviderOptions;
+    this.defaultTools = options.defaultTools;
+    this._fileManager = options.fileManager;
+    this.logger = options.logger ?? noopLogger;
+    this.sessionStartTime = options.startTime ?? Date.now();
+    this.signal = options.signal;
+    this.summary = SessionSummary.empty(this.sessionStartTime);
+  }
+  getModel(requestedModelId) {
+    if (requestedModelId) {
+      if (!this.modelFactory) {
+        throw new Error(
+          `Model '${requestedModelId}' requested but no modelFactory provided. Either use the default model or configure the provider with modelFactory.`
+        );
+      }
+      return this.modelFactory(requestedModelId);
+    }
+    if (!this.defaultLanguageModel) {
+      throw new Error(
+        "No model specified and no default model set. Either specify a model in the call or configure the provider with withDefaultModel()."
+      );
+    }
+    return this.defaultLanguageModel;
+  }
+  extractModelId(model) {
+    const modelWithId = model;
+    if (!modelWithId.modelId) {
+      console.warn(
+        '[SimpleSession] Model does not have modelId property, using "unknown". This may affect cost tracking accuracy.'
+      );
+    }
+    return modelWithId.modelId ?? "unknown";
+  }
+  async generateText(params) {
+    const callStartTime = Date.now();
+    const { model: requestedModel, providerOptions, tools, ...restParams } = params;
+    const languageModel = this.getModel(requestedModel);
+    const modelId = this.extractModelId(languageModel);
+    const mergedProviderOptions = this.defaultProviderOptions || providerOptions ? merge__default.default({}, this.defaultProviderOptions ?? {}, providerOptions ?? {}) : void 0;
+    const mergedTools = this.defaultTools || tools ? { ...this.defaultTools, ...tools } : void 0;
+    this.logger.onLLMCallStart?.({
+      type: "llm_call_start",
+      callType: "generateText",
+      modelId,
+      timestamp: callStartTime,
+      request: { params: restParams }
+    });
+    try {
+      const result = await ai.generateText({
+        ...restParams,
+        tools: mergedTools,
+        providerOptions: mergedProviderOptions,
+        model: languageModel,
+        abortSignal: this.signal
+      });
+      const callEndTime = Date.now();
+      const call = {
+        startTime: callStartTime,
+        endTime: callEndTime,
+        duration: callEndTime - callStartTime,
+        usage: result.usage ?? createZeroUsage(),
+        type: "generateText",
+        model: modelId,
+        provider: this.providerType
+      };
+      this.updateSummaryWithLLMCall(call);
+      this.logger.onLLMCallEnd?.({
+        type: "llm_call_end",
+        callType: "generateText",
+        modelId,
+        timestamp: callEndTime,
+        response: {
+          duration: callEndTime - callStartTime,
+          usage: result.usage,
+          raw: result
+        }
+      });
+      return result;
+    } catch (error) {
+      const callEndTime = Date.now();
+      this.logger.onLLMCallEnd?.({
+        type: "llm_call_end",
+        callType: "generateText",
+        modelId,
+        timestamp: callEndTime,
+        response: {
+          duration: callEndTime - callStartTime,
+          raw: null,
+          error: error instanceof Error ? error : new Error(String(error))
+        }
+      });
+      throw error;
+    }
+  }
+  streamText(params) {
+    const callStartTime = Date.now();
+    const { model: requestedModel, providerOptions, tools, ...restParams } = params;
+    const languageModel = this.getModel(requestedModel);
+    const modelId = this.extractModelId(languageModel);
+    const mergedProviderOptions = this.defaultProviderOptions || providerOptions ? merge__default.default({}, this.defaultProviderOptions ?? {}, providerOptions ?? {}) : void 0;
+    const mergedTools = this.defaultTools || tools ? { ...this.defaultTools, ...tools } : void 0;
+    this.logger.onLLMCallStart?.({
+      type: "llm_call_start",
+      callType: "streamText",
+      modelId,
+      timestamp: callStartTime,
+      request: { params: restParams }
+    });
+    const result = ai.streamText({
+      ...restParams,
+      tools: mergedTools,
+      providerOptions: mergedProviderOptions,
+      model: languageModel,
+      abortSignal: this.signal
+    });
+    const usagePromise = Promise.resolve(result.usage).then((usage) => {
+      const callEndTime = Date.now();
+      const call = {
+        startTime: callStartTime,
+        endTime: callEndTime,
+        duration: callEndTime - callStartTime,
+        usage: usage ?? createZeroUsage(),
+        type: "streamText",
+        model: modelId,
+        provider: this.providerType
+      };
+      this.updateSummaryWithLLMCall(call);
+      this.logger.onLLMCallEnd?.({
+        type: "llm_call_end",
+        callType: "streamText",
+        modelId,
+        timestamp: callEndTime,
+        response: {
+          duration: callEndTime - callStartTime,
+          usage,
+          raw: result
+        }
+      });
+      return usage;
+    });
+    this.pendingUsagePromises.push(usagePromise);
+    return result;
+  }
+  get fileManager() {
+    return this._fileManager;
+  }
+  record(data) {
+    this.summary = this.summary.withCustomRecord(data);
+  }
+  recordToolCall(toolCallSummary) {
+    this.summary = this.summary.withToolCall(toolCallSummary);
+  }
+  recordLLMCall(record) {
+    const call = {
+      ...record,
+      type: record.type ?? "manual"
+    };
+    this.updateSummaryWithLLMCall(call);
+  }
+  recordAdditionalCost(cost) {
+    this.summary = this.summary.withAdditionalCost({
+      ...cost,
+      timestamp: Date.now()
+    });
+  }
+  setMetadata(keyOrData, value) {
+    if (typeof keyOrData === "string") {
+      this.summary = this.summary.withMetadata(keyOrData, value);
+    } else {
+      for (const [k, v] of Object.entries(keyOrData)) {
+        this.summary = this.summary.withMetadata(k, v);
+      }
+    }
+  }
+  updateSummaryWithLLMCall(call) {
+    const newCalls = [...this.summary.llmCalls, call];
+    const { totalCost: llmCost, costByModel } = calculateTotalCost(
+      newCalls.map((c) => ({ usage: c.usage, model: c.model, provider: c.provider })),
+      this.providerPricing
+    );
+    const newTotalUsage = mergeUsages(newCalls.map((c) => c.usage));
+    this.summary = this.summary.withLLMCall(call, llmCost, costByModel, newTotalUsage);
+  }
+  onDone(fn) {
+    this.onDoneFns.push(fn);
+  }
+  async runOnDoneHooks() {
+    const reversedHooks = [...this.onDoneFns].reverse();
+    for (const fn of reversedHooks) {
+      try {
+        await fn();
+      } catch (error) {
+        console.error("[SimpleSession] onDone hook error:", error);
+      }
+    }
+  }
+  async getSummary() {
+    await Promise.all(this.pendingUsagePromises);
+    return this.summary;
+  }
+  /**
+   * Notifies Logger of execution start.
+   * @internal Called by SimpleExecutionHost - not intended for direct use.
+   */
+  notifyExecutionStart() {
+    this._logger.onExecutionStart?.({
+      type: "execution_start",
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Notifies Logger of execution completion with result data and summary.
+   * @param data - The execution result data
+   * @param startTime - Execution start timestamp for duration calculation
+   * @internal Called by SimpleExecutionHost - not intended for direct use.
+   */
+  async notifyExecutionDone(data, startTime) {
+    const summary = await this.getSummary();
+    this._logger.onExecutionDone?.({
+      type: "execution_done",
+      timestamp: Date.now(),
+      duration: Date.now() - startTime,
+      data,
+      summary
+    });
+  }
+  /**
+   * Notifies Logger of execution error with error details and summary (if available).
+   * Gracefully handles getSummary() failures - summary will be undefined if it fails.
+   * @param error - The error that occurred
+   * @param startTime - Execution start timestamp for duration calculation
+   * @internal Called by SimpleExecutionHost - not intended for direct use.
+   */
+  async notifyExecutionError(error, startTime) {
+    let summary;
+    try {
+      summary = await this.getSummary();
+    } catch {
+    }
+    this._logger.onExecutionError?.({
+      type: "execution_error",
+      timestamp: Date.now(),
+      duration: Date.now() - startTime,
+      error,
+      summary
+    });
+  }
+  get _logger() {
+    return this.logger;
+  }
+  get _startTime() {
+    return this.sessionStartTime;
+  }
+  get _modelId() {
+    if (!this.defaultLanguageModel) {
+      return "unknown";
+    }
+    return this.extractModelId(this.defaultLanguageModel);
+  }
+};
+
+// src/session/streaming-session.ts
+var StreamingSession = class extends SimpleSession {
+  lastEventTime;
+  _terminated = false;
+  constructor(options) {
+    super({
+      defaultLanguageModel: options.defaultLanguageModel,
+      modelFactory: options.modelFactory,
+      providerType: options.providerType,
+      providerPricing: options.providerPricing,
+      fileManager: options.fileManager,
+      logger: options.logger,
+      startTime: options.startTime,
+      signal: options.signal,
+      defaultProviderOptions: options.defaultProviderOptions,
+      defaultTools: options.defaultTools
+    });
+    this.lastEventTime = this._startTime;
+    this._logger.onExecutionStart?.({
+      type: "execution_start",
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Emits a streaming event with automatically attached metrics.
+   *
+   * Reserved types ('complete', 'error') throw at runtime - use session.done()
+   * or session.fail() instead.
+   *
+   * @param event - The event to emit (metrics will be added automatically)
+   * @returns The complete event with metrics attached
+   * @throws Error when attempting to emit reserved types ('complete', 'error')
+   */
+  emit(event) {
+    if (this._terminated) {
+      throw new Error("Session already terminated. Cannot call emit() after a terminal operation.");
+    }
+    const eventType = event.type;
+    if (eventType === "complete" || eventType === "error") {
+      throw new Error(
+        `Cannot emit reserved type "${eventType}". Use session.done() for completion or session.fail() for errors.`
+      );
+    }
+    return this.emitInternal(event);
+  }
+  /**
+   * Internal emit method - bypasses reserved type check.
+   * Used by done() and fail() to emit terminal events.
+   */
+  emitInternal(event) {
+    const metrics = this.createMetrics();
+    const fullEvent = { ...event, metrics };
+    this._logger.onExecutionEmit?.({
+      type: "execution_emit",
+      event: fullEvent
+    });
+    return fullEvent;
+  }
+  /**
+   * Signals successful completion of the streaming execution.
+   * Emits a 'complete' event with the result data and session summary.
+   * Also triggers Logger.onExecutionDone for observability.
+   * @param data - The final result data
+   * @returns The complete event with data and summary
+   */
+  async done(data) {
+    if (this._terminated) {
+      throw new Error("Session already terminated. Cannot call done() after a terminal operation.");
+    }
+    this._terminated = true;
+    const summary = await this.getSummary();
+    this._logger.onExecutionDone?.({
+      type: "execution_done",
+      timestamp: Date.now(),
+      duration: summary.totalDuration,
+      data,
+      summary
+    });
+    return this.emitInternal({
+      type: "complete",
+      data,
+      summary
+    });
+  }
+  /**
+   * Signals that the streaming execution failed with an error.
+   * Emits an 'error' event and triggers Logger.onExecutionError for observability.
+   * Gracefully handles getSummary() failures - summary will be undefined if it fails.
+   * @param error - The error that caused the failure
+   * @param data - Optional partial result data (if any was produced before failure)
+   * @returns The error event
+   */
+  async fail(error, data) {
+    if (this._terminated) {
+      throw new Error("Session already terminated. Cannot call fail() after a terminal operation.");
+    }
+    this._terminated = true;
+    let summary;
+    try {
+      summary = await this.getSummary();
+    } catch {
+    }
+    this._logger.onExecutionError?.({
+      type: "execution_error",
+      timestamp: Date.now(),
+      duration: summary?.totalDuration ?? Date.now() - this._startTime,
+      error,
+      data,
+      summary
+    });
+    const errorEvent = {
+      type: "error",
+      error
+    };
+    if (summary) {
+      errorEvent.summary = summary;
+    }
+    if (data !== void 0) {
+      errorEvent.data = data;
+    }
+    return this.emitInternal(errorEvent);
+  }
+  createMetrics() {
+    const now = Date.now();
+    const metrics = {
+      timestamp: now,
+      elapsedMs: now - this._startTime,
+      deltaMs: now - this.lastEventTime
+    };
+    this.lastEventTime = now;
+    return metrics;
+  }
+};
+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(apiKey, defaultModelId, logger, safetySettings, pricingConfig, defaultOptions, searchEnabled = false, urlContextEnabled = false, fileCache) {
+    super();
+    this.apiKey = apiKey;
+    this.defaultModelId = defaultModelId;
+    this.logger = logger;
+    this.safetySettings = safetySettings;
+    this.pricingConfig = pricingConfig;
+    this.defaultOptions = defaultOptions;
+    this.searchEnabled = searchEnabled;
+    this.urlContextEnabled = urlContextEnabled;
+    this.fileCache = fileCache;
+    this.google = google.createGoogleGenerativeAI({ apiKey });
+  }
+  google;
+  withDefaultModel(modelId) {
+    return new _GoogleProvider(
+      this.apiKey,
+      modelId,
+      this.logger,
+      this.safetySettings,
+      this.pricingConfig,
+      this.defaultOptions,
+      this.searchEnabled,
+      this.urlContextEnabled,
+      this.fileCache
+    );
+  }
+  withLogger(newLogger) {
+    return new _GoogleProvider(
+      this.apiKey,
+      this.defaultModelId,
+      newLogger,
+      this.safetySettings,
+      this.pricingConfig,
+      this.defaultOptions,
+      this.searchEnabled,
+      this.urlContextEnabled,
+      this.fileCache
+    );
+  }
+  withPricing(pricing) {
+    validateProviderPricing(pricing, "google");
+    return new _GoogleProvider(
+      this.apiKey,
+      this.defaultModelId,
+      this.logger,
+      this.safetySettings,
+      pricing,
+      this.defaultOptions,
+      this.searchEnabled,
+      this.urlContextEnabled,
+      this.fileCache
+    );
+  }
+  /**
+   * 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.apiKey,
+      this.defaultModelId,
+      this.logger,
+      this.safetySettings,
+      this.pricingConfig,
+      options,
+      this.searchEnabled,
+      this.urlContextEnabled,
+      this.fileCache
+    );
+  }
+  /**
+   * 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.apiKey,
+      this.defaultModelId,
+      this.logger,
+      this.safetySettings,
+      this.pricingConfig,
+      this.defaultOptions,
+      true,
+      this.urlContextEnabled,
+      this.fileCache
+    );
+  }
+  /**
+   * 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.apiKey,
+      this.defaultModelId,
+      this.logger,
+      this.safetySettings,
+      this.pricingConfig,
+      this.defaultOptions,
+      this.searchEnabled,
+      true,
+      this.fileCache
+    );
+  }
+  /**
+   * 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.apiKey,
+      this.defaultModelId,
+      this.logger,
+      this.safetySettings,
+      this.pricingConfig,
+      this.defaultOptions,
+      this.searchEnabled,
+      this.urlContextEnabled,
+      cache ?? new InMemoryFileCache()
+    );
+  }
+  getSessionConfig() {
+    const defaultTools = {
+      ...this.searchEnabled && { google_search: this.google.tools.googleSearch({}) },
+      ...this.urlContextEnabled && { url_context: this.google.tools.urlContext({}) }
+    };
+    const hasDefaultTools = this.searchEnabled || this.urlContextEnabled;
+    return {
+      defaultLanguageModel: this.defaultModelId ? this.createModel(this.defaultModelId) : null,
+      modelFactory: (modelId) => this.createModel(modelId),
+      providerType: "google",
+      providerPricing: this.pricingConfig,
+      fileManager: new GoogleFileManager(this.apiKey, { cache: this.fileCache }),
+      logger: this.logger,
+      defaultProviderOptions: this.defaultOptions ? { google: this.defaultOptions } : void 0,
+      defaultTools: hasDefaultTools ? defaultTools : void 0
+    };
+  }
+  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.safetySettings) {
+      return this.google(modelId, { safetySettings: this.safetySettings });
+    }
+    return this.google(modelId);
+  }
+};
+function createGoogleProvider(config) {
+  return new GoogleProvider(
+    config.apiKey,
+    null,
+    // No default model - must be set with withDefaultModel()
+    noopLogger,
+    config.safetySettings
+  );
+}
+var OpenAIProvider = class _OpenAIProvider extends BaseProvider {
+  constructor(apiKey, defaultModelId, logger, baseURL, organization, pricingConfig, defaultOptions, fileCache) {
+    super();
+    this.apiKey = apiKey;
+    this.defaultModelId = defaultModelId;
+    this.logger = logger;
+    this.baseURL = baseURL;
+    this.organization = organization;
+    this.pricingConfig = pricingConfig;
+    this.defaultOptions = defaultOptions;
+    this.fileCache = fileCache;
+    this.openai = openai.createOpenAI({
+      apiKey,
+      baseURL,
+      organization
+    });
+  }
+  openai;
+  withDefaultModel(modelId) {
+    return new _OpenAIProvider(
+      this.apiKey,
+      modelId,
+      this.logger,
+      this.baseURL,
+      this.organization,
+      this.pricingConfig,
+      this.defaultOptions,
+      this.fileCache
+    );
+  }
+  withLogger(newLogger) {
+    return new _OpenAIProvider(
+      this.apiKey,
+      this.defaultModelId,
+      newLogger,
+      this.baseURL,
+      this.organization,
+      this.pricingConfig,
+      this.defaultOptions,
+      this.fileCache
+    );
+  }
+  withPricing(pricing) {
+    validateProviderPricing(pricing, "openai");
+    return new _OpenAIProvider(
+      this.apiKey,
+      this.defaultModelId,
+      this.logger,
+      this.baseURL,
+      this.organization,
+      pricing,
+      this.defaultOptions,
+      this.fileCache
+    );
+  }
+  /**
+   * 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.apiKey,
+      this.defaultModelId,
+      this.logger,
+      this.baseURL,
+      this.organization,
+      this.pricingConfig,
+      options,
+      this.fileCache
+    );
+  }
+  /**
+   * 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.apiKey,
+      this.defaultModelId,
+      this.logger,
+      this.baseURL,
+      this.organization,
+      this.pricingConfig,
+      this.defaultOptions,
+      cache
+    );
+  }
+  getSessionConfig() {
+    return {
+      defaultLanguageModel: this.defaultModelId ? this.openai(this.defaultModelId) : null,
+      modelFactory: (modelId) => this.openai(modelId),
+      providerType: "openai",
+      providerPricing: this.pricingConfig,
+      fileManager: new NoOpFileManager(),
+      logger: this.logger,
+      defaultProviderOptions: this.defaultOptions ? { openai: this.defaultOptions } : void 0
+    };
+  }
+  createStreamingSession(signal) {
+    return new StreamingSession({ ...this.getSessionConfig(), signal });
+  }
+  createSimpleSession(signal) {
+    return new SimpleSession({ ...this.getSessionConfig(), signal });
+  }
+};
+function createOpenAIProvider(config) {
+  return new OpenAIProvider(
+    config.apiKey,
+    null,
+    // No default model - must be set with withDefaultModel()
+    noopLogger,
+    config.baseURL,
+    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