@inkeep/agents-run-api 0.0.0-dev-20251108014948 → 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();
@@ -2982,7 +3196,16 @@ var _ArtifactService = class _ArtifactService {
         );
         return null;
       }
-      const artifacts = await agentsCore.getLedgerArtifacts(dbClient_default)({
+      let artifacts = [];
+      artifacts = await agentsCore.getLedgerArtifacts(dbClient_default)({
+        scopes: { tenantId: this.context.tenantId, projectId: this.context.projectId },
+        artifactId,
+        toolCallId
+      });
+      if (artifacts.length > 0) {
+        return this.formatArtifactSummaryData(artifacts[0], artifactId, toolCallId);
+      }
+      artifacts = await agentsCore.getLedgerArtifacts(dbClient_default)({
         scopes: { tenantId: this.context.tenantId, projectId: this.context.projectId },
         artifactId,
         taskId: this.context.taskId
@@ -3028,7 +3251,16 @@ var _ArtifactService = class _ArtifactService {
         );
         return null;
       }
-      const artifacts = await agentsCore.getLedgerArtifacts(dbClient_default)({
+      let artifacts = [];
+      artifacts = await agentsCore.getLedgerArtifacts(dbClient_default)({
+        scopes: { tenantId: this.context.tenantId, projectId: this.context.projectId },
+        artifactId,
+        toolCallId
+      });
+      if (artifacts.length > 0) {
+        return this.formatArtifactFullData(artifacts[0], artifactId, toolCallId);
+      }
+      artifacts = await agentsCore.getLedgerArtifacts(dbClient_default)({
         scopes: { tenantId: this.context.tenantId, projectId: this.context.projectId },
         artifactId,
         taskId: this.context.taskId
@@ -3871,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
@@ -3992,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
       }
     };
@@ -4336,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) {
@@ -4449,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: {}
               });
@@ -4470,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."
                 )
@@ -4607,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.'
       )
     });
@@ -4618,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);
@@ -4677,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
@@ -4908,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",
@@ -4980,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));
                     }
                   }
@@ -4996,15 +5230,8 @@ Make it specific and relevant.`;
             );
             result = object;
           }
-          const artifactService = new ArtifactService({
-            tenantId: artifactData.tenantId,
-            projectId: artifactData.projectId,
-            contextId: artifactData.contextId,
-            taskId: artifactData.taskId,
-            sessionId: this.sessionId
-          });
           try {
-            await artifactService.saveArtifact({
+            await this.artifactService.saveArtifact({
               artifactId: artifactData.artifactId,
               name: result.name,
               description: result.description,
@@ -5033,14 +5260,14 @@ Make it specific and relevant.`;
           if (!mainSaveSucceeded) {
             try {
               if (artifactData.tenantId && artifactData.projectId) {
-                const artifactService2 = new ArtifactService({
+                const artifactService = new ArtifactService({
                   tenantId: artifactData.tenantId,
                   projectId: artifactData.projectId,
                   contextId: artifactData.contextId || "unknown",
                   taskId: artifactData.taskId,
                   sessionId: this.sessionId
                 });
-                await artifactService2.saveArtifact({
+                await artifactService.saveArtifact({
                   artifactId: artifactData.artifactId,
                   name: `Artifact ${artifactData.artifactId.substring(0, 8)}`,
                   description: `${artifactData.artifactType || "Data"} from ${artifactData.metadata?.toolName || "tool results"}`,
@@ -5305,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 {
@@ -5704,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
@@ -5914,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":
@@ -5923,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(
         {
@@ -5947,7 +6176,7 @@ function jsonSchemaToZod(jsonSchema) {
         },
         "Unsupported JSON schema type, using unknown validation"
       );
-      return z6.z.unknown();
+      return z7.z.unknown();
   }
 }
 
@@ -6180,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)
     });
   }
@@ -6249,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)
       });
     });
