@inkeep/agents-run-api 0.0.0-dev-20251109004542 → 0.0.0-dev-20251110174655

package/dist/index.cjs

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var agentsCore = require('@inkeep/agents-core');
-var z6 = require('zod');
+var z7 = require('zod');
 var child_process = require('child_process');
 var crypto = require('crypto');
 var fs = require('fs');
@@ -45,7 +45,7 @@ var fetchToNode = require('fetch-to-node');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var z6__default = /*#__PURE__*/_interopDefault(z6);
+var z7__default = /*#__PURE__*/_interopDefault(z7);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var jmespath__default = /*#__PURE__*/_interopDefault(jmespath);
 var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
@@ -67,30 +67,30 @@ var envSchema, parseEnv, env;
 var init_env = __esm({
   "src/env.ts"() {
     agentsCore.loadEnvironmentFiles();
-    envSchema = z6.z.object({
-      NODE_ENV: z6.z.enum(["development", "production", "test"]).optional(),
-      ENVIRONMENT: z6.z.enum(["development", "production", "pentest", "test"]).optional().default("development"),
-      DB_FILE_NAME: z6.z.string().optional(),
-      TURSO_DATABASE_URL: z6.z.string().optional(),
-      TURSO_AUTH_TOKEN: z6.z.string().optional(),
-      AGENTS_RUN_API_URL: z6.z.string().optional().default("http://localhost:3003"),
-      LOG_LEVEL: z6.z.enum(["trace", "debug", "info", "warn", "error"]).optional().default("debug"),
-      NANGO_SERVER_URL: z6.z.string().optional().default("https://api.nango.dev"),
-      NANGO_SECRET_KEY: z6.z.string().optional(),
-      ANTHROPIC_API_KEY: z6.z.string(),
-      OPENAI_API_KEY: z6.z.string().optional(),
-      GOOGLE_GENERATIVE_AI_API_KEY: z6.z.string().optional(),
-      INKEEP_AGENTS_RUN_API_BYPASS_SECRET: z6.z.string().optional(),
-      INKEEP_AGENTS_JWT_SIGNING_SECRET: z6.z.string().optional(),
-      OTEL_BSP_SCHEDULE_DELAY: z6.z.coerce.number().optional().default(500),
-      OTEL_BSP_MAX_EXPORT_BATCH_SIZE: z6.z.coerce.number().optional().default(64)
+    envSchema = z7.z.object({
+      NODE_ENV: z7.z.enum(["development", "production", "test"]).optional(),
+      ENVIRONMENT: z7.z.enum(["development", "production", "pentest", "test"]).optional().default("development"),
+      DB_FILE_NAME: z7.z.string().optional(),
+      TURSO_DATABASE_URL: z7.z.string().optional(),
+      TURSO_AUTH_TOKEN: z7.z.string().optional(),
+      AGENTS_RUN_API_URL: z7.z.string().optional().default("http://localhost:3003"),
+      LOG_LEVEL: z7.z.enum(["trace", "debug", "info", "warn", "error"]).optional().default("debug"),
+      NANGO_SERVER_URL: z7.z.string().optional().default("https://api.nango.dev"),
+      NANGO_SECRET_KEY: z7.z.string().optional(),
+      ANTHROPIC_API_KEY: z7.z.string(),
+      OPENAI_API_KEY: z7.z.string().optional(),
+      GOOGLE_GENERATIVE_AI_API_KEY: z7.z.string().optional(),
+      INKEEP_AGENTS_RUN_API_BYPASS_SECRET: z7.z.string().optional(),
+      INKEEP_AGENTS_JWT_SIGNING_SECRET: z7.z.string().optional(),
+      OTEL_BSP_SCHEDULE_DELAY: z7.z.coerce.number().optional().default(500),
+      OTEL_BSP_MAX_EXPORT_BATCH_SIZE: z7.z.coerce.number().optional().default(64)
     });
     parseEnv = () => {
       try {
         const parsedEnv = envSchema.parse(process.env);
         return parsedEnv;
       } catch (error) {
-        if (error instanceof z6.z.ZodError) {
+        if (error instanceof z7.z.ZodError) {
           const missingVars = error.issues.map((issue) => issue.path.join("."));
           throw new Error(
             `\u274C Invalid environment variables: ${missingVars.join(", ")}
@@ -147,6 +147,219 @@ var init_dbClient = __esm({
   }
 });
 
+// src/constants/execution-limits/defaults.ts
+var executionLimitsDefaults;
+var init_defaults = __esm({
+  "src/constants/execution-limits/defaults.ts"() {
+    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
+    };
+  }
+});
+var constantsSchema, parseConstants, constants, 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, MCP_TOOL_REQUEST_TIMEOUT_MS_DEFAULT, DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS, DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS, DELEGATION_TOOL_BACKOFF_EXPONENT, DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS, A2A_BACKOFF_INITIAL_INTERVAL_MS, A2A_BACKOFF_MAX_INTERVAL_MS, A2A_BACKOFF_EXPONENT, A2A_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;
+var init_execution_limits = __esm({
+  "src/constants/execution-limits/index.ts"() {
+    init_defaults();
+    init_defaults();
+    agentsCore.loadEnvironmentFiles();
+    constantsSchema = z7.z.object(
+      Object.fromEntries(
+        Object.keys(executionLimitsDefaults).map((key) => [
+          `AGENTS_${key}`,
+          z7.z.coerce.number().optional()
+        ])
+      )
+    );
+    parseConstants = () => {
+      const envOverrides = constantsSchema.parse(process.env);
+      return Object.fromEntries(
+        Object.entries(executionLimitsDefaults).map(([key, defaultValue]) => [
+          key,
+          envOverrides[`AGENTS_${key}`] ?? defaultValue
+        ])
+      );
+    };
+    constants = parseConstants();
+    ({
+      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,
+      MCP_TOOL_REQUEST_TIMEOUT_MS_DEFAULT,
+      DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS,
+      DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS,
+      DELEGATION_TOOL_BACKOFF_EXPONENT,
+      DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS,
+      A2A_BACKOFF_INITIAL_INTERVAL_MS,
+      A2A_BACKOFF_MAX_INTERVAL_MS,
+      A2A_BACKOFF_EXPONENT,
+      A2A_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);
+  }
+});
+
 // src/data/conversations.ts
 var conversations_exports = {};
 __export(conversations_exports, {
@@ -161,10 +374,10 @@ __export(conversations_exports, {
 function createDefaultConversationHistoryConfig(mode = "full") {
   return {
     mode,
-    limit: 50,
+    limit: CONVERSATION_HISTORY_DEFAULT_LIMIT,
     includeInternal: true,
     messageTypes: ["chat"],
-    maxOutputTokens: 4e3
+    maxOutputTokens: agentsCore.CONVERSATION_HISTORY_MAX_OUTPUT_TOKENS_DEFAULT
   };
 }
 function extractA2AMessageText(parts) {
@@ -253,7 +466,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 agentsCore.getConversationHistory(dbClient_default)({
     scopes: { tenantId, projectId },
     conversationId,
@@ -383,6 +596,7 @@ async function getConversationScopedArtifacts(params) {
 }
 var init_conversations = __esm({
   "src/data/conversations.ts"() {
+    init_execution_limits();
     init_dbClient();
   }
 });
@@ -438,10 +652,12 @@ var init_sandbox_utils = __esm({
 var logger16, ExecutionSemaphore, _NativeSandboxExecutor, NativeSandboxExecutor;
 var init_NativeSandboxExecutor = __esm({
   "src/tools/NativeSandboxExecutor.ts"() {
+    init_execution_limits();
+    init_logger();
     init_sandbox_utils();
     logger16 = agentsCore.getLogger("native-sandbox-executor");
     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");
@@ -496,9 +712,6 @@ var init_NativeSandboxExecutor = __esm({
       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 = path.join(os.tmpdir(), "inkeep-sandboxes");
         this.ensureTempDir();
@@ -547,7 +760,7 @@ var init_NativeSandboxExecutor = __esm({
         const sandbox = this.sandboxPool[poolKey];
         if (sandbox && fs.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++;
             logger16.debug(
@@ -593,7 +806,7 @@ var init_NativeSandboxExecutor = __esm({
           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);
             }
@@ -604,7 +817,7 @@ var init_NativeSandboxExecutor = __esm({
           if (keysToDelete.length > 0) {
             logger16.debug({ cleanedCount: keysToDelete.length }, "Cleaned up expired sandboxes");
           }
-        }, 6e4);
+        }, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS);
       }
       detectModuleType(executeCode, configuredRuntime) {
         const esmPatterns = [
@@ -714,7 +927,7 @@ var init_NativeSandboxExecutor = __esm({
           fs.writeFileSync(path.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
           );
@@ -779,13 +992,16 @@ var init_NativeSandboxExecutor = __esm({
           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;
@@ -793,9 +1009,13 @@ var init_NativeSandboxExecutor = __esm({
           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;
@@ -852,6 +1072,7 @@ var init_NativeSandboxExecutor = __esm({
 var logger17, _VercelSandboxExecutor, VercelSandboxExecutor;
 var init_VercelSandboxExecutor = __esm({
   "src/tools/VercelSandboxExecutor.ts"() {
+    init_execution_limits();
     init_logger();
     init_sandbox_utils();
     logger17 = agentsCore.getLogger("VercelSandboxExecutor");
@@ -859,9 +1080,6 @@ var init_VercelSandboxExecutor = __esm({
       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;
         logger17.info(
@@ -900,14 +1118,14 @@ var init_VercelSandboxExecutor = __esm({
         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) {
           logger17.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"
           );
@@ -970,32 +1188,28 @@ var init_VercelSandboxExecutor = __esm({
        * 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) {
-              logger17.info(
-                {
-                  count: toRemove.length,
-                  poolSize: this.sandboxPool.size
-                },
-                "Cleaning up expired sandboxes"
-              );
-              for (const hash of toRemove) {
-                this.removeSandbox(hash);
-              }
+          }
+          if (toRemove.length > 0) {
+            logger17.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
@@ -2552,14 +2766,13 @@ __publicField(_ModelFactory, "BUILT_IN_PROVIDERS", [
 var ModelFactory = _ModelFactory;
 
 // src/agents/ToolSessionManager.ts
+init_execution_limits();
 init_logger();
 var logger5 = agentsCore.getLogger("ToolSessionManager");
 var _ToolSessionManager = class _ToolSessionManager {
-  // 5 minutes
   constructor() {
     __publicField(this, "sessions", /* @__PURE__ */ new Map());
-    __publicField(this, "SESSION_TIMEOUT", 5 * 60 * 1e3);
-    setInterval(() => this.cleanupExpiredSessions(), 6e4);
+    setInterval(() => this.cleanupExpiredSessions(), SESSION_CLEANUP_INTERVAL_MS);
   }
   static getInstance() {
     if (!_ToolSessionManager.instance) {
@@ -2704,7 +2917,7 @@ var _ToolSessionManager = class _ToolSessionManager {
     const now = Date.now();
     const expiredSessions = [];
     for (const [sessionId, session] of this.sessions.entries()) {
-      if (now - session.createdAt > this.SESSION_TIMEOUT) {
+      if (now - session.createdAt > SESSION_TOOL_RESULT_CACHE_TIMEOUT_MS) {
         expiredSessions.push(sessionId);
       }
     }
@@ -2722,6 +2935,7 @@ var ToolSessionManager = _ToolSessionManager;
 var toolSessionManager = ToolSessionManager.getInstance();
 
 // src/services/AgentSession.ts
+init_execution_limits();
 init_conversations();
 init_dbClient();
 init_logger();
@@ -3889,8 +4103,8 @@ var AgentSession = class {
     // Track pending artifact processing
     __publicField(this, "artifactProcessingErrors", /* @__PURE__ */ new Map());
     // Track errors per artifact
-    __publicField(this, "MAX_ARTIFACT_RETRIES", 3);
-    __publicField(this, "MAX_PENDING_ARTIFACTS", 100);
+    __publicField(this, "MAX_ARTIFACT_RETRIES", ARTIFACT_GENERATION_MAX_RETRIES);
+    __publicField(this, "MAX_PENDING_ARTIFACTS", ARTIFACT_SESSION_MAX_PENDING);
     // Prevent unbounded growth
     __publicField(this, "scheduledTimeouts");
     // Track scheduled timeouts for cleanup
@@ -4010,8 +4224,8 @@ var AgentSession = class {
       summarizerModel,
       baseModel,
       config: {
-        numEvents: config.numEvents || 1,
-        timeInSeconds: config.timeInSeconds || 2,
+        numEvents: config.numEvents || STATUS_UPDATE_DEFAULT_NUM_EVENTS,
+        timeInSeconds: config.timeInSeconds || STATUS_UPDATE_DEFAULT_INTERVAL_SECONDS,
         ...config
       }
     };
@@ -4354,7 +4568,7 @@ var AgentSession = class {
         }
         return;
       }
-      if (this.previousSummaries.length > 3) {
+      if (this.previousSummaries.length > ARTIFACT_SESSION_MAX_PREVIOUS_SUMMARIES) {
         this.previousSummaries.shift();
       }
       if (this.statusUpdateState) {
@@ -4467,9 +4681,8 @@ var AgentSession = class {
                 projectId: this.projectId,
                 conversationId: this.sessionId,
                 options: {
-                  limit: 10,
-                  // Get recent conversation context
-                  maxOutputTokens: 2e3
+                  limit: agentsCore.CONVERSATION_HISTORY_DEFAULT_LIMIT,
+                  maxOutputTokens: agentsCore.CONVERSATION_HISTORY_MAX_OUTPUT_TOKENS_DEFAULT
                 },
                 filters: {}
               });
@@ -4488,12 +4701,12 @@ ${conversationHistory}
 Previous updates sent to user:
 ${previousSummaries.map((s, i) => `${i + 1}. ${s}`).join("\n")}
 ` : "";
-          const selectionSchema = z6.z.object(
+          const selectionSchema = z7.z.object(
             Object.fromEntries([
               [
                 "no_relevant_updates",
-                z6.z.object({
-                  no_updates: z6.z.boolean().default(true)
+                z7.z.object({
+                  no_updates: z7.z.boolean().default(true)
                 }).optional().describe(
                   "Use when nothing substantially new to report. Should only use on its own."
                 )
@@ -4625,8 +4838,8 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
     if (component.detailsSchema && "properties" in component.detailsSchema) {
       return this.buildZodSchemaFromJson(component.detailsSchema);
     }
-    return z6.z.object({
-      label: z6.z.string().describe(
+    return z7.z.object({
+      label: z7.z.string().describe(
         'A short 3-5 word phrase, that is a descriptive label for the update component. This Label must be EXTREMELY unique to represent the UNIQUE update we are providing. The ACTUAL finding or result, not the action. What specific information was discovered? (e.g., "Slack requires OAuth 2.0 setup", "Found 5 integration methods", "API rate limit is 100/minute"). Include the actual detail or insight, not just that you searched or processed. CRITICAL: Only use facts explicitly found in the activities - NEVER invent names, people, organizations, or details that are not present in the actual tool results.'
       )
     });
@@ -4636,56 +4849,56 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
    */
   buildZodSchemaFromJson(jsonSchema) {
     const properties = {};
-    properties.label = z6.z.string().describe(
+    properties.label = z7.z.string().describe(
       'A short 3-5 word phrase, that is a descriptive label for the update component. This Label must be EXTREMELY unique to represent the UNIQUE update we are providing. The SPECIFIC finding, result, or insight discovered (e.g., "Slack bot needs workspace admin role", "Found ingestion requires 3 steps", "Channel history limited to 10k messages"). State the ACTUAL information found, not that you searched. What did you LEARN or DISCOVER? What specific detail is now known? CRITICAL: Only use facts explicitly found in the activities - NEVER invent names, people, organizations, or details that are not present in the actual tool results.'
     );
     for (const [key, value] of Object.entries(jsonSchema.properties)) {
       let zodType;
       if (value.enum && Array.isArray(value.enum)) {
         if (value.enum.length === 1) {
-          zodType = z6.z.literal(value.enum[0]);
+          zodType = z7.z.literal(value.enum[0]);
         } else {
           const [first, ...rest] = value.enum;
-          zodType = z6.z.enum([first, ...rest]);
+          zodType = z7.z.enum([first, ...rest]);
         }
       } else if (value.type === "string") {
-        zodType = z6.z.string();
+        zodType = z7.z.string();
         if (value.minLength) zodType = zodType.min(value.minLength);
         if (value.maxLength) zodType = zodType.max(value.maxLength);
         if (value.format === "email") zodType = zodType.email();
         if (value.format === "url" || value.format === "uri")
           zodType = zodType.url();
       } else if (value.type === "number" || value.type === "integer") {
-        zodType = value.type === "integer" ? z6.z.number().int() : z6.z.number();
+        zodType = value.type === "integer" ? z7.z.number().int() : z7.z.number();
         if (value.minimum !== void 0) zodType = zodType.min(value.minimum);
         if (value.maximum !== void 0) zodType = zodType.max(value.maximum);
       } else if (value.type === "boolean") {
-        zodType = z6.z.boolean();
+        zodType = z7.z.boolean();
       } else if (value.type === "array") {
         if (value.items) {
           if (value.items.enum && Array.isArray(value.items.enum)) {
             const [first, ...rest] = value.items.enum;
-            zodType = z6.z.array(z6.z.enum([first, ...rest]));
+            zodType = z7.z.array(z7.z.enum([first, ...rest]));
           } else if (value.items.type === "string") {
-            zodType = z6.z.array(z6.z.string());
+            zodType = z7.z.array(z7.z.string());
           } else if (value.items.type === "number") {
-            zodType = z6.z.array(z6.z.number());
+            zodType = z7.z.array(z7.z.number());
           } else if (value.items.type === "boolean") {
-            zodType = z6.z.array(z6.z.boolean());
+            zodType = z7.z.array(z7.z.boolean());
           } else if (value.items.type === "object") {
-            zodType = z6.z.array(z6.z.record(z6.z.string(), z6.z.any()));
+            zodType = z7.z.array(z7.z.record(z7.z.string(), z7.z.any()));
           } else {
-            zodType = z6.z.array(z6.z.any());
+            zodType = z7.z.array(z7.z.any());
           }
         } else {
-          zodType = z6.z.array(z6.z.any());
+          zodType = z7.z.array(z7.z.any());
         }
         if (value.minItems) zodType = zodType.min(value.minItems);
         if (value.maxItems) zodType = zodType.max(value.maxItems);
       } else if (value.type === "object") {
-        zodType = z6.z.record(z6.z.string(), z6.z.any());
+        zodType = z7.z.record(z7.z.string(), z7.z.any());
       } else {
-        zodType = z6.z.any();
+        zodType = z7.z.any();
       }
       if (value.description) {
         zodType = zodType.describe(value.description);
@@ -4695,7 +4908,7 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
       }
       properties[key] = zodType;
     }
-    return z6.z.object(properties);
+    return z7.z.object(properties);
   }
   /**
    * Extract user-visible activities with rich formatting and complete information
@@ -4926,9 +5139,9 @@ Make it specific and relevant.`;
             };
           } else {
             const model = ModelFactory.createModel(modelToUse);
-            const schema = z6.z.object({
-              name: z6.z.string().describe("Concise, descriptive name for the artifact"),
-              description: z6.z.string().describe("Brief description of the artifact's relevance to the user's question")
+            const schema = z7.z.object({
+              name: z7.z.string().describe("Concise, descriptive name for the artifact"),
+              description: z7.z.string().describe("Brief description of the artifact's relevance to the user's question")
             });
             const { object } = await tracer.startActiveSpan(
               "agent_session.generate_artifact_metadata",
@@ -4998,7 +5211,10 @@ Make it specific and relevant.`;
                       `Artifact name/description generation failed, attempt ${attempt}/${maxRetries}`
                     );
                     if (attempt < maxRetries) {
-                      const backoffMs = Math.min(1e3 * 2 ** (attempt - 1), 1e4);
+                      const backoffMs = Math.min(
+                        ARTIFACT_GENERATION_BACKOFF_INITIAL_MS * 2 ** (attempt - 1),
+                        ARTIFACT_GENERATION_BACKOFF_MAX_MS
+                      );
                       await new Promise((resolve) => setTimeout(resolve, backoffMs));
                     }
                   }
@@ -5316,11 +5532,13 @@ async function resolveModelConfig(agentId, subAgent) {
 }
 
 // src/agents/Agent.ts
+init_execution_limits();
 init_conversations();
 init_dbClient();
 init_logger();
 
 // src/services/IncrementalStreamParser.ts
+init_execution_limits();
 init_logger();
 var logger10 = agentsCore.getLogger("IncrementalStreamParser");
 var _IncrementalStreamParser = class _IncrementalStreamParser {
@@ -5715,11 +5933,11 @@ ${chunk}`;
     }
   }
 };
-__publicField(_IncrementalStreamParser, "MAX_SNAPSHOT_SIZE", 100);
+__publicField(_IncrementalStreamParser, "MAX_SNAPSHOT_SIZE", STREAM_PARSER_MAX_SNAPSHOT_SIZE);
 // Max number of snapshots to keep
-__publicField(_IncrementalStreamParser, "MAX_STREAMED_SIZE", 1e3);
+__publicField(_IncrementalStreamParser, "MAX_STREAMED_SIZE", STREAM_PARSER_MAX_STREAMED_SIZE);
 // Max number of streamed component IDs to track
-__publicField(_IncrementalStreamParser, "MAX_COLLECTED_PARTS", 1e4);
+__publicField(_IncrementalStreamParser, "MAX_COLLECTED_PARTS", STREAM_PARSER_MAX_COLLECTED_PARTS);
 var IncrementalStreamParser = _IncrementalStreamParser;
 
 // src/services/ResponseFormatter.ts
@@ -5925,7 +6143,7 @@ var logger12 = agentsCore.getLogger("DataComponentSchema");
 function jsonSchemaToZod(jsonSchema) {
   if (!jsonSchema || typeof jsonSchema !== "object") {
     logger12.warn({ jsonSchema }, "Invalid JSON schema provided, using string fallback");
-    return z6.z.string();
+    return z7.z.string();
   }
   switch (jsonSchema.type) {
     case "object":
@@ -5934,22 +6152,22 @@ function jsonSchemaToZod(jsonSchema) {
         for (const [key, prop] of Object.entries(jsonSchema.properties)) {
           shape[key] = jsonSchemaToZod(prop);
         }
-        return z6.z.object(shape);
+        return z7.z.object(shape);
       }
-      return z6.z.record(z6.z.string(), z6.z.unknown());
+      return z7.z.record(z7.z.string(), z7.z.unknown());
     case "array": {
-      const itemSchema = jsonSchema.items ? jsonSchemaToZod(jsonSchema.items) : z6.z.unknown();
-      return z6.z.array(itemSchema);
+      const itemSchema = jsonSchema.items ? jsonSchemaToZod(jsonSchema.items) : z7.z.unknown();
+      return z7.z.array(itemSchema);
     }
     case "string":
-      return z6.z.string();
+      return z7.z.string();
     case "number":
     case "integer":
-      return z6.z.number();
+      return z7.z.number();
     case "boolean":
-      return z6.z.boolean();
+      return z7.z.boolean();
     case "null":
-      return z6.z.null();
+      return z7.z.null();
     default:
       logger12.warn(
         {
@@ -5958,7 +6176,7 @@ function jsonSchemaToZod(jsonSchema) {
         },
         "Unsupported JSON schema type, using unknown validation"
       );
-      return z6.z.unknown();
+      return z7.z.unknown();
   }
 }
 
@@ -6191,9 +6409,9 @@ var _ArtifactReferenceSchema = class _ArtifactReferenceSchema {
    * Get the standard Zod schema for artifact reference components
    */
   static getSchema() {
-    return z6.z.object({
-      id: z6.z.string(),
-      name: z6.z.literal("Artifact"),
+    return z7.z.object({
+      id: z7.z.string(),
+      name: z7.z.literal("Artifact"),
       props: jsonSchemaToZod(_ArtifactReferenceSchema.ARTIFACT_PROPS_SCHEMA)
     });
   }
@@ -6260,9 +6478,9 @@ var ArtifactCreateSchema = class {
         },
         required: ["id", "tool_call_id", "type", "base_selector"]
       };
-      return z6.z.object({
-        id: z6.z.string(),
-        name: z6.z.literal(`ArtifactCreate_${component.name}`),
+      return z7.z.object({
+        id: z7.z.string(),
+        name: z7.z.literal(`ArtifactCreate_${component.name}`),
         props: jsonSchemaToZod(propsSchema)
       });
     });
@@ -6934,10 +7152,12 @@ var A2AClient = class {
 };
 
 // src/agents/relationTools.ts
+init_execution_limits();
 init_conversations();
 init_dbClient();
 init_logger();
 var logger14 = agentsCore.getLogger("relationships Tools");
+var A2A_RETRY_STATUS_CODES = ["429", "500", "502", "503", "504"];
 var generateTransferToolDescription = (config) => {
   let toolsSection = "";
   let transferSection = "";
@@ -7038,7 +7258,7 @@ var createTransferToAgentTool = ({
   const toolDescription = generateTransferToolDescription(transferConfig);
   return ai.tool({
     description: toolDescription,
-    inputSchema: z6__default.default.object({}),
+    inputSchema: z7__default.default.object({}),
     execute: async () => {
       const activeSpan = api.trace.getActiveSpan();
       if (activeSpan) {
@@ -7093,7 +7313,7 @@ function createDelegateToAgentTool({
 }) {
   return ai.tool({
     description: generateDelegateToolDescription(delegateConfig),
-    inputSchema: z6__default.default.object({ message: z6__default.default.string() }),
+    inputSchema: z7__default.default.object({ message: z7__default.default.string() }),
     execute: async (input, context) => {
       const delegationId = `del_${agentsCore.generateId()}`;
       const activeSpan = api.trace.getActiveSpan();
@@ -7190,13 +7410,12 @@ function createDelegateToAgentTool({
         retryConfig: {
           strategy: "backoff",
           retryConnectionErrors: true,
-          statusCodes: ["429", "500", "502", "503", "504"],
+          statusCodes: [...A2A_RETRY_STATUS_CODES],
           backoff: {
-            initialInterval: 100,
-            maxInterval: 1e4,
-            exponent: 2,
-            maxElapsedTime: 2e4
-            // 1 minute max retry time
+            initialInterval: DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS,
+            maxInterval: DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS,
+            exponent: DELEGATION_TOOL_BACKOFF_EXPONENT,
+            maxElapsedTime: DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS
           }
         }
       });
@@ -8371,12 +8590,6 @@ function hasToolCallWithPrefix(prefix) {
   };
 }
 var logger19 = agentsCore.getLogger("Agent");
-var CONSTANTS = {
-  MAX_GENERATION_STEPS: 12,
-  PHASE_1_TIMEOUT_MS: 27e4,
-  NON_STREAMING_PHASE_1_TIMEOUT_MS: 9e4,
-  PHASE_2_TIMEOUT_MS: 9e4
-};
 function validateModel(modelString, modelType) {
   if (!modelString?.trim()) {
     throw new Error(
@@ -8445,10 +8658,10 @@ var Agent = class {
   }
   /**
    * Get the maximum number of generation steps for this agent
-   * Uses agent's stopWhen.stepCountIs config or defaults to CONSTANTS.MAX_GENERATION_STEPS
+   * Uses agent's stopWhen.stepCountIs config or defaults to AGENT_EXECUTION_MAX_GENERATION_STEPS
    */
   getMaxGenerationSteps() {
-    return this.config.stopWhen?.stepCountIs ?? CONSTANTS.MAX_GENERATION_STEPS;
+    return this.config.stopWhen?.stepCountIs ?? AGENT_EXECUTION_MAX_GENERATION_STEPS;
   }
   /**
    * Sanitizes tool names at runtime for AI SDK compatibility.
@@ -9004,8 +9217,8 @@ var Agent = class {
               const defaultSandboxConfig = {
                 provider: "native",
                 runtime: "node22",
-                timeout: 3e4,
-                vcpus: 4
+                timeout: FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT,
+                vcpus: FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT
               };
               const result = await sandboxExecutor.executeFunctionTool(functionToolDef.id, args, {
                 description: functionToolDef.description || functionToolDef.name,
@@ -9306,9 +9519,9 @@ var Agent = class {
   getArtifactTools() {
     return ai.tool({
       description: "Call this tool to get the complete artifact data with the given artifactId. This retrieves the full artifact content (not just the summary). Only use this when you need the complete artifact data and the summary shown in your context is insufficient.",
-      inputSchema: z6.z.object({
-        artifactId: z6.z.string().describe("The unique identifier of the artifact to get."),
-        toolCallId: z6.z.string().describe("The tool call ID associated with this artifact.")
+      inputSchema: z7.z.object({
+        artifactId: z7.z.string().describe("The unique identifier of the artifact to get."),
+        toolCallId: z7.z.string().describe("The tool call ID associated with this artifact.")
       }),
       execute: async ({ artifactId, toolCallId }) => {
         logger19.info({ artifactId, toolCallId }, "get_artifact_full executed");
@@ -9335,9 +9548,9 @@ var Agent = class {
   createThinkingCompleteTool() {
     return ai.tool({
       description: "\u{1F6A8} CRITICAL: Call this tool IMMEDIATELY when you have gathered enough information to answer the user. This is MANDATORY - you CANNOT provide text responses in thinking mode, only tool calls. Call thinking_complete as soon as you have sufficient data to generate a structured response.",
-      inputSchema: z6.z.object({
-        complete: z6.z.boolean().describe("ALWAYS set to true - marks end of research phase"),
-        summary: z6.z.string().describe(
+      inputSchema: z7.z.object({
+        complete: z7.z.boolean().describe("ALWAYS set to true - marks end of research phase"),
+        summary: z7.z.string().describe(
           "Brief summary of what information was gathered and why it is sufficient to answer the user"
         )
       }),
@@ -9694,15 +9907,14 @@ var Agent = class {
           let textResponse;
           const hasStructuredOutput = this.config.dataComponents && this.config.dataComponents.length > 0;
           const shouldStreamPhase1 = this.getStreamingHelper() && !hasStructuredOutput;
-          const MAX_ALLOWED_TIMEOUT_MS = 6e5;
-          const configuredTimeout = modelSettings.maxDuration ? Math.min(modelSettings.maxDuration * 1e3, MAX_ALLOWED_TIMEOUT_MS) : shouldStreamPhase1 ? CONSTANTS.PHASE_1_TIMEOUT_MS : CONSTANTS.NON_STREAMING_PHASE_1_TIMEOUT_MS;
-          const timeoutMs = Math.min(configuredTimeout, MAX_ALLOWED_TIMEOUT_MS);
-          if (modelSettings.maxDuration && modelSettings.maxDuration * 1e3 > MAX_ALLOWED_TIMEOUT_MS) {
+          const configuredTimeout = modelSettings.maxDuration ? Math.min(modelSettings.maxDuration * 1e3, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS) : shouldStreamPhase1 ? LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING : LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING;
+          const timeoutMs = Math.min(configuredTimeout, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS);
+          if (modelSettings.maxDuration && modelSettings.maxDuration * 1e3 > LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS) {
             logger19.warn(
               {
                 requestedTimeout: modelSettings.maxDuration * 1e3,
                 appliedTimeout: timeoutMs,
-                maxAllowed: MAX_ALLOWED_TIMEOUT_MS
+                maxAllowed: LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS
               },
               "Requested timeout exceeded maximum allowed, capping to 10 minutes"
             );
@@ -9978,9 +10190,9 @@ ${output}${structureHintsFormatted}`;
                 this.config.dataComponents.forEach((dc) => {
                   const propsSchema = jsonSchemaToZod(dc.props);
                   componentSchemas.push(
-                    z6.z.object({
-                      id: z6.z.string(),
-                      name: z6.z.literal(dc.name),
+                    z7.z.object({
+                      id: z7.z.string(),
+                      name: z7.z.literal(dc.name),
                       props: propsSchema
                     })
                   );
@@ -9997,14 +10209,32 @@ ${output}${structureHintsFormatted}`;
               if (componentSchemas.length === 1) {
                 dataComponentsSchema = componentSchemas[0];
               } else {
-                dataComponentsSchema = z6.z.union(
+                dataComponentsSchema = z7.z.union(
                   componentSchemas
                 );
               }
               const structuredModelSettings = ModelFactory.prepareGenerationConfig(
                 this.getStructuredOutputModel()
               );
-              const phase2TimeoutMs = structuredModelSettings.maxDuration ? structuredModelSettings.maxDuration * 1e3 : CONSTANTS.PHASE_2_TIMEOUT_MS;
+              const configuredPhase2Timeout = structuredModelSettings.maxDuration ? Math.min(
+                structuredModelSettings.maxDuration * 1e3,
+                LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS
+              ) : LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS;
+              const phase2TimeoutMs = Math.min(
+                configuredPhase2Timeout,
+                LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS
+              );
+              if (structuredModelSettings.maxDuration && structuredModelSettings.maxDuration * 1e3 > LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS) {
+                logger19.warn(
+                  {
+                    requestedTimeout: structuredModelSettings.maxDuration * 1e3,
+                    appliedTimeout: phase2TimeoutMs,
+                    maxAllowed: LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS,
+                    phase: "structured_generation"
+                  },
+                  "Phase 2 requested timeout exceeded maximum allowed, capping to 10 minutes"
+                );
+              }
               const shouldStreamPhase2 = this.getStreamingHelper();
               if (shouldStreamPhase2) {
                 const phase2Messages = [
@@ -10021,8 +10251,8 @@ ${output}${structureHintsFormatted}`;
                 const streamResult = ai.streamObject({
                   ...structuredModelSettings,
                   messages: phase2Messages,
-                  schema: z6.z.object({
-                    dataComponents: z6.z.array(dataComponentsSchema)
+                  schema: z7.z.object({
+                    dataComponents: z7.z.array(dataComponentsSchema)
                   }),
                   experimental_telemetry: {
                     isEnabled: true,
@@ -10092,8 +10322,8 @@ ${output}${structureHintsFormatted}`;
                   withJsonPostProcessing2({
                     ...structuredModelSettings,
                     messages: phase2Messages,
-                    schema: z6.z.object({
-                      dataComponents: z6.z.array(dataComponentsSchema)
+                    schema: z7.z.object({
+                      dataComponents: z7.z.array(dataComponentsSchema)
                     }),
                     experimental_telemetry: {
                       isEnabled: true,
@@ -10925,14 +11155,14 @@ app.openapi(
         description: "Agent Card for A2A discovery",
         content: {
           "application/json": {
-            schema: z6.z.object({
-              name: z6.z.string(),
-              description: z6.z.string().optional(),
-              url: z6.z.string(),
-              version: z6.z.string(),
-              defaultInputModes: z6.z.array(z6.z.string()),
-              defaultOutputModes: z6.z.array(z6.z.string()),
-              skills: z6.z.array(z6.z.any())
+            schema: z7.z.object({
+              name: z7.z.string(),
+              description: z7.z.string().optional(),
+              url: z7.z.string(),
+              version: z7.z.string(),
+              defaultInputModes: z7.z.array(z7.z.string()),
+              defaultOutputModes: z7.z.array(z7.z.string()),
+              skills: z7.z.array(z7.z.any())
             })
           }
         }
@@ -11179,8 +11409,12 @@ async function executeTransfer({
 }
 
 // src/handlers/executionHandler.ts
+init_execution_limits();
 init_dbClient();
 init_logger();
+
+// src/utils/stream-helpers.ts
+init_execution_limits();
 var SSEStreamHelper = class {
   constructor(stream2, requestId2, timestamp) {
     this.stream = stream2;
@@ -11353,7 +11587,6 @@ function createSSEStreamHelper(stream2, requestId2, timestamp) {
   return new SSEStreamHelper(stream2, requestId2, timestamp);
 }
 var _VercelDataStreamHelper = class _VercelDataStreamHelper {
-  // 10 minutes max lifetime
   constructor(writer) {
     this.writer = writer;
     __publicField(this, "textId", null);
@@ -11363,18 +11596,14 @@ var _VercelDataStreamHelper = class _VercelDataStreamHelper {
     __publicField(this, "completedItems", /* @__PURE__ */ new Set());
     // Track completed items
     __publicField(this, "sessionId");
-    // 5MB limit (more generous during request)
     __publicField(this, "isCompleted", false);
     __publicField(this, "isTextStreaming", false);
     __publicField(this, "queuedEvents", []);
     __publicField(this, "lastTextEndTimestamp", 0);
-    __publicField(this, "TEXT_GAP_THRESHOLD", 2e3);
-    // milliseconds - if gap between text sequences is less than this, queue operations
     __publicField(this, "connectionDropTimer");
-    __publicField(this, "MAX_LIFETIME_MS", 6e5);
     this.connectionDropTimer = setTimeout(() => {
       this.forceCleanup("Connection lifetime exceeded");
-    }, this.MAX_LIFETIME_MS);
+    }, STREAM_MAX_LIFETIME_MS);
   }
   setSessionId(sessionId) {
     this.sessionId = sessionId;
@@ -11428,7 +11657,7 @@ var _VercelDataStreamHelper = class _VercelDataStreamHelper {
     const id = this.textId;
     const startTime = Date.now();
     const gapFromLastSequence = this.lastTextEndTimestamp > 0 ? startTime - this.lastTextEndTimestamp : Number.MAX_SAFE_INTEGER;
-    if (gapFromLastSequence >= this.TEXT_GAP_THRESHOLD) {
+    if (gapFromLastSequence >= STREAM_TEXT_GAP_THRESHOLD_MS) {
       await this.flushQueuedOperations();
     }
     this.isTextStreaming = true;
@@ -11462,7 +11691,7 @@ var _VercelDataStreamHelper = class _VercelDataStreamHelper {
     if (type === "data-artifact") {
       const now = Date.now();
       const gapFromLastTextEnd = this.lastTextEndTimestamp > 0 ? now - this.lastTextEndTimestamp : Number.MAX_SAFE_INTEGER;
-      if (this.isTextStreaming || gapFromLastTextEnd < this.TEXT_GAP_THRESHOLD) {
+      if (this.isTextStreaming || gapFromLastTextEnd < STREAM_TEXT_GAP_THRESHOLD_MS) {
         this.writer.write({
           type: `${type}`,
           data
@@ -11615,7 +11844,7 @@ var _VercelDataStreamHelper = class _VercelDataStreamHelper {
     }
     const now = Date.now();
     const gapFromLastTextEnd = this.lastTextEndTimestamp > 0 ? now - this.lastTextEndTimestamp : Number.MAX_SAFE_INTEGER;
-    if (this.isTextStreaming || gapFromLastTextEnd < this.TEXT_GAP_THRESHOLD) {
+    if (this.isTextStreaming || gapFromLastTextEnd < STREAM_TEXT_GAP_THRESHOLD_MS) {
       this.queuedEvents.push({ type: "data-summary", event: summary });
       return;
     }
@@ -11633,7 +11862,7 @@ var _VercelDataStreamHelper = class _VercelDataStreamHelper {
     }
     const now = Date.now();
     const gapFromLastTextEnd = this.lastTextEndTimestamp > 0 ? now - this.lastTextEndTimestamp : Number.MAX_SAFE_INTEGER;
-    if (this.isTextStreaming || gapFromLastTextEnd < this.TEXT_GAP_THRESHOLD) {
+    if (this.isTextStreaming || gapFromLastTextEnd < STREAM_TEXT_GAP_THRESHOLD_MS) {
       this.queuedEvents.push({ type: "data-operation", event: operation });
       return;
     }
@@ -11676,7 +11905,7 @@ var _VercelDataStreamHelper = class _VercelDataStreamHelper {
     this.cleanup();
   }
 };
-__publicField(_VercelDataStreamHelper, "MAX_BUFFER_SIZE", 5 * 1024 * 1024);
+__publicField(_VercelDataStreamHelper, "MAX_BUFFER_SIZE", STREAM_BUFFER_MAX_SIZE_BYTES);
 var VercelDataStreamHelper = _VercelDataStreamHelper;
 function createVercelStreamHelper(writer) {
   return new VercelDataStreamHelper(writer);
@@ -11748,7 +11977,7 @@ var createMCPStreamHelper = createBufferingStreamHelper;
 var logger24 = agentsCore.getLogger("ExecutionHandler");
 var ExecutionHandler = class {
   constructor() {
-    __publicField(this, "MAX_ERRORS", 3);
+    __publicField(this, "MAX_ERRORS", AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS);
   }
   /**
    * performs exeuction loop
@@ -11882,7 +12111,7 @@ var ExecutionHandler = class {
       );
       if (Array.isArray(task)) task = task[0];
       let currentMessage = userMessage;
-      const maxTransfers = agentConfig?.stopWhen?.transferCountIs ?? 10;
+      const maxTransfers = agentConfig?.stopWhen?.transferCountIs ?? agentsCore.AGENT_EXECUTION_TRANSFER_COUNT_DEFAULT;
       while (iterations < maxTransfers) {
         iterations++;
         logger24.info(
@@ -12204,36 +12433,36 @@ var chatCompletionsRoute = zodOpenapi.createRoute({
     body: {
       content: {
         "application/json": {
-          schema: z6.z.object({
-            model: z6.z.string().describe("The model to use for the completion"),
-            messages: z6.z.array(
-              z6.z.object({
-                role: z6.z.enum(["system", "user", "assistant", "function", "tool"]).describe("The role of the message"),
-                content: z6.z.union([
-                  z6.z.string(),
-                  z6.z.array(
-                    z6.z.strictObject({
-                      type: z6.z.string(),
-                      text: z6.z.string().optional()
+          schema: z7.z.object({
+            model: z7.z.string().describe("The model to use for the completion"),
+            messages: z7.z.array(
+              z7.z.object({
+                role: z7.z.enum(["system", "user", "assistant", "function", "tool"]).describe("The role of the message"),
+                content: z7.z.union([
+                  z7.z.string(),
+                  z7.z.array(
+                    z7.z.strictObject({
+                      type: z7.z.string(),
+                      text: z7.z.string().optional()
                     })
                   )
                 ]).describe("The message content"),
-                name: z6.z.string().optional().describe("The name of the message sender")
+                name: z7.z.string().optional().describe("The name of the message sender")
               })
             ).describe("The conversation messages"),
-            temperature: z6.z.number().optional().describe("Controls randomness (0-1)"),
-            top_p: z6.z.number().optional().describe("Controls nucleus sampling"),
-            n: z6.z.number().optional().describe("Number of completions to generate"),
-            stream: z6.z.boolean().optional().describe("Whether to stream the response"),
-            max_tokens: z6.z.number().optional().describe("Maximum tokens to generate"),
-            presence_penalty: z6.z.number().optional().describe("Presence penalty (-2 to 2)"),
-            frequency_penalty: z6.z.number().optional().describe("Frequency penalty (-2 to 2)"),
-            logit_bias: z6.z.record(z6.z.string(), z6.z.number()).optional().describe("Token logit bias"),
-            user: z6.z.string().optional().describe("User identifier"),
-            conversationId: z6.z.string().optional().describe("Conversation ID for multi-turn chat"),
-            tools: z6.z.array(z6.z.string()).optional().describe("Available tools"),
-            runConfig: z6.z.record(z6.z.string(), z6.z.unknown()).optional().describe("Run configuration"),
-            headers: z6.z.record(z6.z.string(), z6.z.unknown()).optional().describe(
+            temperature: z7.z.number().optional().describe("Controls randomness (0-1)"),
+            top_p: z7.z.number().optional().describe("Controls nucleus sampling"),
+            n: z7.z.number().optional().describe("Number of completions to generate"),
+            stream: z7.z.boolean().optional().describe("Whether to stream the response"),
+            max_tokens: z7.z.number().optional().describe("Maximum tokens to generate"),
+            presence_penalty: z7.z.number().optional().describe("Presence penalty (-2 to 2)"),
+            frequency_penalty: z7.z.number().optional().describe("Frequency penalty (-2 to 2)"),
+            logit_bias: z7.z.record(z7.z.string(), z7.z.number()).optional().describe("Token logit bias"),
+            user: z7.z.string().optional().describe("User identifier"),
+            conversationId: z7.z.string().optional().describe("Conversation ID for multi-turn chat"),
+            tools: z7.z.array(z7.z.string()).optional().describe("Available tools"),
+            runConfig: z7.z.record(z7.z.string(), z7.z.unknown()).optional().describe("Run configuration"),
+            headers: z7.z.record(z7.z.string(), z7.z.unknown()).optional().describe(
               "Headers data for template processing (validated against context config schema)"
             )
           })
@@ -12244,14 +12473,14 @@ var chatCompletionsRoute = zodOpenapi.createRoute({
   responses: {
     200: {
       description: "Streaming chat completion response in Server-Sent Events format",
-      headers: z6.z.object({
-        "Content-Type": z6.z.string().default("text/event-stream"),
-        "Cache-Control": z6.z.string().default("no-cache"),
-        Connection: z6.z.string().default("keep-alive")
+      headers: z7.z.object({
+        "Content-Type": z7.z.string().default("text/event-stream"),
+        "Cache-Control": z7.z.string().default("no-cache"),
+        Connection: z7.z.string().default("keep-alive")
       }),
       content: {
         "text/event-stream": {
-          schema: z6.z.string().describe("Server-Sent Events stream with chat completion chunks")
+          schema: z7.z.string().describe("Server-Sent Events stream with chat completion chunks")
         }
       }
     },
@@ -12259,13 +12488,13 @@ var chatCompletionsRoute = zodOpenapi.createRoute({
       description: "Invalid request context or parameters",
       content: {
         "application/json": {
-          schema: z6.z.object({
-            error: z6.z.string(),
-            details: z6.z.array(
-              z6.z.object({
-                field: z6.z.string(),
-                message: z6.z.string(),
-                value: z6.z.unknown().optional()
+          schema: z7.z.object({
+            error: z7.z.string(),
+            details: z7.z.array(
+              z7.z.object({
+                field: z7.z.string(),
+                message: z7.z.string(),
+                value: z7.z.unknown().optional()
               })
             ).optional()
           })
@@ -12276,8 +12505,8 @@ var chatCompletionsRoute = zodOpenapi.createRoute({
       description: "Agent or agent not found",
       content: {
         "application/json": {
-          schema: z6.z.object({
-            error: z6.z.string()
+          schema: z7.z.object({
+            error: z7.z.string()
           })
         }
       }
@@ -12286,9 +12515,9 @@ var chatCompletionsRoute = zodOpenapi.createRoute({
       description: "Internal server error",
       content: {
         "application/json": {
-          schema: z6.z.object({
-            error: z6.z.string(),
-            message: z6.z.string()
+          schema: z7.z.object({
+            error: z7.z.string(),
+            message: z7.z.string()
           })
         }
       }
@@ -13000,7 +13229,7 @@ var getServer = async (headers2, executionContext, conversationId, credentialSto
     "send-query-to-agent",
     `Send a query to the ${agent.name} agent. The agent has the following description: ${agent.description}`,
     {
-      query: z6.z.string().describe("The query to send to the agent")
+      query: z7.z.string().describe("The query to send to the agent")
     },
     async ({ query }) => {
       try {