@inkeep/agents-run-api 0.31.7 → 0.32.1

package/README.md

@@ -44,7 +44,7 @@ pnpm db:migrate
 ```env
 ENVIRONMENT=development|production|test
 PORT=3003
-DB_FILE_NAME=path/to/sqlite.db
+DATABASE_URL=postgresql://dbuser:secretpassword@database.server.com:3211/mydb
 ANTHROPIC_API_KEY=required
 OPENAI_API_KEY=optional
 LOG_LEVEL=debug|info|warn|error
@@ -73,7 +73,7 @@ pnpm test src/__tests__/a2a/ # Run A2A-specific tests
 
 The API uses environment-based configuration with defaults for local development. Key configuration areas:
 
-- **Database**: SQLite connection via `DB_FILE_NAME`
+- **Database**: PostgreSQL connection via `DATABASE_URL`
 - **AI Models**: Anthropic and OpenAI API keys
 - **Observability**: OpenTelemetry tracing support
 - **CORS**: Configurable for web clients

package/dist/{SandboxExecutorFactory-QVNCS6YN.js → SandboxExecutorFactory-D3OSN652.js}

@@ -1,11 +1,11 @@
-import { getLogger as getLogger$1 } from './chunk-A2S7GSHL.js';
+import { getLogger } from './chunk-A2S7GSHL.js';
+import { FUNCTION_TOOL_SANDBOX_POOL_TTL_MS, FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS, FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT, FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES, FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS } from './chunk-IVALDC72.js';
 import { __publicField } from './chunk-PKBMQBKP.js';
 import { spawn } from 'child_process';
 import crypto, { createHash } from 'crypto';
 import { mkdirSync, existsSync, rmSync, writeFileSync } from 'fs';
 import { tmpdir } from 'os';
 import { join } from 'path';
-import { getLogger } from '@inkeep/agents-core';
 import { Sandbox } from '@vercel/sandbox';
 
 // src/tools/sandbox-utils.ts
@@ -56,7 +56,7 @@ function parseExecutionResult(stdout, functionId, logger4) {
 // src/tools/NativeSandboxExecutor.ts
 var logger = getLogger("native-sandbox-executor");
 var ExecutionSemaphore = class {
-  constructor(permits, maxWaitTimeMs = 3e4) {
+  constructor(permits, maxWaitTimeMs = FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS) {
     __publicField(this, "permits");
     __publicField(this, "waitQueue", []);
     __publicField(this, "maxWaitTime");
@@ -111,9 +111,6 @@ var _NativeSandboxExecutor = class _NativeSandboxExecutor {
   constructor() {
     __publicField(this, "tempDir");
     __publicField(this, "sandboxPool", {});
-    __publicField(this, "POOL_TTL", 5 * 60 * 1e3);
-    // 5 minutes
-    __publicField(this, "MAX_USE_COUNT", 50);
     __publicField(this, "executionSemaphores", /* @__PURE__ */ new Map());
     this.tempDir = join(tmpdir(), "inkeep-sandboxes");
     this.ensureTempDir();
@@ -162,7 +159,7 @@ var _NativeSandboxExecutor = class _NativeSandboxExecutor {
     const sandbox = this.sandboxPool[poolKey];
     if (sandbox && existsSync(sandbox.sandboxDir)) {
       const now = Date.now();
-      if (now - sandbox.lastUsed < this.POOL_TTL && sandbox.useCount < this.MAX_USE_COUNT) {
+      if (now - sandbox.lastUsed < FUNCTION_TOOL_SANDBOX_POOL_TTL_MS && sandbox.useCount < FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT) {
         sandbox.lastUsed = now;
         sandbox.useCount++;
         logger.debug(
@@ -170,7 +167,7 @@ var _NativeSandboxExecutor = class _NativeSandboxExecutor {
             poolKey,
             useCount: sandbox.useCount,
             sandboxDir: sandbox.sandboxDir,
-            lastUsed: new Date(sandbox.lastUsed).toISOString()
+            lastUsed: new Date(sandbox.lastUsed)
           },
           "Reusing cached sandbox"
         );
@@ -208,7 +205,7 @@ var _NativeSandboxExecutor = class _NativeSandboxExecutor {
       const now = Date.now();
       const keysToDelete = [];
       for (const [key, sandbox] of Object.entries(this.sandboxPool)) {
-        if (now - sandbox.lastUsed > this.POOL_TTL || sandbox.useCount >= this.MAX_USE_COUNT) {
+        if (now - sandbox.lastUsed > FUNCTION_TOOL_SANDBOX_POOL_TTL_MS || sandbox.useCount >= FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT) {
           this.cleanupSandbox(sandbox.sandboxDir);
           keysToDelete.push(key);
         }
@@ -219,7 +216,7 @@ var _NativeSandboxExecutor = class _NativeSandboxExecutor {
       if (keysToDelete.length > 0) {
         logger.debug({ cleanedCount: keysToDelete.length }, "Cleaned up expired sandboxes");
       }
-    }, 6e4);
+    }, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS);
   }
   detectModuleType(executeCode, configuredRuntime) {
     const esmPatterns = [
@@ -329,7 +326,7 @@ var _NativeSandboxExecutor = class _NativeSandboxExecutor {
       writeFileSync(join(sandboxDir, `index.${fileExtension}`), executionCode, "utf8");
       const result = await this.executeInSandbox(
         sandboxDir,
-        config.sandboxConfig?.timeout || 3e4,
+        config.sandboxConfig?.timeout || FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT,
         moduleType,
         config.sandboxConfig
       );
@@ -394,13 +391,16 @@ var _NativeSandboxExecutor = class _NativeSandboxExecutor {
       let stdout = "";
       let stderr = "";
       let outputSize = 0;
-      const MAX_OUTPUT_SIZE = 1024 * 1024;
       node.stdout?.on("data", (data) => {
         const dataStr = data.toString();
         outputSize += dataStr.length;
-        if (outputSize > MAX_OUTPUT_SIZE) {
+        if (outputSize > FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES) {
           node.kill("SIGTERM");
-          reject(new Error(`Output size exceeded limit of ${MAX_OUTPUT_SIZE} bytes`));
+          reject(
+            new Error(
+              `Output size exceeded limit of ${FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES} bytes`
+            )
+          );
           return;
         }
         stdout += dataStr;
@@ -408,9 +408,13 @@ var _NativeSandboxExecutor = class _NativeSandboxExecutor {
       node.stderr?.on("data", (data) => {
         const dataStr = data.toString();
         outputSize += dataStr.length;
-        if (outputSize > MAX_OUTPUT_SIZE) {
+        if (outputSize > FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES) {
           node.kill("SIGTERM");
-          reject(new Error(`Output size exceeded limit of ${MAX_OUTPUT_SIZE} bytes`));
+          reject(
+            new Error(
+              `Output size exceeded limit of ${FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES} bytes`
+            )
+          );
           return;
         }
         stderr += dataStr;
@@ -462,14 +466,11 @@ var _NativeSandboxExecutor = class _NativeSandboxExecutor {
 };
 __publicField(_NativeSandboxExecutor, "instance", null);
 var NativeSandboxExecutor = _NativeSandboxExecutor;
-var logger2 = getLogger$1("VercelSandboxExecutor");
+var logger2 = getLogger("VercelSandboxExecutor");
 var _VercelSandboxExecutor = class _VercelSandboxExecutor {
   constructor(config) {
     __publicField(this, "config");
     __publicField(this, "sandboxPool", /* @__PURE__ */ new Map());
-    __publicField(this, "POOL_TTL", 5 * 60 * 1e3);
-    // 5 minutes
-    __publicField(this, "MAX_USE_COUNT", 50);
     __publicField(this, "cleanupInterval", null);
     this.config = config;
     logger2.info(
@@ -508,14 +509,14 @@ var _VercelSandboxExecutor = class _VercelSandboxExecutor {
     if (!cached) return null;
     const now = Date.now();
     const age = now - cached.createdAt;
-    if (age > this.POOL_TTL || cached.useCount >= this.MAX_USE_COUNT) {
+    if (age > FUNCTION_TOOL_SANDBOX_POOL_TTL_MS || cached.useCount >= FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT) {
       logger2.debug(
         {
           dependencyHash,
           age,
           useCount: cached.useCount,
-          ttl: this.POOL_TTL,
-          maxUseCount: this.MAX_USE_COUNT
+          ttl: FUNCTION_TOOL_SANDBOX_POOL_TTL_MS,
+          maxUseCount: FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT
         },
         "Sandbox expired, will create new one"
       );
@@ -578,32 +579,28 @@ var _VercelSandboxExecutor = class _VercelSandboxExecutor {
    * Start periodic cleanup of expired sandboxes
    */
   startPoolCleanup() {
-    this.cleanupInterval = setInterval(
-      () => {
-        const now = Date.now();
-        const toRemove = [];
-        for (const [hash, cached] of this.sandboxPool.entries()) {
-          const age = now - cached.createdAt;
-          if (age > this.POOL_TTL || cached.useCount >= this.MAX_USE_COUNT) {
-            toRemove.push(hash);
-          }
+    this.cleanupInterval = setInterval(() => {
+      const now = Date.now();
+      const toRemove = [];
+      for (const [hash, cached] of this.sandboxPool.entries()) {
+        const age = now - cached.createdAt;
+        if (age > FUNCTION_TOOL_SANDBOX_POOL_TTL_MS || cached.useCount >= FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT) {
+          toRemove.push(hash);
         }
-        if (toRemove.length > 0) {
-          logger2.info(
-            {
-              count: toRemove.length,
-              poolSize: this.sandboxPool.size
-            },
-            "Cleaning up expired sandboxes"
-          );
-          for (const hash of toRemove) {
-            this.removeSandbox(hash);
-          }
+      }
+      if (toRemove.length > 0) {
+        logger2.info(
+          {
+            count: toRemove.length,
+            poolSize: this.sandboxPool.size
+          },
+          "Cleaning up expired sandboxes"
+        );
+        for (const hash of toRemove) {
+          this.removeSandbox(hash);
         }
-      },
-      60 * 1e3
-      // Run every minute
-    );
+      }
+    }, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS);
   }
   /**
    * Cleanup all sandboxes and stop cleanup interval
@@ -863,7 +860,7 @@ __publicField(_VercelSandboxExecutor, "instance");
 var VercelSandboxExecutor = _VercelSandboxExecutor;
 
 // src/tools/SandboxExecutorFactory.ts
-var logger3 = getLogger$1("SandboxExecutorFactory");
+var logger3 = getLogger("SandboxExecutorFactory");
 var _SandboxExecutorFactory = class _SandboxExecutorFactory {
   constructor() {
     __publicField(this, "nativeExecutor", null);

package/dist/{chunk-IMJLQGAX.js → chunk-54Z7AOV4.js}

@@ -1,13 +1,14 @@
-import { dbClient_default } from './chunk-TRNLEUK2.js';
-import { createMessage, generateId, getConversationHistory } from '@inkeep/agents-core';
+import { dbClient_default } from './chunk-BYF2SHLS.js';
+import { CONVERSATION_HISTORY_DEFAULT_LIMIT } from './chunk-IVALDC72.js';
+import { CONVERSATION_HISTORY_MAX_OUTPUT_TOKENS_DEFAULT, createMessage, generateId, getConversationHistory } from '@inkeep/agents-core';
 
 function createDefaultConversationHistoryConfig(mode = "full") {
   return {
     mode,
-    limit: 50,
+    limit: CONVERSATION_HISTORY_DEFAULT_LIMIT,
     includeInternal: true,
     messageTypes: ["chat"],
-    maxOutputTokens: 4e3
+    maxOutputTokens: CONVERSATION_HISTORY_MAX_OUTPUT_TOKENS_DEFAULT
   };
 }
 function extractA2AMessageText(parts) {
@@ -96,7 +97,7 @@ async function getScopedHistory({
     return [];
   }
 }
-async function getUserFacingHistory(tenantId, projectId, conversationId, limit = 50) {
+async function getUserFacingHistory(tenantId, projectId, conversationId, limit = CONVERSATION_HISTORY_DEFAULT_LIMIT) {
   return await getConversationHistory(dbClient_default)({
     scopes: { tenantId, projectId },
     conversationId,
@@ -190,7 +191,7 @@ async function getConversationScopedArtifacts(params) {
       return [];
     }
     const { getLedgerArtifacts } = await import('@inkeep/agents-core');
-    const dbClient = (await import('./dbClient-PLEBWGM4.js')).default;
+    const dbClient = (await import('./dbClient-XRZSZEYI.js')).default;
     const visibleTaskIds = visibleMessages.map((msg) => msg.taskId).filter((taskId) => Boolean(taskId));
     const referenceArtifacts = [];
     for (const taskId of visibleTaskIds) {

package/dist/chunk-BYF2SHLS.js

@@ -0,0 +1,13 @@
+import { env } from './chunk-N2FZD53W.js';
+import { createDatabaseClient } from '@inkeep/agents-core';
+
+var getDbConfig = () => {
+  if (env.ENVIRONMENT === "test") {
+    return {};
+  }
+  return { connectionString: env.DATABASE_URL };
+};
+var dbClient = createDatabaseClient(getDbConfig());
+var dbClient_default = dbClient;
+
+export { dbClient_default };

package/dist/chunk-IVALDC72.js

@@ -0,0 +1,204 @@
+import { loadEnvironmentFiles } from '@inkeep/agents-core';
+import { z } from 'zod';
+
+// src/constants/execution-limits/index.ts
+
+// src/constants/execution-limits/defaults.ts
+var executionLimitsDefaults = {
+  // Sub Agent Turn Execution
+  // During a Sub Agent's turn, it makes decisions by calling the LLM (language model). Each decision
+  // point is called a "generation step" - for example, deciding to call a tool, transfer to another
+  // Sub Agent, delegate a subtask, or send a response to the user.
+  // AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS: Maximum errors tolerated during a single Sub Agent's turn before stopping execution
+  // AGENT_EXECUTION_MAX_GENERATION_STEPS: Maximum LLM inference calls allowed within a single Sub Agent turn
+  AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS: 3,
+  AGENT_EXECUTION_MAX_GENERATION_STEPS: 5,
+  // Sub Agent Decision-Making Timeouts
+  // These control how long to wait for the LLM to make decisions during a Sub Agent's turn.
+  // "First call" = initial decision at start of turn (may include tool results from previous actions)
+  // "Subsequent call" = follow-up decisions after executing tools within the same turn
+  // Streaming mode has longer timeout because it waits for the full streamed response to the user
+  // LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING: Timeout for initial streaming response to user
+  // LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING: Timeout for initial non-streaming (internal) decision
+  // LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS: Timeout for follow-up decisions after tool execution
+  // LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS: Maximum timeout allowed regardless of configuration
+  LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING: 27e4,
+  // 4.5 minutes
+  LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING: 9e4,
+  // 1.5 minutes
+  LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS: 9e4,
+  // 1.5 minutes
+  LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS: 6e5,
+  // 10 minutes
+  // Function Tool Execution (Sandboxed Environments)
+  // Function Tools are custom JavaScript functions that Sub Agents can call. They run in secure
+  // isolated sandboxes (containerized environments) to prevent malicious code execution.
+  // For performance, sandboxes are cached and reused across multiple tool calls until they expire.
+  // FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT: Maximum execution time for a Function Tool call
+  // FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT: Virtual CPUs allocated to each sandbox (affects compute capacity)
+  // FUNCTION_TOOL_SANDBOX_POOL_TTL_MS: Time-to-live for cached sandboxes (after this, sandbox is discarded)
+  // FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT: Maximum reuses of a sandbox before it's refreshed (prevents resource leaks)
+  // FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES: Maximum size of Function Tool output (prevents memory exhaustion)
+  // FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS: Maximum wait time for sandbox to become available when pool is full
+  // FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS: How often to check for and remove expired sandboxes from the pool
+  FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT: 3e4,
+  // 30 seconds
+  FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT: 4,
+  FUNCTION_TOOL_SANDBOX_POOL_TTL_MS: 3e5,
+  // 5 minutes
+  FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT: 50,
+  FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES: 1048576,
+  // 1 MB
+  FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS: 3e4,
+  // 30 seconds
+  FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS: 6e4,
+  // 1 minute
+  // MCP Tool Execution
+  // MCP (Model Context Protocol) Servers are external services that provide tools to Sub Agents.
+  // When a Sub Agent calls an MCP Tool, the request is sent to the external MCP Server.
+  // Note: MCP connection/retry constants are defined in @inkeep/agents-core/constants/execution-limits-shared
+  // MCP_TOOL_REQUEST_TIMEOUT_MS_DEFAULT: Maximum wait time for an MCP tool call to complete
+  MCP_TOOL_REQUEST_TIMEOUT_MS_DEFAULT: 6e4,
+  // 60 seconds
+  // Sub Agent Delegation (Retry Strategy)
+  // When a Sub Agent delegates a subtask to another Sub Agent, it uses the A2A (Agent-to-Agent)
+  // protocol to communicate. If the delegation request fails, these constants control the
+  // exponential backoff retry strategy. Formula: delay = min(INITIAL * EXPONENT^attempt, MAX)
+  // DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS: Starting delay before first retry
+  // DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS: Maximum delay between retries (caps exponential growth)
+  // DELEGATION_TOOL_BACKOFF_EXPONENT: Multiplier applied to delay after each retry (2 = doubles each time)
+  // DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS: Total time to keep retrying before giving up
+  DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS: 100,
+  DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS: 1e4,
+  // 10 seconds
+  DELEGATION_TOOL_BACKOFF_EXPONENT: 2,
+  DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS: 2e4,
+  // 20 seconds
+  // General Agent-to-Agent (A2A) Communication (Retry Strategy)
+  // These control retries for broader A2A protocol operations beyond delegation (e.g., status checks,
+  // conversation updates). Uses more conservative retry parameters than delegation-specific retries.
+  // A2A_BACKOFF_INITIAL_INTERVAL_MS: Starting delay before first retry
+  // A2A_BACKOFF_MAX_INTERVAL_MS: Maximum delay between retries
+  // A2A_BACKOFF_EXPONENT: Multiplier for exponential backoff (1.5 = grows 50% each retry)
+  // A2A_BACKOFF_MAX_ELAPSED_TIME_MS: Total time to keep retrying before giving up
+  A2A_BACKOFF_INITIAL_INTERVAL_MS: 500,
+  A2A_BACKOFF_MAX_INTERVAL_MS: 6e4,
+  // 1 minute
+  A2A_BACKOFF_EXPONENT: 1.5,
+  A2A_BACKOFF_MAX_ELAPSED_TIME_MS: 3e4,
+  // 30 seconds
+  // Artifact Processing
+  // Artifacts are tool outputs saved for later reference by Sub Agents or users. When a tool generates
+  // an artifact, the system automatically generates a human-readable name and description using the LLM.
+  // These constants control artifact name/description generation and context window management.
+  // ARTIFACT_GENERATION_MAX_RETRIES: Retry attempts for LLM-based artifact name/description generation
+  // ARTIFACT_SESSION_MAX_PENDING: Maximum unprocessed artifacts in queue (prevents unbounded growth)
+  // ARTIFACT_SESSION_MAX_PREVIOUS_SUMMARIES: Historical artifact summaries kept in context for reference
+  // ARTIFACT_GENERATION_BACKOFF_INITIAL_MS: Starting delay for retry backoff when generation fails
+  // ARTIFACT_GENERATION_BACKOFF_MAX_MS: Maximum delay between retries (formula: min(INITIAL * 2^attempt, MAX))
+  ARTIFACT_GENERATION_MAX_RETRIES: 3,
+  ARTIFACT_SESSION_MAX_PENDING: 100,
+  ARTIFACT_SESSION_MAX_PREVIOUS_SUMMARIES: 3,
+  ARTIFACT_GENERATION_BACKOFF_INITIAL_MS: 1e3,
+  // 1 second
+  ARTIFACT_GENERATION_BACKOFF_MAX_MS: 1e4,
+  // 10 seconds
+  // Conversation Session & Cache Management
+  // A "session" represents the state of an ongoing conversation with an Agent. Tool results are cached
+  // within the session for performance - this is especially important for artifact processing where the
+  // same tool outputs may be referenced multiple times across Sub Agent turns.
+  // SESSION_TOOL_RESULT_CACHE_TIMEOUT_MS: How long tool results are kept in cache before expiring
+  // SESSION_CLEANUP_INTERVAL_MS: How often to check for and remove expired cached tool results
+  SESSION_TOOL_RESULT_CACHE_TIMEOUT_MS: 3e5,
+  // 5 minutes
+  SESSION_CLEANUP_INTERVAL_MS: 6e4,
+  // 1 minute
+  // Status Updates
+  // Status Updates are real-time progress messages sent to users during longer Sub Agent operations.
+  // The system automatically generates status updates based on activity thresholds - either after a
+  // certain number of significant events OR after a time interval (whichever comes first).
+  // Events include: tool calls, Sub Agent transfers, delegations, or other significant activities.
+  // STATUS_UPDATE_DEFAULT_NUM_EVENTS: Number of significant events before triggering a status update
+  // STATUS_UPDATE_DEFAULT_INTERVAL_SECONDS: Time interval (in seconds) before generating status update
+  STATUS_UPDATE_DEFAULT_NUM_EVENTS: 1,
+  STATUS_UPDATE_DEFAULT_INTERVAL_SECONDS: 2,
+  // Response Streaming (Internal Buffering Limits)
+  // These are internal infrastructure limits for streaming responses to users. Streaming enables
+  // real-time updates as Sub Agents generate responses, Data Components, and Status Updates.
+  // STREAM_PARSER_MAX_SNAPSHOT_SIZE: Maximum Data Component snapshots buffered before clearing old ones
+  // STREAM_PARSER_MAX_STREAMED_SIZE: Maximum streamed component IDs tracked simultaneously
+  // STREAM_PARSER_MAX_COLLECTED_PARTS: Maximum accumulated stream parts before forcing flush
+  // STREAM_BUFFER_MAX_SIZE_BYTES: Maximum total buffer size in bytes (prevents memory exhaustion)
+  // STREAM_TEXT_GAP_THRESHOLD_MS: Time gap that triggers bundling text with artifact data vs separate send
+  // STREAM_MAX_LIFETIME_MS: Maximum duration a stream can stay open before forced closure
+  STREAM_PARSER_MAX_SNAPSHOT_SIZE: 100,
+  STREAM_PARSER_MAX_STREAMED_SIZE: 1e3,
+  STREAM_PARSER_MAX_COLLECTED_PARTS: 1e4,
+  STREAM_BUFFER_MAX_SIZE_BYTES: 5242880,
+  // 5 MB
+  STREAM_TEXT_GAP_THRESHOLD_MS: 2e3,
+  // 2 seconds
+  STREAM_MAX_LIFETIME_MS: 6e5,
+  // 10 minutes
+  // Conversation History Message Retrieval
+  // CONVERSATION_HISTORY_DEFAULT_LIMIT: Default number of recent conversation messages to retrieve
+  CONVERSATION_HISTORY_DEFAULT_LIMIT: 50
+};
+
+// src/constants/execution-limits/index.ts
+loadEnvironmentFiles();
+var constantsSchema = z.object(
+  Object.fromEntries(
+    Object.keys(executionLimitsDefaults).map((key) => [
+      `AGENTS_${key}`,
+      z.coerce.number().optional()
+    ])
+  )
+);
+var parseConstants = () => {
+  const envOverrides = constantsSchema.parse(process.env);
+  return Object.fromEntries(
+    Object.entries(executionLimitsDefaults).map(([key, defaultValue]) => [
+      key,
+      envOverrides[`AGENTS_${key}`] ?? defaultValue
+    ])
+  );
+};
+var constants = parseConstants();
+var {
+  AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS,
+  AGENT_EXECUTION_MAX_GENERATION_STEPS,
+  LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING,
+  LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING,
+  LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS,
+  LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS,
+  FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT,
+  FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT,
+  FUNCTION_TOOL_SANDBOX_POOL_TTL_MS,
+  FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT,
+  FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES,
+  FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS,
+  FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS,
+  DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS,
+  DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS,
+  DELEGATION_TOOL_BACKOFF_EXPONENT,
+  DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS,
+  ARTIFACT_GENERATION_MAX_RETRIES,
+  ARTIFACT_SESSION_MAX_PENDING,
+  ARTIFACT_SESSION_MAX_PREVIOUS_SUMMARIES,
+  ARTIFACT_GENERATION_BACKOFF_INITIAL_MS,
+  ARTIFACT_GENERATION_BACKOFF_MAX_MS,
+  SESSION_TOOL_RESULT_CACHE_TIMEOUT_MS,
+  SESSION_CLEANUP_INTERVAL_MS,
+  STATUS_UPDATE_DEFAULT_NUM_EVENTS,
+  STATUS_UPDATE_DEFAULT_INTERVAL_SECONDS,
+  STREAM_PARSER_MAX_SNAPSHOT_SIZE,
+  STREAM_PARSER_MAX_STREAMED_SIZE,
+  STREAM_PARSER_MAX_COLLECTED_PARTS,
+  STREAM_BUFFER_MAX_SIZE_BYTES,
+  STREAM_TEXT_GAP_THRESHOLD_MS,
+  STREAM_MAX_LIFETIME_MS,
+  CONVERSATION_HISTORY_DEFAULT_LIMIT
+} = constants;
+
+export { AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS, AGENT_EXECUTION_MAX_GENERATION_STEPS, ARTIFACT_GENERATION_BACKOFF_INITIAL_MS, ARTIFACT_GENERATION_BACKOFF_MAX_MS, ARTIFACT_GENERATION_MAX_RETRIES, ARTIFACT_SESSION_MAX_PENDING, ARTIFACT_SESSION_MAX_PREVIOUS_SUMMARIES, CONVERSATION_HISTORY_DEFAULT_LIMIT, DELEGATION_TOOL_BACKOFF_EXPONENT, DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS, DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS, DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS, FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS, FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES, FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT, FUNCTION_TOOL_SANDBOX_POOL_TTL_MS, FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS, FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS, LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS, SESSION_CLEANUP_INTERVAL_MS, SESSION_TOOL_RESULT_CACHE_TIMEOUT_MS, STATUS_UPDATE_DEFAULT_INTERVAL_SECONDS, STATUS_UPDATE_DEFAULT_NUM_EVENTS, STREAM_BUFFER_MAX_SIZE_BYTES, STREAM_MAX_LIFETIME_MS, STREAM_PARSER_MAX_COLLECTED_PARTS, STREAM_PARSER_MAX_SNAPSHOT_SIZE, STREAM_PARSER_MAX_STREAMED_SIZE, STREAM_TEXT_GAP_THRESHOLD_MS };

package/dist/{chunk-Z4TYO3W3.js → chunk-N2FZD53W.js}

@@ -6,9 +6,7 @@ loadEnvironmentFiles();
 var envSchema = z.object({
   NODE_ENV: z.enum(["development", "production", "test"]).optional(),
   ENVIRONMENT: z.enum(["development", "production", "pentest", "test"]).optional().default("development"),
-  DB_FILE_NAME: z.string().optional(),
-  TURSO_DATABASE_URL: z.string().optional(),
-  TURSO_AUTH_TOKEN: z.string().optional(),
+  DATABASE_URL: z.string().optional(),
   AGENTS_RUN_API_URL: z.string().optional().default("http://localhost:3003"),
   LOG_LEVEL: z.enum(["trace", "debug", "info", "warn", "error"]).optional().default("debug"),
   NANGO_SERVER_URL: z.string().optional().default("https://api.nango.dev"),

package/dist/{chunk-DWEFKQTA.js → chunk-YBBSNUL3.js}

@@ -1,4 +1,4 @@
-import { env } from './chunk-Z4TYO3W3.js';
+import { env } from './chunk-N2FZD53W.js';
 import { getLogger } from './chunk-A2S7GSHL.js';
 import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
 import { BaggageSpanProcessor, ALLOW_ALL_BAGGAGE_KEYS } from '@opentelemetry/baggage-span-processor';

package/dist/{conversations-V6DNH5MW.js → conversations-ZZI6XV2G.js}

@@ -1 +1 @@
-export { createDefaultConversationHistoryConfig, getConversationScopedArtifacts, getFormattedConversationHistory, getFullConversationContext, getScopedHistory, getUserFacingHistory, saveA2AMessageResponse } from './chunk-IMJLQGAX.js';
+export { createDefaultConversationHistoryConfig, getConversationScopedArtifacts, getFormattedConversationHistory, getFullConversationContext, getScopedHistory, getUserFacingHistory, saveA2AMessageResponse } from './chunk-54Z7AOV4.js';

package/dist/dbClient-XRZSZEYI.js

@@ -0,0 +1 @@
+export { dbClient_default as default } from './chunk-BYF2SHLS.js';