@@ -6923,29 +7152,102 @@ 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) => {
-  return `Hand off the conversation to agent ${config.id}.
+  let toolsSection = "";
+  let transferSection = "";
+  if (config.transferRelations && config.transferRelations.length > 0) {
+    const transferList = config.transferRelations.map(
+      (transfer) => `  - ${transfer.name || transfer.id}: ${transfer.description || "No description available"}`
+    ).join("\n");
+    transferSection = `
+
+Can Transfer To:
+${transferList}`;
+  }
+  let delegateSection = "";
+  if (config.delegateRelations && config.delegateRelations.length > 0) {
+    const delegateList = config.delegateRelations.map(
+      (delegate) => `  - ${delegate.config.name || delegate.config.id}: ${delegate.config.description || "No description available"} (${delegate.type})`
+    ).join("\n");
+    delegateSection = `
+
+Can Delegate To:
+${delegateList}`;
+  }
+  if (config.tools && config.tools.length > 0) {
+    const toolDescriptions = config.tools.map((tool3) => {
+      const toolsList = tool3.availableTools?.map((t) => `  - ${t.name}: ${t.description || "No description available"}`).join("\n") || "";
+      return `MCP Server: ${tool3.name}
+${toolsList}`;
+    }).join("\n\n");
+    toolsSection = `
+
+Available Tools & Capabilities:
+${toolDescriptions}`;
+  }
+  const finalDescription = `Hand off the conversation to agent ${config.id}.
 
 Agent Information:
 - ID: ${config.id}
 - Name: ${config.name ?? "No name provided"}
-- Description: ${config.description ?? "No description provided"}
+- Description: ${config.description ?? "No description provided"}${toolsSection}${transferSection}${delegateSection}
 
 Hand off the conversation to agent ${config.id} when the user's request would be better handled by this specialized agent.`;
+  return finalDescription;
 };
