avantgate 1.1.0 → 1.1.2

package/dist/agent/index.js

@@ -0,0 +1,1803 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/agent/index.ts
+var agent_exports = {};
+__export(agent_exports, {
+  AgentToolFactory: () => AgentToolFactory,
+  CircularToolCallError: () => CircularToolCallError,
+  CompositeToolStrategy: () => CompositeToolStrategy,
+  DtoValidationError: () => DtoValidationError,
+  HttpTelemetryExporter: () => HttpTelemetryExporter,
+  KeyValueStorageAdapter: () => KeyValueStorageAdapter,
+  MemoryStorageAdapter: () => MemoryStorageAdapter,
+  PhaseBasedToolStrategy: () => PhaseBasedToolStrategy,
+  PiiLeakError: () => PiiLeakError,
+  PlatformStorageAdapter: () => PlatformStorageAdapter,
+  PrismaStorageAdapter: () => PrismaStorageAdapter,
+  RoleBasedToolStrategy: () => RoleBasedToolStrategy,
+  SQLiteStorageAdapter: () => SQLiteStorageAdapter,
+  StepExecutionError: () => StepExecutionError,
+  StepSuspendedError: () => StepSuspendedError,
+  ToolAccessDeniedError: () => ToolAccessDeniedError,
+  ToolCallDepthExceededError: () => ToolCallDepthExceededError,
+  ToolNotFoundError: () => ToolNotFoundError,
+  ToolRegistry: () => ToolRegistry,
+  ToolSubCallQuotaError: () => ToolSubCallQuotaError,
+  applyToolStrategy: () => applyToolStrategy,
+  auditToolResult: () => auditToolResult,
+  createCustomStorageAdapter: () => createCustomStorageAdapter,
+  createIsolatedTool: () => createIsolatedTool,
+  createStepRunner: () => createStepRunner,
+  createToolInvoker: () => createToolInvoker,
+  createToolSharedState: () => createToolSharedState,
+  dto: () => dto
+});
+module.exports = __toCommonJS(agent_exports);
+
+// src/agent/errors.ts
+var StepSuspendedError = class extends Error {
+  stepId;
+  workflowId;
+  metadata;
+  constructor(stepId, workflowId, metadata) {
+    super(`Step execution suspended for human approval: [${workflowId}::${stepId}]`);
+    this.name = "StepSuspendedError";
+    this.stepId = stepId;
+    this.workflowId = workflowId;
+    this.metadata = metadata;
+  }
+};
+var PiiLeakError = class extends Error {
+  toolName;
+  maskedCount;
+  constructor(toolName, maskedCount) {
+    super(`PII leak detected in tool output for "${toolName}" (${maskedCount} occurrences detected).`);
+    this.name = "PiiLeakError";
+    this.toolName = toolName;
+    this.maskedCount = maskedCount;
+  }
+};
+var StepExecutionError = class extends Error {
+  stepId;
+  workflowId;
+  originalError;
+  constructor(stepId, workflowId, message, originalError) {
+    super(`Execution failed at step [${workflowId}::${stepId}]: ${message}`);
+    this.name = "StepExecutionError";
+    this.stepId = stepId;
+    this.workflowId = workflowId;
+    this.originalError = originalError;
+  }
+};
+var ToolAccessDeniedError = class extends Error {
+  toolName;
+  requiredRole;
+  constructor(toolName, requiredRole) {
+    const roleMsg = requiredRole ? ` (requires role "${requiredRole}")` : "";
+    super(`Access denied for tool "${toolName}"${roleMsg}.`);
+    this.name = "ToolAccessDeniedError";
+    this.toolName = toolName;
+    this.requiredRole = requiredRole;
+  }
+};
+var CircularToolCallError = class extends Error {
+  cycle;
+  constructor(cycle) {
+    super(`Circular tool call detected: ${cycle.join(" -> ")}`);
+    this.name = "CircularToolCallError";
+    this.cycle = cycle;
+  }
+};
+var ToolCallDepthExceededError = class extends Error {
+  depth;
+  maxDepth;
+  constructor(depth, maxDepth) {
+    super(`Tool call depth limit exceeded: depth ${depth} exceeds max allowed depth of ${maxDepth}.`);
+    this.name = "ToolCallDepthExceededError";
+    this.depth = depth;
+    this.maxDepth = maxDepth;
+  }
+};
+var ToolSubCallQuotaError = class extends Error {
+  totalCalls;
+  maxCalls;
+  constructor(totalCalls, maxCalls) {
+    super(`Tool sub-call quota exceeded: ${totalCalls} calls exceeds session quota of ${maxCalls}.`);
+    this.name = "ToolSubCallQuotaError";
+    this.totalCalls = totalCalls;
+    this.maxCalls = maxCalls;
+  }
+};
+var ToolNotFoundError = class extends Error {
+  toolId;
+  constructor(toolId) {
+    super(`Tool not found in registry: "${toolId}".`);
+    this.name = "ToolNotFoundError";
+    this.toolId = toolId;
+  }
+};
+var DtoValidationError = class extends Error {
+  toolName;
+  issues;
+  constructor(toolName, message, issues = []) {
+    super(`LLM DTO validation failed for tool "${toolName}": ${message}`);
+    this.name = "DtoValidationError";
+    this.toolName = toolName;
+    this.issues = issues;
+  }
+};
+
+// src/sanitizer.ts
+var EMAIL_REGEX = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,7}\b/g;
+var PHONE_FR_REGEX = /\b(?:(?:\+|00)33|0)\s*[1-9](?:[\s.-]*\d{2}){4}\b/g;
+var NIR_SSN_REGEX = /\b[12]\s*\d{2}\s*(?:0[1-9]|1[0-2]|[2-9]\d)\s*(?:0[1-9]|[1-8]\d|9[0-8]|2[ABab])\s*(?!000)\d{3}\s*(?!000)\d{3}(?:\s*\d{2})?\b/g;
+var SPI_LABELLED_REGEX = /(?:(?:num[ée]ro\s+fiscal|spi|n[°o]\s*fiscal|d[ée]clarant(?: fiscal)?)\s*[:=]?\s*)\b(\d{2}(?:[\s.-]?\d{2}){5}[\s.-]?\d|\d{13})\b/gi;
+var SPI_FORMATTED_REGEX = /\b[0-3]\d(?:\s+\d{2}){5}\s+\d\b/g;
+var IBAN_REGEX = /\b[A-Z]{2}\s*[0-9]{2}(?:[\s\r\n.-]*[A-Z0-9]){11,30}\b/g;
+var BIC_LABELLED_REGEX = /(?:(?:bic|swift)\s*[:=]?\s*)\b([A-Z]{4}[A-Z]{2}[A-Z0-9]{2}(?:[A-Z0-9]{3})?)\b/gi;
+function sanitizePII(input) {
+  let count = 0;
+  let result = input;
+  result = result.replace(EMAIL_REGEX, () => {
+    count++;
+    return "[REDACTED_EMAIL]";
+  });
+  result = result.replace(PHONE_FR_REGEX, () => {
+    count++;
+    return "[REDACTED_PHONE]";
+  });
+  result = result.replace(IBAN_REGEX, (match) => {
+    const cleanChars = match.replace(/[\s\r\n.-]/g, "");
+    if (cleanChars.length >= 15 && cleanChars.length <= 34) {
+      count++;
+      return "[REDACTED_IBAN]";
+    }
+    return match;
+  });
+  result = result.replace(BIC_LABELLED_REGEX, (_, bicCode) => {
+    count++;
+    return `[REDACTED_BIC: ${bicCode.slice(0, 4)}****]`;
+  });
+  result = result.replace(SPI_LABELLED_REGEX, (fullMatch, digits) => {
+    count++;
+    return fullMatch.replace(digits, "[REDACTED_SPI]");
+  });
+  result = result.replace(NIR_SSN_REGEX, (match) => {
+    const rawDigits = match.replace(/\s+/g, "");
+    if (rawDigits.length === 13 || rawDigits.length === 15) {
+      count++;
+      return "[REDACTED_NIR]";
+    }
+    return match;
+  });
+  result = result.replace(SPI_FORMATTED_REGEX, (match) => {
+    if (!match.includes("[REDACTED")) {
+      count++;
+      return "[REDACTED_SPI]";
+    }
+    return match;
+  });
+  return { text: result, maskedCount: count };
+}
+
+// src/agent/guardrails.ts
+function sanitizeString(value) {
+  const result = sanitizePII(value);
+  return { text: result.text, count: result.maskedCount };
+}
+function sanitizeArray(items, options, visited) {
+  let totalCount = 0;
+  const sanitized = items.map((item) => {
+    const res = recursivelySanitize(item, options, visited);
+    totalCount += res.count;
+    return res.sanitized;
+  });
+  return { sanitized, count: totalCount };
+}
+function sanitizeObject(target, options, visited) {
+  let totalCount = 0;
+  const copy = {};
+  for (const [key, val] of Object.entries(target)) {
+    const res = recursivelySanitize(val, options, visited);
+    copy[key] = res.sanitized;
+    totalCount += res.count;
+  }
+  return { sanitized: copy, count: totalCount };
+}
+function recursivelySanitize(data, options, visited = /* @__PURE__ */ new WeakSet()) {
+  if (typeof data === "string") {
+    const res = sanitizeString(data);
+    return { sanitized: res.text, count: res.count };
+  }
+  if (data !== null && typeof data === "object") {
+    if (visited.has(data)) {
+      return { sanitized: "[CIRCULAR_REFERENCE]", count: 0 };
+    }
+    visited.add(data);
+    if (Array.isArray(data)) {
+      return sanitizeArray(data, options, visited);
+    }
+    return sanitizeObject(data, options, visited);
+  }
+  return { sanitized: data, count: 0 };
+}
+function auditToolResult(data, options) {
+  const { sanitized, count } = recursivelySanitize(data, options);
+  if (options.throwOnPii && count > 0) {
+    throw new PiiLeakError(options.toolName, count);
+  }
+  return {
+    sanitizedData: sanitized,
+    maskedCount: count
+  };
+}
+
+// src/agent/isolated-tool.ts
+async function dispatchClientData(rawResult, callback) {
+  if (!callback) {
+    return;
+  }
+  await callback(rawResult);
+}
+async function produceLlmPayload(rawResult, args, context, transformer) {
+  if (transformer) {
+    return await transformer(rawResult, args, context);
+  }
+  return rawResult;
+}
+function validateLlmDto(payload, schema, toolIdentifier) {
+  const parseResult = schema.safeParse(payload);
+  if (!parseResult.success) {
+    const issues = parseResult.error.issues ?? [];
+    const errorMessages = issues.map((issue) => `${issue.path.join(".") || "root"}: ${issue.message}`).join(", ");
+    throw new DtoValidationError(
+      toolIdentifier,
+      errorMessages,
+      issues
+    );
+  }
+  return parseResult.data;
+}
+function protectLlmPayload(payload, toolIdentifier, sanitizePii = true, throwOnPii = false) {
+  if (!sanitizePii) {
+    return { sanitized: payload, count: 0 };
+  }
+  const { sanitizedData, maskedCount } = auditToolResult(payload, {
+    toolName: toolIdentifier,
+    throwOnPii
+  });
+  return { sanitized: sanitizedData, count: maskedCount };
+}
+async function processLlmPayload(rawResult, args, context, config, toolIdentifier) {
+  let payload = await produceLlmPayload(rawResult, args, context, config.llmDto);
+  if (config.llmDtoSchema) {
+    payload = validateLlmDto(payload, config.llmDtoSchema, toolIdentifier);
+  }
+  return protectLlmPayload(
+    payload,
+    toolIdentifier,
+    config.sanitizePii !== false,
+    config.throwOnPii === true
+  );
+}
+function createIsolatedTool(config) {
+  const toolId = config.id || config.name;
+  const toolAlias = config.alias;
+  const clientCallback = config.clientDto;
+  const tool = {
+    description: config.description,
+    parameters: config.parameters,
+    _toolId: toolId,
+    _toolName: config.name,
+    _toolAlias: toolAlias,
+    _isIsolated: true,
+    _cacheTTL: config.cacheTTL,
+    _lastPiiFilteredCount: 0,
+    async execute(args, context) {
+      const updatedContext = {
+        ...context,
+        callChain: context?.callChain ?? Object.freeze([toolId])
+      };
+      const rawResult = await config.execute(args, updatedContext);
+      await dispatchClientData(rawResult, clientCallback);
+      const protection = await processLlmPayload(
+        rawResult,
+        args,
+        updatedContext,
+        config,
+        toolAlias || config.name
+      );
+      tool._lastPiiFilteredCount = protection.count;
+      return protection.sanitized;
+    }
+  };
+  return tool;
+}
+
+// src/agent/dto.ts
+var dto = {
+  /**
+   * Generates a boolean acknowledgment for mutations ({ success: true | false }).
+   * If rawResult contains a boolean `success` property, it is preserved; otherwise defaults to true.
+   */
+  boolean: () => (data) => ({
+    success: typeof data?.success === "boolean" ? data.success : true
+  }),
+  /**
+   * Generates a boolean acknowledgment preserving an opaque technical identifier for tool chaining.
+   */
+  booleanWithId: (idKey = "id") => (data) => ({
+    success: typeof data?.success === "boolean" ? data.success : true,
+    [idKey]: data?.[idKey]
+  }),
+  /**
+   * Extracts a numeric count from a list or nested array property without exposing items to the LLM.
+   */
+  count: (arrayKey) => (data) => {
+    const list = arrayKey ? data?.[arrayKey] : data;
+    return {
+      success: true,
+      count: Array.isArray(list) ? list.length : 0
+    };
+  },
+  /**
+   * Filters raw output by extracting only a strict whitelist of allowed fields.
+   */
+  pick: (keys) => (data) => {
+    const result = {};
+    if (!data || typeof data !== "object") {
+      return result;
+    }
+    for (const key of keys) {
+      if (key in data) {
+        result[key] = data[key];
+      }
+    }
+    return result;
+  }
+};
+
+// src/agent/factory.ts
+var AgentToolFactory = class _AgentToolFactory {
+  context;
+  constructor(defaultContext = {}) {
+    this.context = Object.freeze({ ...defaultContext });
+  }
+  /**
+   * Returns a new factory instance with merged context.
+   */
+  withContext(extraContext) {
+    return new _AgentToolFactory({
+      ...this.context,
+      ...extraContext
+    });
+  }
+  /**
+   * Returns current factory context.
+   */
+  getContext() {
+    return this.context;
+  }
+  /**
+   * Instantiates an isolated tool by injecting factory context into the builder function.
+   */
+  createTool(builder) {
+    const config = builder(this.context);
+    return createIsolatedTool(config);
+  }
+};
+
+// src/agent/registry.ts
+var ToolRegistry = class _ToolRegistry {
+  toolsById = /* @__PURE__ */ new Map();
+  toolsByPublicName = /* @__PURE__ */ new Map();
+  /**
+   * Registers a new tool in the registry.
+   */
+  register(toolDef) {
+    const id = toolDef.id || toolDef.name;
+    const publicName = toolDef.alias || toolDef.name;
+    const normalizedDef = {
+      ...toolDef,
+      id
+    };
+    this.toolsById.set(id, normalizedDef);
+    this.toolsByPublicName.set(publicName, normalizedDef);
+    return this;
+  }
+  /**
+   * Retrieves a tool by its ID or public name/alias.
+   */
+  get(idOrName) {
+    return this.toolsById.get(idOrName) ?? this.toolsByPublicName.get(idOrName);
+  }
+  /**
+   * Retrieves a tool strictly by its immutable technical ID (O(1)).
+   */
+  getById(id) {
+    return this.toolsById.get(id);
+  }
+  /**
+   * Retrieves a tool by its public alias seen by the LLM (O(1)).
+   */
+  getByPublicName(publicName) {
+    return this.toolsByPublicName.get(publicName);
+  }
+  /**
+   * Checks if a tool is registered by ID or public name.
+   */
+  has(idOrName) {
+    return this.toolsById.has(idOrName) || this.toolsByPublicName.has(idOrName);
+  }
+  /**
+   * Returns all registered tools without duplicates.
+   */
+  getAll() {
+    return Array.from(this.toolsById.values());
+  }
+  /**
+   * Filters tools matching a specific workflow phase.
+   */
+  getByPhase(phase) {
+    return this.getAll().filter((item) => {
+      if (!item.phases || item.phases.length === 0) {
+        return true;
+      }
+      return item.phases.includes(phase);
+    });
+  }
+  /**
+   * Filters tools matching the user's roles (RBAC).
+   */
+  filterByRoles(userRoles) {
+    const roleSet = new Set(userRoles);
+    return this.getAll().filter((item) => {
+      if (!item.requiredRoles || item.requiredRoles.length === 0) {
+        return true;
+      }
+      return item.requiredRoles.some((role) => roleSet.has(role));
+    });
+  }
+  /**
+   * Converts instance registered tools to the record map format required by Vercel AI SDK.
+   */
+  toRecord(options = {}) {
+    return _ToolRegistry.toRecord(this.getAll(), options);
+  }
+  /**
+   * Converts a list of registered tools to the record map format required by Vercel AI SDK.
+   * If anonymize is true, uses alias (if defined) as dictionary key instead of technical name.
+   */
+  static toRecord(tools, options = {}) {
+    const record = {};
+    for (const item of tools) {
+      const key = options.anonymize && item.alias ? item.alias : item.name;
+      record[key] = item.tool;
+    }
+    return record;
+  }
+};
+
+// src/agent/strategy.ts
+var PhaseBasedToolStrategy = class {
+  selectTools(tools, context) {
+    if (!context.phase) {
+      return tools;
+    }
+    const currentPhase = context.phase;
+    return tools.filter((item) => {
+      if (!item.phases || item.phases.length === 0) {
+        return true;
+      }
+      return item.phases.includes(currentPhase);
+    });
+  }
+};
+var RoleBasedToolStrategy = class {
+  selectTools(tools, context) {
+    if (!context.role) {
+      return tools.filter((t) => !t.requiredRoles || t.requiredRoles.length === 0);
+    }
+    const currentRole = context.role;
+    return tools.filter((item) => {
+      if (!item.requiredRoles || item.requiredRoles.length === 0) {
+        return true;
+      }
+      return item.requiredRoles.includes(currentRole);
+    });
+  }
+};
+var CompositeToolStrategy = class {
+  strategies;
+  constructor(strategies) {
+    this.strategies = strategies;
+  }
+  async selectTools(tools, context) {
+    let current = tools;
+    for (const strategy of this.strategies) {
+      current = await strategy.selectTools(current, context);
+    }
+    return current;
+  }
+};
+async function applyToolStrategy(tools, strategy, context) {
+  const selected = await strategy.selectTools(tools, context);
+  return ToolRegistry.toRecord(selected);
+}
+
+// src/agent/adapters/memory-adapter.ts
+var MemoryStorageAdapter = class {
+  storage = /* @__PURE__ */ new Map();
+  toolExecutions = [];
+  cacheStorage = /* @__PURE__ */ new Map();
+  stateStorage = /* @__PURE__ */ new Map();
+  ttlMs;
+  constructor(options = {}) {
+    this.ttlMs = options.ttlMs;
+  }
+  buildKey(workflowId, stepId) {
+    return `${workflowId}::${stepId}`;
+  }
+  isExpired(entry) {
+    if (!entry.expiresAt) {
+      return false;
+    }
+    return Date.now() > entry.expiresAt;
+  }
+  async getStep(workflowId, stepId) {
+    const key = this.buildKey(workflowId, stepId);
+    const entry = this.storage.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (this.isExpired(entry)) {
+      this.storage.delete(key);
+      return null;
+    }
+    return entry.record;
+  }
+  async saveStep(step) {
+    const key = this.buildKey(step.workflowId, step.stepId);
+    const expiresAt = this.ttlMs ? Date.now() + this.ttlMs : void 0;
+    this.storage.set(key, {
+      record: step,
+      expiresAt
+    });
+  }
+  async updateStepStatus(workflowId, stepId, status, patch) {
+    const existing = await this.getStep(workflowId, stepId);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const updated = {
+      ...existing ?? {
+        workflowId,
+        stepId,
+        createdAt: now
+      },
+      ...patch,
+      status,
+      updatedAt: now
+    };
+    await this.saveStep(updated);
+  }
+  async listSteps(workflowId) {
+    const results = [];
+    for (const [key, entry] of this.storage.entries()) {
+      if (this.isExpired(entry)) {
+        this.storage.delete(key);
+        continue;
+      }
+      if (entry.record.workflowId === workflowId) {
+        results.push(entry.record);
+      }
+    }
+    return results;
+  }
+  async saveToolExecution(record) {
+    this.toolExecutions.push(record);
+  }
+  async listToolExecutions(workflowId, stepId) {
+    return this.toolExecutions.filter((item) => {
+      if (workflowId && item.workflowId !== workflowId) return false;
+      if (stepId && item.stepId !== stepId) return false;
+      return true;
+    });
+  }
+  async getCachedToolResult(cacheKey) {
+    const entry = this.cacheStorage.get(cacheKey);
+    if (!entry) {
+      return null;
+    }
+    if (Date.now() > entry.expiresAt) {
+      this.cacheStorage.delete(cacheKey);
+      return null;
+    }
+    return entry.result;
+  }
+  async setCachedToolResult(cacheKey, result, ttlSeconds) {
+    const expiresAt = Date.now() + ttlSeconds * 1e3;
+    this.cacheStorage.set(cacheKey, { result, expiresAt });
+  }
+  async getStateValue(key) {
+    const entry = this.stateStorage.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      this.stateStorage.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  async setStateValue(key, value, ttlSeconds) {
+    const expiresAt = ttlSeconds ? Date.now() + ttlSeconds * 1e3 : void 0;
+    this.stateStorage.set(key, { value, expiresAt });
+  }
+  async deleteStateValue(key) {
+    this.stateStorage.delete(key);
+  }
+  /**
+   * Resets all internal in-memory maps (useful for test isolation).
+   */
+  clear() {
+    this.storage.clear();
+    this.toolExecutions.length = 0;
+    this.cacheStorage.clear();
+    this.stateStorage.clear();
+  }
+};
+
+// src/agent/step-runner.ts
+async function fetchCachedResult(storage, workflowId, stepId) {
+  const existing = await storage.getStep(workflowId, stepId);
+  if (existing && existing.status === "COMPLETED") {
+    return { isCompleted: true, result: existing.result };
+  }
+  return { isCompleted: false };
+}
+async function markStepRunning(storage, workflowId, stepId, runId) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await storage.saveStep({
+    workflowId,
+    stepId,
+    runId,
+    status: "RUNNING",
+    createdAt: now,
+    updatedAt: now
+  });
+}
+async function handleStepFailure(storage, workflowId, stepId, error) {
+  if (error instanceof StepSuspendedError) {
+    throw error;
+  }
+  const errorMsg = error instanceof Error ? error.message : String(error);
+  await storage.updateStepStatus(workflowId, stepId, "FAILED", {
+    error: errorMsg
+  });
+  throw new StepExecutionError(stepId, workflowId, errorMsg, error);
+}
+async function executeWithPersistence(storage, workflowId, stepId, runId, executeFn) {
+  const cache = await fetchCachedResult(storage, workflowId, stepId);
+  if (cache.isCompleted) {
+    return cache.result;
+  }
+  await markStepRunning(storage, workflowId, stepId, runId);
+  try {
+    const result = await executeFn();
+    await storage.updateStepStatus(workflowId, stepId, "COMPLETED", { result });
+    return result;
+  } catch (error) {
+    return handleStepFailure(storage, workflowId, stepId, error);
+  }
+}
+async function handleWaitForApproval(storage, workflowId, stepId, runId, options) {
+  const existing = await storage.getStep(workflowId, stepId);
+  if (existing && existing.status === "COMPLETED") {
+    return existing.result ?? options?.defaultResult;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const stepRecord = {
+    workflowId,
+    stepId,
+    runId,
+    status: "WAITING_APPROVAL",
+    metadata: options?.metadata,
+    result: options?.defaultResult,
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now
+  };
+  await storage.saveStep(stepRecord);
+  throw new StepSuspendedError(stepId, workflowId, options?.metadata);
+}
+function createStepRunner(config) {
+  const { workflowId, runId = config.runId ?? config.workflowId, storage = new MemoryStorageAdapter() } = config;
+  return {
+    workflowId,
+    storage,
+    async run(stepId, executeFn) {
+      return executeWithPersistence(storage, workflowId, stepId, runId, executeFn);
+    },
+    async waitForApproval(stepId, options) {
+      return handleWaitForApproval(storage, workflowId, stepId, runId, options);
+    },
+    async approveStep(stepId, approvalData) {
+      await storage.updateStepStatus(workflowId, stepId, "COMPLETED", {
+        result: approvalData
+      });
+    },
+    async rejectStep(stepId, reason) {
+      await storage.updateStepStatus(workflowId, stepId, "FAILED", {
+        error: reason ?? "Rejected by human operator"
+      });
+    }
+  };
+}
+
+// src/agent/tool-state.ts
+function createToolSharedState(storage) {
+  const volatileMap = /* @__PURE__ */ new Map();
+  return {
+    async get(key) {
+      if (storage?.getStateValue) {
+        return storage.getStateValue(key);
+      }
+      const entry = volatileMap.get(key);
+      if (!entry) {
+        return null;
+      }
+      if (entry.expiresAt && Date.now() > entry.expiresAt) {
+        volatileMap.delete(key);
+        return null;
+      }
+      return entry.value;
+    },
+    async set(key, value, ttlSeconds) {
+      if (storage?.setStateValue) {
+        await storage.setStateValue(key, value, ttlSeconds);
+        return;
+      }
+      const expiresAt = ttlSeconds ? Date.now() + ttlSeconds * 1e3 : void 0;
+      volatileMap.set(key, { value, expiresAt });
+    },
+    async delete(key) {
+      if (storage?.deleteStateValue) {
+        await storage.deleteStateValue(key);
+        return;
+      }
+      volatileMap.delete(key);
+    },
+    async clear() {
+      if (storage?.clearStateValues) {
+        await storage.clearStateValues();
+        return;
+      }
+      volatileMap.clear();
+    }
+  };
+}
+
+// src/agent/tool-invoker.ts
+function buildCacheKey(toolId, args) {
+  try {
+    return `avantgate:cache:${toolId}:${JSON.stringify(args)}`;
+  } catch {
+    return `avantgate:cache:${toolId}:${String(args)}`;
+  }
+}
+function validateCallLimits(registeredId, parentChain, maxDepth, totalCalls, maxTotalCalls) {
+  if (totalCalls > maxTotalCalls) {
+    throw new ToolSubCallQuotaError(totalCalls, maxTotalCalls);
+  }
+  if (parentChain.includes(registeredId)) {
+    throw new CircularToolCallError([...parentChain, registeredId]);
+  }
+  if (parentChain.length >= maxDepth) {
+    throw new ToolCallDepthExceededError(parentChain.length + 1, maxDepth);
+  }
+}
+async function recordExecution(storage, record) {
+  if (!storage?.saveToolExecution) {
+    return;
+  }
+  try {
+    await storage.saveToolExecution(record);
+  } catch {
+  }
+}
+function createToolInvoker(registry, storage, options = {}) {
+  const {
+    maxDepth = 5,
+    maxTotalSubCalls = 20,
+    workflowId = options.workflowId,
+    stepId = options.stepId
+  } = options;
+  let totalCallsCount = 0;
+  const sharedState = createToolSharedState(storage);
+  const invoker = {
+    async invokeTool(toolId, args, context) {
+      totalCallsCount++;
+      const registered = registry.get(toolId);
+      if (!registered) {
+        throw new ToolNotFoundError(toolId);
+      }
+      const parentChain = context?.callChain ?? [];
+      validateCallLimits(
+        registered.id,
+        parentChain,
+        maxDepth,
+        totalCallsCount,
+        maxTotalSubCalls
+      );
+      const cacheKey = buildCacheKey(registered.id, args);
+      const cacheTTL = registered.tool._cacheTTL;
+      if (cacheTTL && storage?.getCachedToolResult) {
+        const cached = await storage.getCachedToolResult(cacheKey);
+        if (cached !== null && cached !== void 0) {
+          return cached;
+        }
+      }
+      const activeChain = Object.freeze([...parentChain, registered.id]);
+      const childContext = {
+        ...context,
+        workflowId: context?.workflowId ?? workflowId,
+        stepId: context?.stepId ?? stepId,
+        callChain: activeChain,
+        state: sharedState,
+        storage,
+        callTool: (subId, subArgs) => invoker.invokeTool(subId, subArgs, childContext)
+      };
+      const startTime = Date.now();
+      const parentId = parentChain[parentChain.length - 1];
+      const runId = context?.runId ?? childContext.workflowId;
+      try {
+        const result = await registered.tool.execute(args, childContext);
+        const durationMs = Date.now() - startTime;
+        if (cacheTTL && storage?.setCachedToolResult) {
+          await storage.setCachedToolResult(cacheKey, result, cacheTTL);
+        }
+        const piiFilteredCount = registered.tool._lastPiiFilteredCount ?? 0;
+        await recordExecution(storage, {
+          executionId: `exec-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+          workflowId: childContext.workflowId,
+          stepId: childContext.stepId,
+          runId,
+          toolId: registered.id,
+          parentToolId: parentId,
+          aliasUsed: registered.alias,
+          depth: activeChain.length,
+          inputArgs: args,
+          outputSummary: result,
+          durationMs,
+          status: "SUCCESS",
+          piiFilteredCount,
+          tokens: childContext.tokens,
+          costUsd: childContext.costUsd,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return result;
+      } catch (error) {
+        const durationMs = Date.now() - startTime;
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        await recordExecution(storage, {
+          executionId: `exec-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+          workflowId: childContext.workflowId,
+          stepId: childContext.stepId,
+          runId,
+          toolId: registered.id,
+          parentToolId: parentId,
+          aliasUsed: registered.alias,
+          depth: activeChain.length,
+          inputArgs: args,
+          durationMs,
+          status: "FAILED",
+          error: errorMsg,
+          tokens: childContext.tokens,
+          costUsd: childContext.costUsd,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        throw error;
+      }
+    }
+  };
+  return invoker;
+}
+
+// src/agent/adapters/custom-adapter.ts
+function createCustomStorageAdapter(handlers) {
+  return {
+    getStep: handlers.getStep,
+    saveStep: handlers.saveStep,
+    updateStepStatus: handlers.updateStepStatus,
+    listSteps: handlers.listSteps,
+    saveToolExecution: handlers.saveToolExecution,
+    listToolExecutions: handlers.listToolExecutions,
+    getCachedToolResult: handlers.getCachedToolResult,
+    setCachedToolResult: handlers.setCachedToolResult,
+    getStateValue: handlers.getStateValue,
+    setStateValue: handlers.setStateValue,
+    deleteStateValue: handlers.deleteStateValue
+  };
+}
+var KeyValueStorageAdapter = class {
+  client;
+  prefix;
+  ttlSeconds;
+  constructor(client, options = {}) {
+    this.client = client;
+    this.prefix = options.prefix ?? "avantgate:step:";
+    this.ttlSeconds = options.ttlSeconds;
+  }
+  buildKey(workflowId, stepId) {
+    return `${this.prefix}${workflowId}:${stepId}`;
+  }
+  async getStep(workflowId, stepId) {
+    const raw = await this.client.get(this.buildKey(workflowId, stepId));
+    if (!raw) {
+      return null;
+    }
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async saveStep(step) {
+    const key = this.buildKey(step.workflowId, step.stepId);
+    const serialized = JSON.stringify(step);
+    await this.client.set(key, serialized, this.ttlSeconds);
+  }
+  async updateStepStatus(workflowId, stepId, status, patch) {
+    const existing = await this.getStep(workflowId, stepId);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const updated = {
+      ...existing ?? {
+        workflowId,
+        stepId,
+        createdAt: now
+      },
+      ...patch,
+      status,
+      updatedAt: now
+    };
+    await this.saveStep(updated);
+  }
+  async listSteps(workflowId) {
+    if (!this.client.keys) {
+      return [];
+    }
+    const pattern = `${this.prefix}${workflowId}:*`;
+    const matchedKeys = await this.client.keys(pattern);
+    const records = [];
+    for (const key of matchedKeys) {
+      const raw = await this.client.get(key);
+      if (raw) {
+        try {
+          records.push(JSON.parse(raw));
+        } catch {
+        }
+      }
+    }
+    return records;
+  }
+  async getCachedToolResult(cacheKey) {
+    const raw = await this.client.get(`cache:${cacheKey}`);
+    if (!raw) return null;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async setCachedToolResult(cacheKey, result, ttlSeconds) {
+    await this.client.set(`cache:${cacheKey}`, JSON.stringify(result), ttlSeconds);
+  }
+  async getStateValue(key) {
+    const raw = await this.client.get(`state:${key}`);
+    if (!raw) return null;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async setStateValue(key, value, ttlSeconds) {
+    await this.client.set(`state:${key}`, JSON.stringify(value), ttlSeconds);
+  }
+  async deleteStateValue(key) {
+    if (this.client.del) {
+      await this.client.del(`state:${key}`);
+      return;
+    }
+    await this.client.set(`state:${key}`, "", 0);
+  }
+};
+
+// src/agent/adapters/prisma-adapter.ts
+function toStepRecord(raw) {
+  const result = typeof raw.result === "string" ? tryParseJson(raw.result) : raw.result;
+  const metadata = typeof raw.metadata === "string" ? tryParseJson(raw.metadata) : raw.metadata;
+  return {
+    workflowId: raw.workflowId,
+    stepId: raw.stepId,
+    status: raw.status,
+    result,
+    error: raw.error ?? void 0,
+    metadata,
+    createdAt: raw.createdAt instanceof Date ? raw.createdAt.toISOString() : String(raw.createdAt),
+    updatedAt: raw.updatedAt instanceof Date ? raw.updatedAt.toISOString() : String(raw.updatedAt)
+  };
+}
+function tryParseJson(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+var PrismaStorageAdapter = class {
+  model;
+  toolDelegates;
+  volatileCache = /* @__PURE__ */ new Map();
+  volatileState = /* @__PURE__ */ new Map();
+  volatileExecutions = [];
+  constructor(model, toolDelegates) {
+    this.model = model;
+    this.toolDelegates = toolDelegates;
+  }
+  async getStep(workflowId, stepId) {
+    const raw = await this.model.findUnique({
+      where: {
+        workflowId_stepId: { workflowId, stepId }
+      }
+    });
+    if (!raw) {
+      return null;
+    }
+    return toStepRecord(raw);
+  }
+  async saveStep(step) {
+    const payload = {
+      workflowId: step.workflowId,
+      stepId: step.stepId,
+      status: step.status,
+      result: step.result !== void 0 ? JSON.stringify(step.result) : null,
+      error: step.error ?? null,
+      metadata: step.metadata ? JSON.stringify(step.metadata) : null,
+      updatedAt: new Date(step.updatedAt)
+    };
+    await this.model.upsert({
+      where: {
+        workflowId_stepId: {
+          workflowId: step.workflowId,
+          stepId: step.stepId
+        }
+      },
+      create: {
+        ...payload,
+        createdAt: new Date(step.createdAt)
+      },
+      update: payload
+    });
+  }
+  async updateStepStatus(workflowId, stepId, status, patch) {
+    const existing = await this.getStep(workflowId, stepId);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const updated = {
+      ...existing ?? {
+        workflowId,
+        stepId,
+        createdAt: now
+      },
+      ...patch,
+      status,
+      updatedAt: now
+    };
+    await this.saveStep(updated);
+  }
+  async listSteps(workflowId) {
+    const list = await this.model.findMany({
+      where: { workflowId },
+      orderBy: { createdAt: "asc" }
+    });
+    return list.map(toStepRecord);
+  }
+  async saveToolExecution(record) {
+    if (this.toolDelegates?.toolExecution) {
+      await this.toolDelegates.toolExecution.create({
+        data: {
+          executionId: record.executionId,
+          workflowId: record.workflowId,
+          stepId: record.stepId,
+          toolId: record.toolId,
+          parentToolId: record.parentToolId,
+          aliasUsed: record.aliasUsed,
+          depth: record.depth,
+          inputArgs: record.inputArgs ? JSON.stringify(record.inputArgs) : null,
+          outputSummary: record.outputSummary ? JSON.stringify(record.outputSummary) : null,
+          durationMs: record.durationMs,
+          status: record.status,
+          error: record.error,
+          createdAt: new Date(record.createdAt)
+        }
+      });
+      return;
+    }
+    this.volatileExecutions.push(record);
+  }
+  async listToolExecutions(workflowId, stepId) {
+    if (this.toolDelegates?.toolExecution) {
+      const rows = await this.toolDelegates.toolExecution.findMany({
+        where: {
+          ...workflowId ? { workflowId } : {},
+          ...stepId ? { stepId } : {}
+        },
+        orderBy: { createdAt: "asc" }
+      });
+      return rows.map((r) => ({
+        ...r,
+        inputArgs: tryParseJson(r.inputArgs),
+        outputSummary: tryParseJson(r.outputSummary),
+        createdAt: r.createdAt instanceof Date ? r.createdAt.toISOString() : String(r.createdAt)
+      }));
+    }
+    return this.volatileExecutions.filter((item) => {
+      if (workflowId && item.workflowId !== workflowId) return false;
+      if (stepId && item.stepId !== stepId) return false;
+      return true;
+    });
+  }
+  async getCachedToolResult(cacheKey) {
+    if (this.toolDelegates?.toolCache) {
+      const row = await this.toolDelegates.toolCache.findUnique({
+        where: { cacheKey }
+      });
+      if (!row || Date.now() > Number(row.expiresAt)) return null;
+      return tryParseJson(row.result);
+    }
+    const entry = this.volatileCache.get(cacheKey);
+    if (!entry || Date.now() > entry.expiresAt) return null;
+    return entry.result;
+  }
+  async setCachedToolResult(cacheKey, result, ttlSeconds) {
+    const expiresAt = Date.now() + ttlSeconds * 1e3;
+    if (this.toolDelegates?.toolCache) {
+      await this.toolDelegates.toolCache.upsert({
+        where: { cacheKey },
+        create: { cacheKey, result: JSON.stringify(result), expiresAt },
+        update: { result: JSON.stringify(result), expiresAt }
+      });
+      return;
+    }
+    this.volatileCache.set(cacheKey, { result, expiresAt });
+  }
+  async getStateValue(key) {
+    if (this.toolDelegates?.sharedState) {
+      const row = await this.toolDelegates.sharedState.findUnique({
+        where: { stateKey: key }
+      });
+      if (!row || row.expiresAt && Date.now() > Number(row.expiresAt)) return null;
+      return tryParseJson(row.value);
+    }
+    const entry = this.volatileState.get(key);
+    if (!entry || entry.expiresAt && Date.now() > entry.expiresAt) return null;
+    return entry.value;
+  }
+  async setStateValue(key, value, ttlSeconds) {
+    const expiresAt = ttlSeconds ? Date.now() + ttlSeconds * 1e3 : null;
+    if (this.toolDelegates?.sharedState) {
+      await this.toolDelegates.sharedState.upsert({
+        where: { stateKey: key },
+        create: { stateKey: key, value: JSON.stringify(value), expiresAt },
+        update: { value: JSON.stringify(value), expiresAt }
+      });
+      return;
+    }
+    this.volatileState.set(key, { value, expiresAt: expiresAt ?? void 0 });
+  }
+  async deleteStateValue(key) {
+    if (this.toolDelegates?.sharedState) {
+      await this.toolDelegates.sharedState.delete({
+        where: { stateKey: key }
+      });
+      return;
+    }
+    this.volatileState.delete(key);
+  }
+};
+
+// src/agent/adapters/sqlite-adapter.ts
+function parseSqliteRow(row) {
+  let result = void 0;
+  let metadata = void 0;
+  try {
+    if (row.result) {
+      result = JSON.parse(row.result);
+    }
+  } catch {
+  }
+  try {
+    if (row.metadata) {
+      metadata = JSON.parse(row.metadata);
+    }
+  } catch {
+  }
+  return {
+    workflowId: row.workflow_id,
+    stepId: row.step_id,
+    runId: metadata?.runId ?? row.workflow_id,
+    status: row.status,
+    result,
+    error: row.error ?? void 0,
+    piiDetectedCount: metadata?.piiDetectedCount,
+    tokens: metadata?.tokens,
+    costUsd: metadata?.costUsd,
+    metadata,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function parseExecutionRow(row) {
+  let inputArgs = row.input_args;
+  let outputSummary = row.output_summary;
+  try {
+    if (typeof row.input_args === "string") inputArgs = JSON.parse(row.input_args);
+  } catch {
+  }
+  try {
+    if (typeof row.output_summary === "string") outputSummary = JSON.parse(row.output_summary);
+  } catch {
+  }
+  return {
+    executionId: row.execution_id,
+    workflowId: row.workflow_id ?? void 0,
+    stepId: row.step_id ?? void 0,
+    runId: row.workflow_id ?? void 0,
+    toolId: row.tool_id,
+    parentToolId: row.parent_tool_id ?? void 0,
+    aliasUsed: row.alias_used ?? void 0,
+    depth: Number(row.depth),
+    inputArgs,
+    outputSummary,
+    durationMs: Number(row.duration_ms),
+    status: row.status,
+    error: row.error ?? void 0,
+    piiFilteredCount: row.pii_filtered_count !== null && row.pii_filtered_count !== void 0 ? Number(row.pii_filtered_count) : void 0,
+    costUsd: row.cost_usd !== null && row.cost_usd !== void 0 ? Number(row.cost_usd) : void 0,
+    createdAt: row.created_at
+  };
+}
+var SQLiteStorageAdapter = class {
+  db;
+  constructor(db) {
+    this.db = db;
+    this.initTables();
+  }
+  initTables() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS avantgate_steps (
+        workflow_id TEXT NOT NULL,
+        step_id TEXT NOT NULL,
+        status TEXT NOT NULL,
+        result TEXT,
+        error TEXT,
+        metadata TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        PRIMARY KEY (workflow_id, step_id)
+      );
+
+      CREATE TABLE IF NOT EXISTS avantgate_tool_executions (
+        execution_id TEXT PRIMARY KEY,
+        workflow_id TEXT,
+        step_id TEXT,
+        tool_id TEXT NOT NULL,
+        parent_tool_id TEXT,
+        alias_used TEXT,
+        depth INTEGER NOT NULL,
+        input_args TEXT,
+        output_summary TEXT,
+        duration_ms INTEGER NOT NULL,
+        status TEXT NOT NULL,
+        error TEXT,
+        pii_filtered_count INTEGER,
+        cost_usd REAL,
+        created_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS avantgate_tool_cache (
+        cache_key TEXT PRIMARY KEY,
+        result TEXT NOT NULL,
+        expires_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS avantgate_shared_state (
+        state_key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        expires_at INTEGER
+      );
+    `);
+  }
+  async getStep(workflowId, stepId) {
+    const stmt = this.db.prepare(
+      "SELECT * FROM avantgate_steps WHERE workflow_id = ? AND step_id = ?"
+    );
+    const row = stmt.get(workflowId, stepId);
+    if (!row) {
+      return null;
+    }
+    return parseSqliteRow(row);
+  }
+  async saveStep(step) {
+    const stmt = this.db.prepare(`
+      INSERT INTO avantgate_steps (
+        workflow_id, step_id, status, result, error, metadata, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(workflow_id, step_id) DO UPDATE SET
+        status = excluded.status,
+        result = excluded.result,
+        error = excluded.error,
+        metadata = excluded.metadata,
+        updated_at = excluded.updated_at;
+    `);
+    const mergedMetadata = {
+      ...step.metadata ?? {},
+      ...step.runId ? { runId: step.runId } : {},
+      ...step.piiDetectedCount !== void 0 ? { piiDetectedCount: step.piiDetectedCount } : {},
+      ...step.tokens ? { tokens: step.tokens } : {},
+      ...step.costUsd !== void 0 ? { costUsd: step.costUsd } : {}
+    };
+    const resultStr = step.result !== void 0 ? JSON.stringify(step.result) : null;
+    const metadataStr = Object.keys(mergedMetadata).length > 0 ? JSON.stringify(mergedMetadata) : null;
+    stmt.run(
+      step.workflowId,
+      step.stepId,
+      step.status,
+      resultStr,
+      step.error ?? null,
+      metadataStr,
+      step.createdAt,
+      step.updatedAt
+    );
+  }
+  async updateStepStatus(workflowId, stepId, status, patch) {
+    const existing = await this.getStep(workflowId, stepId);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const updated = {
+      workflowId,
+      stepId,
+      status,
+      result: patch?.result !== void 0 ? patch.result : existing?.result,
+      error: patch?.error !== void 0 ? patch.error : existing?.error,
+      metadata: patch?.metadata !== void 0 ? patch.metadata : existing?.metadata,
+      createdAt: existing?.createdAt ?? now,
+      updatedAt: now
+    };
+    await this.saveStep(updated);
+  }
+  async listSteps(workflowId) {
+    const stmt = this.db.prepare(
+      "SELECT * FROM avantgate_steps WHERE workflow_id = ? ORDER BY created_at ASC"
+    );
+    const rows = stmt.all(workflowId);
+    return rows.map(parseSqliteRow);
+  }
+  async saveToolExecution(record) {
+    const stmt = this.db.prepare(`
+      INSERT INTO avantgate_tool_executions (
+        execution_id, workflow_id, step_id, tool_id, parent_tool_id, alias_used,
+        depth, input_args, output_summary, duration_ms, status, error,
+        pii_filtered_count, cost_usd, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      record.executionId,
+      record.workflowId ?? null,
+      record.stepId ?? null,
+      record.toolId,
+      record.parentToolId ?? null,
+      record.aliasUsed ?? null,
+      record.depth,
+      record.inputArgs !== void 0 ? JSON.stringify(record.inputArgs) : null,
+      record.outputSummary !== void 0 ? JSON.stringify(record.outputSummary) : null,
+      record.durationMs,
+      record.status,
+      record.error ?? null,
+      record.piiFilteredCount ?? null,
+      record.costUsd ?? null,
+      record.createdAt
+    );
+  }
+  async listToolExecutions(workflowId, stepId) {
+    let query = "SELECT * FROM avantgate_tool_executions";
+    const params = [];
+    if (workflowId && stepId) {
+      query += " WHERE workflow_id = ? AND step_id = ?";
+      params.push(workflowId, stepId);
+    } else if (workflowId) {
+      query += " WHERE workflow_id = ?";
+      params.push(workflowId);
+    }
+    query += " ORDER BY created_at ASC";
+    const stmt = this.db.prepare(query);
+    const rows = stmt.all(...params);
+    return rows.map(parseExecutionRow);
+  }
+  async getCachedToolResult(cacheKey) {
+    const stmt = this.db.prepare(
+      "SELECT result, expires_at FROM avantgate_tool_cache WHERE cache_key = ?"
+    );
+    const row = stmt.get(cacheKey);
+    if (!row) {
+      return null;
+    }
+    if (Date.now() > Number(row.expires_at)) {
+      this.db.prepare("DELETE FROM avantgate_tool_cache WHERE cache_key = ?").run(cacheKey);
+      return null;
+    }
+    try {
+      return JSON.parse(row.result);
+    } catch {
+      return null;
+    }
+  }
+  async setCachedToolResult(cacheKey, result, ttlSeconds) {
+    const stmt = this.db.prepare(`
+      INSERT INTO avantgate_tool_cache (cache_key, result, expires_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(cache_key) DO UPDATE SET
+        result = excluded.result,
+        expires_at = excluded.expires_at;
+    `);
+    const expiresAt = Date.now() + ttlSeconds * 1e3;
+    stmt.run(cacheKey, JSON.stringify(result), expiresAt);
+  }
+  async getStateValue(key) {
+    const stmt = this.db.prepare(
+      "SELECT value, expires_at FROM avantgate_shared_state WHERE state_key = ?"
+    );
+    const row = stmt.get(key);
+    if (!row) {
+      return null;
+    }
+    if (row.expires_at && Date.now() > Number(row.expires_at)) {
+      this.db.prepare("DELETE FROM avantgate_shared_state WHERE state_key = ?").run(key);
+      return null;
+    }
+    try {
+      return JSON.parse(row.value);
+    } catch {
+      return null;
+    }
+  }
+  async setStateValue(key, value, ttlSeconds) {
+    const stmt = this.db.prepare(`
+      INSERT INTO avantgate_shared_state (state_key, value, expires_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(state_key) DO UPDATE SET
+        value = excluded.value,
+        expires_at = excluded.expires_at;
+    `);
+    const expiresAt = ttlSeconds ? Date.now() + ttlSeconds * 1e3 : null;
+    stmt.run(key, JSON.stringify(value), expiresAt);
+  }
+  async deleteStateValue(key) {
+    this.db.prepare("DELETE FROM avantgate_shared_state WHERE state_key = ?").run(key);
+  }
+};
+
+// src/agent/adapters/platform-adapter.ts
+function mapStepToEvent(record) {
+  const now = record.updatedAt || record.createdAt || (/* @__PURE__ */ new Date()).toISOString();
+  if (record.status === "RUNNING") {
+    const startEvent = {
+      type: "STEP_START",
+      timestamp: now,
+      stepName: record.stepId,
+      metadata: record.metadata
+    };
+    return startEvent;
+  }
+  if (record.status === "COMPLETED") {
+    const completedEvent = {
+      type: "STEP_COMPLETED",
+      timestamp: now,
+      stepName: record.stepId,
+      piiDetectedCount: record.piiDetectedCount,
+      resultSummary: record.result,
+      metadata: record.metadata
+    };
+    return completedEvent;
+  }
+  if (record.status === "FAILED") {
+    const failedEvent = {
+      type: "STEP_FAILED",
+      timestamp: now,
+      stepName: record.stepId,
+      error: record.error ?? "Step execution failed"
+    };
+    return failedEvent;
+  }
+  if (record.status === "WAITING_APPROVAL") {
+    const approvalEvent = {
+      type: "STEP_APPROVAL_REQUEST",
+      timestamp: now,
+      stepName: record.stepId,
+      actionType: record.metadata?.actionType ?? "MANUAL_APPROVAL",
+      payloadSummary: record.result ?? record.metadata
+    };
+    return approvalEvent;
+  }
+  return null;
+}
+function mapToolExecutionToEvent(record) {
+  return {
+    type: "TOOL_EXECUTION",
+    timestamp: record.createdAt,
+    toolId: record.toolId,
+    toolName: record.toolId,
+    aliasUsed: record.aliasUsed,
+    durationMs: record.durationMs,
+    success: record.status === "SUCCESS",
+    parentToolId: record.parentToolId,
+    depth: record.depth,
+    llmSummary: record.outputSummary,
+    piiFilteredCount: record.piiFilteredCount,
+    tokens: record.tokens,
+    costUsd: record.costUsd,
+    cached: record.cached,
+    error: record.error
+  };
+}
+var PlatformStorageAdapter = class {
+  exporter;
+  primary;
+  constructor(config) {
+    this.exporter = config.exporter;
+    this.primary = config.primaryStorage ?? new MemoryStorageAdapter();
+  }
+  async getStep(workflowId, stepId) {
+    return this.primary.getStep(workflowId, stepId);
+  }
+  async saveStep(record) {
+    await this.primary.saveStep(record);
+    const event = mapStepToEvent(record);
+    if (!event) return;
+    const runId = record.runId ?? record.workflowId;
+    this.exporter.enqueue(runId, event, record.tokens ? { ...record.tokens, costUsd: record.costUsd } : void 0);
+  }
+  async updateStepStatus(workflowId, stepId, status, updates) {
+    await this.primary.updateStepStatus(workflowId, stepId, status, updates);
+    const existing = await this.primary.getStep(workflowId, stepId);
+    if (!existing) return;
+    const event = mapStepToEvent(existing);
+    if (!event) return;
+    const runId = existing.runId ?? workflowId;
+    this.exporter.enqueue(runId, event);
+  }
+  async listSteps(workflowId) {
+    return this.primary.listSteps(workflowId);
+  }
+  async saveToolExecution(record) {
+    if (this.primary.saveToolExecution) {
+      await this.primary.saveToolExecution(record);
+    }
+    const event = mapToolExecutionToEvent(record);
+    const runId = record.runId ?? record.workflowId ?? "default-run";
+    this.exporter.enqueue(runId, event, record.tokens ? { ...record.tokens, costUsd: record.costUsd } : void 0);
+  }
+  async listToolExecutions(workflowId, stepId) {
+    if (this.primary.listToolExecutions) {
+      return this.primary.listToolExecutions(workflowId, stepId);
+    }
+    return [];
+  }
+  async getCachedToolResult(cacheKey) {
+    if (this.primary.getCachedToolResult) {
+      return this.primary.getCachedToolResult(cacheKey);
+    }
+    return null;
+  }
+  async setCachedToolResult(cacheKey, result, ttlSeconds) {
+    if (this.primary.setCachedToolResult) {
+      await this.primary.setCachedToolResult(cacheKey, result, ttlSeconds);
+    }
+  }
+  async getStateValue(key) {
+    if (this.primary.getStateValue) {
+      return this.primary.getStateValue(key);
+    }
+    return null;
+  }
+  async setStateValue(key, value, ttlSeconds) {
+    if (this.primary.setStateValue) {
+      await this.primary.setStateValue(key, value, ttlSeconds);
+    }
+  }
+  async deleteStateValue(key) {
+    if (this.primary.deleteStateValue) {
+      await this.primary.deleteStateValue(key);
+    }
+  }
+  async clearStateValues() {
+    if (this.primary.clearStateValues) {
+      await this.primary.clearStateValues();
+    }
+  }
+};
+
+// src/agent/telemetry/http-exporter.ts
+var DEFAULT_ENDPOINT = "https://api.avantgate.cloud/api/v1/ingest/events";
+var DEFAULT_INTERVAL_MS = 5e3;
+var DEFAULT_MAX_BATCH = 50;
+var DEFAULT_MAX_QUEUE = 1e3;
+function aggregateUsage(items) {
+  let prompt = 0;
+  let completion = 0;
+  let total = 0;
+  let cost = 0;
+  let hasUsage = false;
+  for (const item of items) {
+    if (!item.usage) continue;
+    hasUsage = true;
+    prompt += item.usage.promptTokens ?? 0;
+    completion += item.usage.completionTokens ?? 0;
+    total += item.usage.totalTokens ?? 0;
+    cost += item.usage.costUsd ?? 0;
+  }
+  if (!hasUsage) return void 0;
+  return { promptTokens: prompt, completionTokens: completion, totalTokens: total, costUsd: cost };
+}
+function buildPayloads(items, agentName) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const list = grouped.get(item.runId) ?? [];
+    list.push(item);
+    grouped.set(item.runId, list);
+  }
+  const payloads = [];
+  for (const [runId, runItems] of grouped.entries()) {
+    payloads.push({
+      runId,
+      agentName,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      events: runItems.map((ri) => ri.event),
+      usage: aggregateUsage(runItems)
+    });
+  }
+  return payloads;
+}
+async function sendPayload(payload, endpoint, apiKey, fetchFn) {
+  const response = await fetchFn(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    throw new Error(`Telemetry ingestion failed: ${response.status} ${response.statusText}`);
+  }
+}
+var HttpTelemetryExporter = class {
+  apiKey;
+  endpoint;
+  agentName;
+  batchIntervalMs;
+  maxBatchSize;
+  maxQueueSize;
+  fetchFn;
+  onError;
+  queue = [];
+  timer = null;
+  isFlushing = false;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.endpoint = options.endpoint ?? DEFAULT_ENDPOINT;
+    this.agentName = options.agentName;
+    this.batchIntervalMs = options.batchIntervalMs ?? DEFAULT_INTERVAL_MS;
+    this.maxBatchSize = options.maxBatchSize ?? DEFAULT_MAX_BATCH;
+    this.maxQueueSize = options.maxQueueSize ?? DEFAULT_MAX_QUEUE;
+    this.fetchFn = options.fetchFn ?? globalThis.fetch;
+    this.onError = options.onError;
+    this.startTimer();
+  }
+  startTimer() {
+    if (this.batchIntervalMs <= 0) return;
+    this.timer = setInterval(() => {
+      void this.flush();
+    }, this.batchIntervalMs);
+    if (this.timer && typeof this.timer === "object" && "unref" in this.timer) {
+      this.timer.unref();
+    }
+  }
+  enqueue(runId, event, usage) {
+    if (this.queue.length >= this.maxQueueSize) {
+      this.queue.shift();
+    }
+    this.queue.push({ runId, event, usage });
+    if (this.queue.length >= this.maxBatchSize) {
+      void this.flush();
+    }
+  }
+  async flush() {
+    if (this.isFlushing || this.queue.length === 0) return;
+    this.isFlushing = true;
+    const toProcess = this.queue.splice(0, this.maxBatchSize);
+    const payloads = buildPayloads(toProcess, this.agentName);
+    let hadError = false;
+    try {
+      await Promise.all(
+        payloads.map(
+          (p) => sendPayload(p, this.endpoint, this.apiKey, this.fetchFn)
+        )
+      );
+    } catch (err) {
+      hadError = true;
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.onError?.(error);
+    } finally {
+      this.isFlushing = false;
+      if (!hadError && this.queue.length > 0) {
+        void this.flush();
+      }
+    }
+  }
+  async shutdown() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    await this.flush();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentToolFactory,
+  CircularToolCallError,
+  CompositeToolStrategy,
+  DtoValidationError,
+  HttpTelemetryExporter,
+  KeyValueStorageAdapter,
+  MemoryStorageAdapter,
+  PhaseBasedToolStrategy,
+  PiiLeakError,
+  PlatformStorageAdapter,
+  PrismaStorageAdapter,
+  RoleBasedToolStrategy,
+  SQLiteStorageAdapter,
+  StepExecutionError,
+  StepSuspendedError,
+  ToolAccessDeniedError,
+  ToolCallDepthExceededError,
+  ToolNotFoundError,
+  ToolRegistry,
+  ToolSubCallQuotaError,
+  applyToolStrategy,
+  auditToolResult,
+  createCustomStorageAdapter,
+  createIsolatedTool,
+  createStepRunner,
+  createToolInvoker,
+  createToolSharedState,
+  dto
+});