-var generateDelegateToolDescription = (config) => {
-  return `Delegate a specific task to another agent.
+var generateDelegateToolDescription = (delegateRelation) => {
+  const config = delegateRelation.config;
+  let toolsSection = "";
+  let transferSection = "";
+  let delegateSection = "";
+  if (delegateRelation.type === "internal" && "tools" in config) {
+    const agentConfig = config;
+    if (agentConfig.tools && agentConfig.tools.length > 0) {
+      const toolDescriptions = agentConfig.tools.map((tool3) => {
+        const toolsList = tool3.availableTools?.map((t) => `  - ${t.name}: ${t.description || "No description available"}`).join("\n") || "";
+        return `MCP Server: ${tool3.name}
+${toolsList}`;
+      }).join("\n\n");
+      toolsSection = `
+
+Available Tools & Capabilities:
+${toolDescriptions}`;
+    }
+    if (agentConfig.transferRelations && agentConfig.transferRelations.length > 0) {
+      const transferList = agentConfig.transferRelations.map(
+        (transfer) => `  - ${transfer.name || transfer.id}: ${transfer.description || "No description available"}`
+      ).join("\n");
+      transferSection = `
+
+Can Transfer To:
+${transferList}`;
+    }
+    if (agentConfig.delegateRelations && agentConfig.delegateRelations.length > 0) {
+      const delegateList = agentConfig.delegateRelations.map(
+        (delegate) => `  - ${delegate.config.name || delegate.config.id}: ${delegate.config.description || "No description available"} (${delegate.type})`
+      ).join("\n");
+      delegateSection = `
+
+Can Delegate To:
+${delegateList}`;
+    }
+  }
+  const finalDescription = `Delegate a specific task to another agent.
 
 Agent Information:
 - ID: ${config.id}
 - Name: ${config.name}
 - Description: ${config.description || "No description provided"}
+- Type: ${delegateRelation.type}${toolsSection}${transferSection}${delegateSection}
 
 Delegate a specific task to agent ${config.id} when it seems like the agent can do relevant work.`;
+  return finalDescription;
 };
 var createTransferToAgentTool = ({
   transferConfig,
@@ -6953,9 +7255,10 @@ var createTransferToAgentTool = ({
   subAgent,
   streamRequestId
 }) => {
+  const toolDescription = generateTransferToolDescription(transferConfig);
   return ai.tool({
-    description: generateTransferToolDescription(transferConfig),
-    inputSchema: z6__default.default.object({}),
+    description: toolDescription,
+    inputSchema: z7__default.default.object({}),
     execute: async () => {
       const activeSpan = api.trace.getActiveSpan();
       if (activeSpan) {
@@ -7009,8 +7312,8 @@ function createDelegateToAgentTool({
   credentialStoreRegistry
 }) {
   return ai.tool({
-    description: generateDelegateToolDescription(delegateConfig.config),
-    inputSchema: z6__default.default.object({ message: z6__default.default.string() }),
+    description: generateDelegateToolDescription(delegateConfig),
+    inputSchema: z7__default.default.object({ message: z7__default.default.string() }),
     execute: async (input, context) => {
       const delegationId = `del_${agentsCore.generateId()}`;
       const activeSpan = api.trace.getActiveSpan();
@@ -7107,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
           }
         }
       });
@@ -7266,7 +7568,7 @@ var system_prompt_default = `<system_message>
       - You ARE the user's assistant - there are no other agents, specialists, or experts
       - NEVER say you are connecting them to anyone or anything
       - Continue conversations as if you personally have been handling them the entire time
-      - Answer questions directly without any transition phrases or transfer language
+      - Answer questions directly without any transition phrases or transfer language except when transferring to another agent or delegating to another agent
       {{TRANSFER_INSTRUCTIONS}}
       {{DELEGATION_INSTRUCTIONS}}
     </security>
@@ -7274,7 +7576,7 @@ var system_prompt_default = `<system_message>
     <interaction_guidelines>
       - Be helpful, accurate, and professional
       - Use tools when appropriate to provide better assistance
-      - Explain your reasoning when using tools
+      - Use tools directly without announcing or explaining what you're doing ("Let me search...", "I'll look for...", etc.)
       - Save important tool results as artifacts when they contain structured data that should be preserved and referenced
       - Ask for clarification when requests are ambiguous
       
@@ -7292,11 +7594,6 @@ var system_prompt_default = `<system_message>
       - NEVER mention delegation occurred: just present the results
       - If delegation returns artifacts, reference them as if you created them
       
-      \u{1F6A8} TRANSFER TOOL RULES - CRITICAL:
-      - When calling transfer_to_* tools, call the tool IMMEDIATELY without any explanatory text
-      - Do NOT explain the transfer, do NOT say "I'll hand this off", do NOT provide reasoning
-      - Just call the transfer tool directly when you determine it's needed
-      - The tool call is sufficient - no additional text should be generated
     </interaction_guidelines>
     
     {{THINKING_PREPARATION_INSTRUCTIONS}}
@@ -7515,9 +7812,24 @@ var Phase1Config = class _Phase1Config {
     if (!hasTransferRelations) {
       return "";
     }
-    return `- You have transfer_to_* tools that seamlessly continue the conversation
-- NEVER announce transfers - just call the tool when needed
-- The conversation continues naturally without any transfer language`;
+    return `You are part of a single unified assistant composed of specialized agents. To the user, you must always appear as one continuous, confident voice.
+
+You have transfer_to_* tools that seamlessly continue the conversation. When you determine another agent should handle a request: ONLY call the appropriate transfer_to_* tool. Do not provide any substantive answer, limitation, or explanation before transferring. NEVER announce, describe, or apologize for a transfer.
+
+Do NOT stream any text when transferring - call the transfer tool IMMEDIATELY. Do NOT acknowledge the request, do NOT say "Looking into that...", "Let me search...", "I'll help you find...", or provide ANY explanatory text. Place all reasoning or handoff details inside the transfer tool call, not in the user message. The tool call is sufficient - no additional text should be generated.
+
+CRITICAL: When you receive a user message that ends with "Please continue from where this conversation was left off" - this indicates you are continuing a conversation that another agent started. You should:
+- Review the conversation history to see what was already communicated to the user
+- Continue seamlessly from where the previous response left off
+- Do NOT repeat what was already said in the conversation history
+- Do NOT announce what you're about to do ("Let me search...", "I'll look for...", etc.)
+- Proceed directly with the appropriate tool or action
+- Act as if you have been handling the conversation from the beginning
+
+When receiving any transfer, act as if you have been engaged from the start. Continue the same tone, context, and style. Never reference other agents, tools, or roles.
+
+Your goal: preserve the illusion of a single, seamless, intelligent assistant. All user-facing behavior must feel like one continuous conversation, regardless of internal transfers.
+`;
   }
   generateDelegationInstructions(hasDelegateRelations) {
     if (!hasDelegateRelations) {
@@ -8278,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(
@@ -8352,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.
@@ -8911,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,
@@ -9213,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");
@@ -9242,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"
         )
       }),
@@ -9517,6 +9823,9 @@ var Agent = class {
         try {
           this.streamRequestId = streamRequestId;
           this.streamHelper = streamRequestId ? getStreamHelper(streamRequestId) : void 0;
+          if (streamRequestId && this.artifactComponents.length > 0) {
+            agentSessionManager.updateArtifactComponents(streamRequestId, this.artifactComponents);
+          }
           const conversationId = runtimeContext?.metadata?.conversationId;
           if (conversationId) {
             this.setConversationId(conversationId);
@@ -9598,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"
             );
@@ -9882,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
                     })
                   );
@@ -9901,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 = [
@@ -9925,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,
@@ -9996,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,
@@ -10264,9 +10590,14 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
       const models = "models" in config.agentSchema ? config.agentSchema.models : void 0;
       const stopWhen = "stopWhen" in config.agentSchema ? config.agentSchema.stopWhen : void 0;
       const toolsForAgentResult = await Promise.all(
-        toolsForAgent.data.map(
-          async (item) => await agentsCore.dbResultToMcpTool(item.tool, dbClient_default, credentialStoreRegistry)
-        )
+        toolsForAgent.data.map(async (item) => {
+          const mcpTool = await agentsCore.dbResultToMcpTool(item.tool, dbClient_default, credentialStoreRegistry);
+          if (item.selectedTools && item.selectedTools.length > 0) {
+            const selectedToolsSet = new Set(item.selectedTools);
+            mcpTool.availableTools = mcpTool.availableTools?.filter((tool3) => selectedToolsSet.has(tool3.name)) || [];
+          }
+          return mcpTool;
+        })
       ) ?? [];
       const agent = new Agent(
         {
@@ -10295,20 +10626,112 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
             subAgentRelations: [],
             transferRelations: []
           })),
-          transferRelations: enhancedInternalRelations.filter((relation) => relation.relationType === "transfer").map((relation) => ({
-            baseUrl: config.baseUrl,
-            apiKey: config.apiKey,
-            id: relation.id,
-            tenantId: config.tenantId,
-            projectId: config.projectId,
-            agentId: config.agentId,
-            name: relation.name,
-            description: relation.description,
-            prompt: "",
-            delegateRelations: [],
-            subAgentRelations: [],
-            transferRelations: []
-          })),
+          transferRelations: await Promise.all(
+            enhancedInternalRelations.filter((relation) => relation.relationType === "transfer").map(async (relation) => {
+              const targetToolsForAgent = await agentsCore.getToolsForAgent(dbClient_default)({
+                scopes: {
+                  tenantId: config.tenantId,
+                  projectId: config.projectId,
+                  agentId: config.agentId,
+                  subAgentId: relation.id
+                }
+              });
+              let targetTransferRelations = { data: [] };
+              let targetDelegateRelations = { data: [] };
+              try {
+                const [transferRel, delegateRel] = await Promise.all([
+                  agentsCore.getRelatedAgentsForAgent(dbClient_default)({
+                    scopes: {
+                      tenantId: config.tenantId,
+                      projectId: config.projectId,
+                      agentId: config.agentId
+                    },
+                    subAgentId: relation.id
+                  }),
+                  agentsCore.getExternalAgentsForSubAgent(dbClient_default)({
+                    scopes: {
+                      tenantId: config.tenantId,
+                      projectId: config.projectId,
+                      agentId: config.agentId,
+                      subAgentId: relation.id
+                    }
+                  })
+                ]);
+                targetTransferRelations = transferRel;
+                targetDelegateRelations = delegateRel;
+              } catch (err) {
+                logger20.info(
+                  {
+                    agentId: relation.id,
+                    error: err?.message || "Unknown error"
+                  },
+                  "Could not fetch relations for target agent (likely external/team agent), using basic info only"
+                );
+              }
+              const targetAgentTools = await Promise.all(
+                targetToolsForAgent.data.map(async (item) => {
+                  const mcpTool = await agentsCore.dbResultToMcpTool(
+                    item.tool,
+                    dbClient_default,
+                    credentialStoreRegistry
+                  );
+                  if (item.selectedTools && item.selectedTools.length > 0) {
+                    const selectedToolsSet = new Set(item.selectedTools);
+                    mcpTool.availableTools = mcpTool.availableTools?.filter(
+                      (tool3) => selectedToolsSet.has(tool3.name)
+                    ) || [];
+                  }
+                  return mcpTool;
+                })
+              ) ?? [];
+              const targetTransferRelationsConfig = targetTransferRelations.data.filter((rel) => rel.relationType === "transfer").map((rel) => ({
+                baseUrl: config.baseUrl,
+                apiKey: config.apiKey,
+                id: rel.id,
+                tenantId: config.tenantId,
+                projectId: config.projectId,
+                agentId: config.agentId,
+                name: rel.name,
+                description: rel.description,
+                prompt: "",
+                delegateRelations: [],
+                subAgentRelations: [],
+                transferRelations: []
+                // Note: Not including tools for nested relations to avoid infinite recursion
+              }));
+              const targetDelegateRelationsConfig = targetDelegateRelations.data.map(
+                (rel) => ({
+                  type: "external",
+                  config: {
+                    id: rel.externalAgent.id,
+                    name: rel.externalAgent.name,
+                    description: rel.externalAgent.description || "",
+                    baseUrl: rel.externalAgent.baseUrl,
+                    headers: rel.headers,
+                    credentialReferenceId: rel.externalAgent.credentialReferenceId,
+                    relationId: rel.id,
+                    relationType: "delegate"
+                  }
+                })
+              );
+              return {
+                baseUrl: config.baseUrl,
+                apiKey: config.apiKey,
+                id: relation.id,
+                tenantId: config.tenantId,
+                projectId: config.projectId,
+                agentId: config.agentId,
+                name: relation.name,
+                description: relation.description,
+                prompt: "",
+                delegateRelations: targetDelegateRelationsConfig,
+                subAgentRelations: [],
+                transferRelations: targetTransferRelationsConfig,
+                tools: targetAgentTools
+                // Include target agent's tools for transfer descriptions
+              };
+            })
+          ),
           delegateRelations: [
             ...enhancedInternalRelations.filter((relation) => relation.relationType === "delegate").map((relation) => ({
               type: "internal",
@@ -10323,8 +10746,11 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
                 description: relation.description,
                 prompt: "",
                 delegateRelations: [],
+                // Simplified - no nested relations
                 subAgentRelations: [],
-                transferRelations: []
+                transferRelations: [],
+                tools: []
+                // Tools are defined in config files, not DB
               }
             })),
             ...externalRelations.data.map((relation) => ({
@@ -10729,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())
             })
           }
         }
@@ -10983,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;
@@ -11157,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);
@@ -11167,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;
@@ -11232,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;
@@ -11266,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
@@ -11419,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;
     }
@@ -11437,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;
     }
@@ -11480,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);
@@ -11552,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
@@ -11686,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(
@@ -11781,7 +12206,27 @@ var ExecutionHandler = class {
           const firstArtifact = messageResponse.result.artifacts[0];
           const transferReason = firstArtifact?.parts[1]?.kind === "text" ? firstArtifact.parts[1].text : "Transfer initiated";
           logger24.info({ targetSubAgentId, transferReason, transferFromAgent }, "Transfer response");
-          currentMessage = `<transfer_context> ${transferReason} </transfer_context>`;
+          await agentsCore.createMessage(dbClient_default)({
+            id: agentsCore.generateId(),
+            tenantId,
+            projectId,
+            conversationId,
+            role: "agent",
+            content: {
+              text: transferReason,
+              parts: [
+                {
+                  kind: "text",
+                  text: transferReason
+                }
+              ]
+            },
+            visibility: "user-facing",
+            messageType: "chat",
+            fromSubAgentId: currentAgentId,
+            taskId: task.id
+          });
+          currentMessage = currentMessage + "\n\nPlease continue this conversation seamlessly. The previous response in conversation history was from another internal agent, but you must continue as if YOU made that response. All responses must appear as one unified agent - do not repeat what was already communicated.";
           const { success, targetSubAgentId: newAgentId } = await executeTransfer({
             projectId,
             tenantId,
@@ -11988,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)"
             )
           })
@@ -12028,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")
         }
       }
     },
@@ -12043,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()
           })
@@ -12060,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()
           })
         }
       }
@@ -12070,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()
           })
         }
       }
@@ -12784,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 {