@inkeep/agents-core 0.37.0 → 0.37.1

package/dist/{chunk-ICZLNCX7.js → chunk-ROXPFQAM.js}

@@ -1,10 +1,11 @@
-import { loadEnvironmentFiles, env } from './chunk-Q5U2SVA6.js';
+import { loadEnvironmentFiles, env } from './chunk-LL6F3EAR.js';
 import { getLogger } from './chunk-DN4B564Y.js';
 import { CredentialStoreType, MCPTransportType } from './chunk-YFHT5M2R.js';
-import { external_exports } from './chunk-OUXC23J7.js';
+import { z } from 'zod';
 import { customAlphabet } from 'nanoid';
 import { scrypt, randomBytes, timingSafeEqual } from 'crypto';
 import { promisify } from 'util';
+import { z as z$1 } from '@hono/zod-openapi';
 import { HTTPException } from 'hono/http-exception';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
@@ -14,6 +15,12 @@ import { CallToolResultSchema } from '@modelcontextprotocol/sdk/types.js';
 import { tool } from 'ai';
 import { asyncExitHook, gracefulExit } from 'exit-hook';
 import { match } from 'ts-pattern';
+import { createAnthropic, anthropic } from '@ai-sdk/anthropic';
+import { createGateway, gateway } from '@ai-sdk/gateway';
+import { createGoogleGenerativeAI, google } from '@ai-sdk/google';
+import { createOpenAI, openai } from '@ai-sdk/openai';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { createOpenRouter, openrouter } from '@openrouter/ai-sdk-provider';
 import * as jose from 'jose';
 import { SignJWT, jwtVerify } from 'jose';
 import { Composio } from '@composio/core';
@@ -47,14 +54,12 @@ var executionLimitsSharedDefaults = {
   // Increased from 4,000 to 8,000 to accommodate tool results in conversation history.
   CONVERSATION_HISTORY_MAX_OUTPUT_TOKENS_DEFAULT: 8e3
 };
-
-// src/constants/execution-limits-shared/index.ts
 loadEnvironmentFiles();
-var constantsSchema = external_exports.object(
+var constantsSchema = z.object(
   Object.fromEntries(
     Object.keys(executionLimitsSharedDefaults).map((key) => [
       `AGENTS_${key}`,
-      external_exports.coerce.number().optional()
+      z.coerce.number().optional()
     ])
   )
 );
@@ -179,11 +184,18 @@ function normalizeDateString(dateString) {
   }
   const pgTimestampPattern = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(\.\d{1,3})?$/;
   if (pgTimestampPattern.test(dateString)) {
-    return dateString.replace(" ", "T") + "Z";
+    return `${dateString.replace(" ", "T")}Z`;
   }
   return dateString;
 }
-var ErrorCode = external_exports.enum([
+function toISODateString(dateValue) {
+  if (typeof dateValue === "string") {
+    const normalized = normalizeDateString(dateValue);
+    return typeof normalized === "string" ? normalized : normalized.toISOString();
+  }
+  return dateValue.toISOString();
+}
+var ErrorCode = z$1.enum([
   "bad_request",
   "unauthorized",
   "forbidden",
@@ -202,28 +214,28 @@ var errorCodeToHttpStatus = {
   internal_server_error: 500
 };
 var ERROR_DOCS_BASE_URL = "https://docs.inkeep.com/agents-api/errors";
-var problemDetailsSchema = external_exports.object({
+var problemDetailsSchema = z$1.object({
   // type: z.string().url().openapi({
   //   description: "A URI reference that identifies the problem type.",
   //   example: `${ERROR_DOCS_BASE_URL}#not-found`,
   // }),
-  title: external_exports.string().openapi({
+  title: z$1.string().openapi({
     description: "A short, human-readable summary of the problem type.",
     example: "Resource Not Found"
   }),
-  status: external_exports.number().int().openapi({
+  status: z$1.number().int().openapi({
     description: "The HTTP status code.",
     example: 404
   }),
-  detail: external_exports.string().openapi({
+  detail: z$1.string().openapi({
     description: "A human-readable explanation specific to this occurrence of the problem.",
     example: "The requested resource was not found."
   }),
-  instance: external_exports.string().optional().openapi({
+  instance: z$1.string().optional().openapi({
     description: "A URI reference that identifies the specific occurrence of the problem.",
     example: "/conversations/123"
   }),
-  requestId: external_exports.string().optional().openapi({
+  requestId: z$1.string().optional().openapi({
     description: "A unique identifier for the request, useful for troubleshooting.",
     example: "req_1234567890"
   }),
@@ -232,13 +244,13 @@ var problemDetailsSchema = external_exports.object({
     example: "not_found"
   })
 }).openapi("ProblemDetails");
-var errorResponseSchema = external_exports.object({
-  error: external_exports.object({
+var errorResponseSchema = z$1.object({
+  error: z$1.object({
     code: ErrorCode.openapi({
       description: "A short code indicating the error code returned.",
       example: "not_found"
     }),
-    message: external_exports.string().openapi({
+    message: z$1.string().openapi({
       description: "A human readable error message.",
       example: "The requested resource was not found."
     })
@@ -376,15 +388,15 @@ var errorSchemaFactory = (code, description) => ({
   content: {
     "application/problem+json": {
       schema: problemDetailsSchema.extend({
-        code: external_exports.literal(code).openapi({
+        code: z$1.literal(code).openapi({
           description: "A short code indicating the error code returned.",
           example: code
         }),
-        detail: external_exports.string().openapi({
+        detail: z$1.string().openapi({
           description: "A detailed explanation specific to this occurrence of the problem, providing context and specifics about what went wrong.",
           example: description
         }),
-        title: external_exports.string().openapi({
+        title: z$1.string().openapi({
           description: "A short, human-readable summary of the problem type.",
           example: getTitleFromCode(code)
         }),
@@ -392,16 +404,16 @@ var errorSchemaFactory = (code, description) => ({
         //   description: "A URI reference that identifies the problem type.",
         //   example: `${ERROR_DOCS_BASE_URL}#${code}`,
         // }),
-        status: external_exports.number().int().openapi({
+        status: z$1.number().int().openapi({
           description: "The HTTP status code.",
           example: errorCodeToHttpStatus[code]
         }),
-        error: external_exports.object({
-          code: external_exports.literal(code).openapi({
+        error: z$1.object({
+          code: z$1.literal(code).openapi({
             description: "A short code indicating the error code returned.",
             example: code
           }),
-          message: external_exports.string().openapi({
+          message: z$1.string().openapi({
             description: "A concise error message suitable for display to end users. May be truncated if the full detail is long.",
             example: description.length > 100 ? `${description.substring(0, 97)}...` : description
           })
@@ -462,6 +474,28 @@ function getRequestExecutionContext(c) {
   }
   return executionContext;
 }
+
+// src/utils/format-messages.ts
+function formatMessagesForLLM(messages) {
+  return messages.map((message) => {
+    const role = message.role === "user" ? "user" : message.role === "agent" ? "assistant" : "system";
+    const content = typeof message.content === "object" && message.content && "text" in message.content ? message.content.text : String(message.content || "");
+    return {
+      role,
+      content,
+      timestamp: message.createdAt,
+      fromSubAgentId: message.fromSubAgentId
+    };
+  });
+}
+function formatMessagesForLLMContext(messages) {
+  const formattedMessages = formatMessagesForLLM(messages);
+  return formattedMessages.map((msg) => {
+    const roleLabel = msg.role === "user" ? "User" : msg.role === "assistant" ? "Agent" : "System";
+    const agentInfo = msg.fromSubAgentId ? ` (${msg.fromSubAgentId})` : "";
+    return `${roleLabel}${agentInfo}: ${msg.content}`;
+  }).join("\n\n");
+}
 var McpClient = class {
   name;
   client;
@@ -579,7 +613,7 @@ var McpClient = class {
       try {
         const createZodSchema = (inputSchema) => {
           if (!inputSchema || !inputSchema.properties) {
-            return external_exports.object({});
+            return z.object({});
           }
           const zodProperties = {};
           for (const [key, prop] of Object.entries(inputSchema.properties)) {
@@ -587,19 +621,22 @@ var McpClient = class {
             let zodType;
             switch (propDef.type) {
               case "string":
-                zodType = external_exports.string();
+                zodType = z.string();
                 break;
               case "number":
-                zodType = external_exports.number();
+                zodType = z.number();
                 break;
               case "boolean":
-                zodType = external_exports.boolean();
+                zodType = z.boolean();
                 break;
               case "array":
-                zodType = external_exports.array(external_exports.any());
+                zodType = z.array(z.any());
+                break;
+              case "object":
+                zodType = createZodSchema(propDef);
                 break;
               default:
-                zodType = external_exports.any();
+                zodType = z.any();
             }
             if (propDef.description) {
               zodType = zodType.describe(propDef.description);
@@ -610,7 +647,7 @@ var McpClient = class {
             }
             zodProperties[key] = zodType;
           }
-          return external_exports.object(zodProperties);
+          return z.object(zodProperties);
         };
         const schema = createZodSchema(def.inputSchema);
         const createdTool = tool({
@@ -636,7 +673,268 @@ var McpClient = class {
     return results;
   }
 };
-var logger2 = getLogger("service-token-auth");
+var logger2 = getLogger("ModelFactory");
+var nimDefault = createOpenAICompatible({
+  name: "nim",
+  baseURL: "https://integrate.api.nvidia.com/v1",
+  headers: {
+    Authorization: `Bearer ${process.env.NIM_API_KEY}`
+  }
+});
+var ModelFactory = class _ModelFactory {
+  /**
+   * Create a provider instance with custom configuration
+   */
+  static createProvider(provider, config) {
+    switch (provider) {
+      case "anthropic":
+        return createAnthropic(config);
+      case "openai":
+        return createOpenAI(config);
+      case "google":
+        return createGoogleGenerativeAI(config);
+      case "openrouter":
+        return {
+          ...createOpenRouter(config),
+          textEmbeddingModel: () => {
+            throw new Error("OpenRouter does not support text embeddings");
+          },
+          imageModel: () => {
+            throw new Error("OpenRouter does not support image generation");
+          }
+        };
+      case "gateway":
+        return createGateway(config);
+      case "nim": {
+        const nimConfig = {
+          name: "nim",
+          baseURL: "https://integrate.api.nvidia.com/v1",
+          headers: {
+            Authorization: `Bearer ${process.env.NIM_API_KEY}`
+          },
+          ...config
+        };
+        return createOpenAICompatible(nimConfig);
+      }
+      case "custom": {
+        if (!config.baseURL && !config.baseUrl) {
+          throw new Error(
+            "Custom provider requires baseURL. Please provide it in providerOptions.baseURL or providerOptions.baseUrl"
+          );
+        }
+        const customConfig = {
+          name: "custom",
+          baseURL: config.baseURL || config.baseUrl,
+          headers: {
+            ...process.env.CUSTOM_LLM_API_KEY && {
+              Authorization: `Bearer ${process.env.CUSTOM_LLM_API_KEY}`
+            },
+            ...config.headers || {}
+          },
+          ...config
+        };
+        logger2.info(
+          {
+            config: {
+              baseURL: customConfig.baseURL,
+              hasApiKey: !!process.env.CUSTOM_LLM_API_KEY,
+              apiKeyPrefix: `${process.env.CUSTOM_LLM_API_KEY?.substring(0, 10)}...`,
+              headers: Object.keys(customConfig.headers || {})
+            }
+          },
+          "Creating custom OpenAI-compatible provider"
+        );
+        return createOpenAICompatible(customConfig);
+      }
+      default:
+        throw new Error(`Unsupported provider: ${provider}`);
+    }
+  }
+  /**
+   * Extract provider configuration from providerOptions
+   * Only includes settings that go to the provider constructor (baseURL, apiKey, etc.)
+   */
+  static extractProviderConfig(providerOptions) {
+    if (!providerOptions) {
+      return {};
+    }
+    const providerConfig = {};
+    if (providerOptions.baseUrl || providerOptions.baseURL) {
+      providerConfig.baseURL = providerOptions.baseUrl || providerOptions.baseURL;
+    }
+    if (providerOptions.headers) {
+      providerConfig.headers = providerOptions.headers;
+    }
+    if (providerOptions.gateway) {
+      Object.assign(providerConfig, providerOptions.gateway);
+    }
+    if (providerOptions.nim) {
+      Object.assign(providerConfig, providerOptions.nim);
+    }
+    if (providerOptions.custom) {
+      Object.assign(providerConfig, providerOptions.custom);
+    }
+    return providerConfig;
+  }
+  /**
+   * Create a language model instance from configuration
+   * Throws error if no config provided - models must be configured at project level
+   */
+  static createModel(config) {
+    if (!config?.model?.trim()) {
+      throw new Error(
+        "Model configuration is required. Please configure models at the project level."
+      );
+    }
+    const modelSettings = config;
+    if (!modelSettings.model) {
+      throw new Error("Model configuration is required");
+    }
+    const modelString = modelSettings.model.trim();
+    const { provider, modelName } = _ModelFactory.parseModelString(modelString);
+    logger2.debug(
+      {
+        provider,
+        model: modelName,
+        fullModelString: modelSettings.model,
+        hasProviderOptions: !!modelSettings.providerOptions
+      },
+      "Creating language model from config"
+    );
+    const providerConfig = _ModelFactory.extractProviderConfig(modelSettings.providerOptions);
+    if (Object.keys(providerConfig).length > 0) {
+      logger2.info({ config: providerConfig }, `Applying custom ${provider} provider configuration`);
+      const customProvider = _ModelFactory.createProvider(provider, providerConfig);
+      return customProvider.languageModel(modelName);
+    }
+    switch (provider) {
+      case "anthropic":
+        return anthropic(modelName);
+      case "openai":
+        return openai(modelName);
+      case "google":
+        return google(modelName);
+      case "openrouter":
+        return openrouter(modelName);
+      case "gateway":
+        return gateway(modelName);
+      case "nim":
+        return nimDefault(modelName);
+      case "custom":
+        throw new Error(
+          "Custom provider requires configuration. Please provide baseURL in providerOptions.custom.baseURL or providerOptions.baseURL"
+        );
+      default:
+        throw new Error(
+          `Unsupported provider: ${provider}. Supported providers are: ${_ModelFactory.BUILT_IN_PROVIDERS.join(", ")}. To access other models, use OpenRouter (openrouter/model-id), Vercel AI Gateway (gateway/model-id), NVIDIA NIM (nim/model-id), or Custom OpenAI-compatible (custom/model-id).`
+        );
+    }
+  }
+  /**
+   * Built-in providers that have special handling
+   */
+  static BUILT_IN_PROVIDERS = [
+    "anthropic",
+    "openai",
+    "google",
+    "openrouter",
+    "gateway",
+    "nim",
+    "custom"
+  ];
+  /**
+   * Parse model string to extract provider and model name
+   * Examples: "anthropic/claude-sonnet-4" -> { provider: "anthropic", modelName: "claude-sonnet-4" }
+   *          "openrouter/anthropic/claude-sonnet-4" -> { provider: "openrouter", modelName: "anthropic/claude-sonnet-4" }
+   *          "claude-sonnet-4" -> { provider: "anthropic", modelName: "claude-sonnet-4" } (default to anthropic)
+   */
+  static parseModelString(modelString) {
+    if (modelString.includes("/")) {
+      const [provider, ...modelParts] = modelString.split("/");
+      const normalizedProvider = provider.toLowerCase();
+      if (!_ModelFactory.BUILT_IN_PROVIDERS.includes(normalizedProvider)) {
+        throw new Error(
+          `Unsupported provider: ${normalizedProvider}. Supported providers are: ${_ModelFactory.BUILT_IN_PROVIDERS.join(", ")}. To access other models, use OpenRouter (openrouter/model-id), Vercel AI Gateway (gateway/model-id), NVIDIA NIM (nim/model-id), or Custom OpenAI-compatible (custom/model-id).`
+        );
+      }
+      return {
+        provider: normalizedProvider,
+        modelName: modelParts.join("/")
+      };
+    }
+    throw new Error(`No provider specified in model string: ${modelString}`);
+  }
+  /**
+   * Get generation parameters from provider options
+   * These are parameters that get passed to generateText/streamText calls
+   */
+  static getGenerationParams(providerOptions) {
+    if (!providerOptions) {
+      return {};
+    }
+    const excludedKeys = [
+      "apiKey",
+      "baseURL",
+      "baseUrl",
+      "maxDuration",
+      "headers",
+      "gateway",
+      "nim",
+      "custom"
+    ];
+    const params = {};
+    for (const [key, value] of Object.entries(providerOptions)) {
+      if (!excludedKeys.includes(key) && value !== void 0) {
+        params[key] = value;
+      }
+    }
+    return params;
+  }
+  /**
+   * Prepare complete generation configuration from model settings
+   * Returns model instance and generation parameters ready to spread into generateText/streamText
+   * Includes maxDuration if specified in provider options (in seconds, following Vercel standard)
+   */
+  static prepareGenerationConfig(modelSettings) {
+    const modelString = modelSettings?.model?.trim();
+    const model = _ModelFactory.createModel({
+      model: modelString,
+      providerOptions: modelSettings?.providerOptions
+    });
+    const generationParams = _ModelFactory.getGenerationParams(modelSettings?.providerOptions);
+    const maxDuration = modelSettings?.providerOptions?.maxDuration;
+    return {
+      model,
+      ...generationParams,
+      ...maxDuration !== void 0 && { maxDuration }
+    };
+  }
+  /**
+   * Validate model settingsuration
+   * Basic validation only - let AI SDK handle parameter-specific validation
+   */
+  static validateConfig(config) {
+    const errors = [];
+    if (!config.model) {
+      errors.push("Model name is required");
+    }
+    if (config.providerOptions) {
+      if (config.providerOptions.apiKey) {
+        errors.push(
+          "API keys should not be stored in provider options. Use environment variables (ANTHROPIC_API_KEY, OPENAI_API_KEY) or credential store instead."
+        );
+      }
+      if (config.providerOptions.maxDuration !== void 0) {
+        const maxDuration = config.providerOptions.maxDuration;
+        if (typeof maxDuration !== "number" || maxDuration <= 0) {
+          errors.push("maxDuration must be a positive number (in seconds)");
+        }
+      }
+    }
+    return errors;
+  }
+};
+var logger3 = getLogger("service-token-auth");
 function getJwtSecret() {
   const secret = env.INKEEP_AGENTS_JWT_SIGNING_SECRET;
   const dev_secret = "insecure-dev-secret-change-in-production-min-32-chars";
@@ -646,7 +944,7 @@ function getJwtSecret() {
         "INKEEP_AGENTS_JWT_SIGNING_SECRET environment variable is required in production"
       );
     }
-    logger2.warn(
+    logger3.warn(
       {},
       "INKEEP_AGENTS_JWT_SIGNING_SECRET not set, using insecure default. DO NOT USE IN PRODUCTION!"
     );
@@ -661,7 +959,7 @@ async function generateServiceToken(params) {
       tenantId: params.tenantId,
       projectId: params.projectId
     }).setProtectedHeader({ alg: "HS256", typ: "JWT" }).setIssuer("inkeep-agents").setSubject(params.originAgentId).setAudience(params.targetAgentId).setIssuedAt().setExpirationTime("5m").sign(secret);
-    logger2.debug(
+    logger3.debug(
       {
         originAgentId: params.originAgentId,
         targetAgentId: params.targetAgentId,
@@ -671,7 +969,7 @@ async function generateServiceToken(params) {
     );
     return token;
   } catch (error) {
-    logger2.error({ error }, "Failed to generate service token");
+    logger3.error({ error }, "Failed to generate service token");
     throw new Error("Failed to generate service token");
   }
 }
@@ -683,7 +981,7 @@ async function verifyServiceToken(token) {
       algorithms: ["HS256"]
     });
     if (typeof payload.sub !== "string" || typeof payload.aud !== "string" || typeof payload.tenantId !== "string" || typeof payload.projectId !== "string") {
-      logger2.warn({ payload }, "Invalid service token: missing required claims");
+      logger3.warn({ payload }, "Invalid service token: missing required claims");
       return {
         valid: false,
         error: "Invalid token: missing required claims"
@@ -698,7 +996,7 @@ async function verifyServiceToken(token) {
       iat: payload.iat,
       exp: payload.exp
     };
-    logger2.debug(
+    logger3.debug(
       {
         originAgentId: validPayload.sub,
         targetAgentId: validPayload.aud,
@@ -712,13 +1010,13 @@ async function verifyServiceToken(token) {
     };
   } catch (error) {
     if (error instanceof Error) {
-      logger2.warn({ error: error.message }, "Team agent token verification failed");
+      logger3.warn({ error: error.message }, "Team agent token verification failed");
       return {
         valid: false,
         error: error.message
       };
     }
-    logger2.warn({ error }, "Team agent token verification failed with unknown error");
+    logger3.warn({ error }, "Team agent token verification failed with unknown error");
     return {
       valid: false,
       error: "Token verification failed"
@@ -727,7 +1025,7 @@ async function verifyServiceToken(token) {
 }
 function validateTenantId(payload, expectedTenantId) {
   if (payload.tenantId !== expectedTenantId) {
-    logger2.warn(
+    logger3.warn(
       {
         tokenTenantId: payload.tenantId,
         expectedTenantId,
@@ -742,7 +1040,7 @@ function validateTenantId(payload, expectedTenantId) {
 }
 function validateTargetAgent(payload, expectedTargetAgentId) {
   if (payload.aud !== expectedTargetAgentId) {
-    logger2.warn(
+    logger3.warn(
       {
         tokenTargetAgentId: payload.aud,
         expectedTargetAgentId,
@@ -793,7 +1091,7 @@ async function verifyTempToken(publicKeyPem, token) {
   }
   return payload;
 }
-var logger3 = getLogger("composio-client");
+var logger4 = getLogger("composio-client");
 var TOOLKIT_TO_CATEGORY = {
   github: "development",
   gitlab: "development",
@@ -867,21 +1165,21 @@ function addUserIdToUrl(url, userId) {
 async function deleteComposioConnectedAccount(accountId) {
   const composioInstance = getComposioInstance();
   if (!composioInstance) {
-    logger3.info({}, "Composio not configured, skipping account deletion");
+    logger4.info({}, "Composio not configured, skipping account deletion");
     return false;
   }
   try {
     await composioInstance.connectedAccounts.delete(accountId);
     return true;
   } catch (error) {
-    logger3.warn({ error }, "Error deleting Composio connected account");
+    logger4.warn({ error }, "Error deleting Composio connected account");
     return false;
   }
 }
 async function fetchComposioConnectedAccounts(derivedUserId) {
   const composioInstance = getComposioInstance();
   if (!composioInstance) {
-    logger3.info({}, "Composio not configured, skipping connected accounts fetch");
+    logger4.info({}, "Composio not configured, skipping connected accounts fetch");
     return null;
   }
   try {
@@ -890,25 +1188,25 @@ async function fetchComposioConnectedAccounts(derivedUserId) {
     });
     return connectedAccounts;
   } catch (error) {
-    logger3.error({ error }, "Error fetching Composio connected accounts");
+    logger4.error({ error }, "Error fetching Composio connected accounts");
     return null;
   }
 }
 async function isComposioMCPServerAuthenticated(tenantId, projectId, mcpServerUrl) {
   const composioApiKey = process.env.COMPOSIO_API_KEY;
   if (!composioApiKey) {
-    logger3.info({}, "Composio API key not configured, skipping auth check");
+    logger4.info({}, "Composio API key not configured, skipping auth check");
     return false;
   }
   const serverId = extractComposioServerId(mcpServerUrl);
   if (!serverId) {
-    logger3.info({ mcpServerUrl }, "Could not extract Composio server ID from URL");
+    logger4.info({ mcpServerUrl }, "Could not extract Composio server ID from URL");
     return false;
   }
   const derivedUserId = deriveComposioUserId(tenantId, projectId);
   const composioInstance = getComposioInstance();
   if (!composioInstance) {
-    logger3.info({}, "Composio not configured, skipping auth check");
+    logger4.info({}, "Composio not configured, skipping auth check");
     return false;
   }
   try {
@@ -926,7 +1224,7 @@ async function isComposioMCPServerAuthenticated(tenantId, projectId, mcpServerUr
     );
     return !!activeAccount;
   } catch (error) {
-    logger3.error({ error, mcpServerUrl }, "Error checking Composio authentication status");
+    logger4.error({ error, mcpServerUrl }, "Error checking Composio authentication status");
     return false;
   }
 }
@@ -950,7 +1248,7 @@ function transformComposioServerData(composioMcpServer, isAuthenticated, url, th
 async function ensureComposioAccount(composioMcpServer, derivedUserId, initiatedAccounts) {
   const firstAuthConfigId = composioMcpServer.authConfigIds[0];
   if (!firstAuthConfigId) {
-    logger3.error({ serverId: composioMcpServer.id }, "No auth config ID found for MCP server");
+    logger4.error({ serverId: composioMcpServer.id }, "No auth config ID found for MCP server");
     return null;
   }
   const existingInitiatedAccount = initiatedAccounts.find(
@@ -962,7 +1260,7 @@ async function ensureComposioAccount(composioMcpServer, derivedUserId, initiated
   try {
     const composioInstance = getComposioInstance();
     if (!composioInstance) {
-      logger3.error({ serverId: composioMcpServer.id }, "Composio not configured");
+      logger4.error({ serverId: composioMcpServer.id }, "Composio not configured");
       return null;
     }
     const createAccountResponse = await composioInstance.connectedAccounts.link(
@@ -971,7 +1269,7 @@ async function ensureComposioAccount(composioMcpServer, derivedUserId, initiated
     );
     return createAccountResponse.redirectUrl ?? null;
   } catch (error) {
-    logger3.error(
+    logger4.error(
       { serverId: composioMcpServer.id, error },
       "Error creating connected account for MCP server"
     );
@@ -1008,13 +1306,13 @@ async function transformComposioServer(composioMcpServer, authenticatedAuthConfi
 async function fetchComposioServers(tenantId, projectId) {
   const composioApiKey = process.env.COMPOSIO_API_KEY;
   if (!composioApiKey) {
-    logger3.info({}, "COMPOSIO_API_KEY not configured, skipping Composio servers");
+    logger4.info({}, "COMPOSIO_API_KEY not configured, skipping Composio servers");
     return [];
   }
   const derivedUserId = deriveComposioUserId(tenantId, projectId);
   const composioInstance = getComposioInstance();
   if (!composioInstance) {
-    logger3.info({}, "Composio not configured, returning empty list");
+    logger4.info({}, "Composio not configured, returning empty list");
     return [];
   }
   try {
@@ -1051,26 +1349,26 @@ async function fetchComposioServers(tenantId, projectId) {
     );
     return validServers;
   } catch (error) {
-    logger3.error({ error }, "Failed to fetch Composio servers");
+    logger4.error({ error }, "Failed to fetch Composio servers");
     return [];
   }
 }
 async function fetchSingleComposioServer(tenantId, projectId, mcpServerUrl) {
   const composioApiKey = process.env.COMPOSIO_API_KEY;
   if (!composioApiKey) {
-    logger3.debug({}, "COMPOSIO_API_KEY not configured");
+    logger4.debug({}, "COMPOSIO_API_KEY not configured");
     return null;
   }
   const derivedUserId = deriveComposioUserId(tenantId, projectId);
   const composioInstance = getComposioInstance();
   if (!composioInstance) {
-    logger3.info({}, "Composio not configured, returning null");
+    logger4.info({}, "Composio not configured, returning null");
     return null;
   }
   try {
     const serverId = extractComposioServerId(mcpServerUrl);
     if (!serverId) {
-      logger3.error({ mcpServerUrl }, "Could not extract Composio server ID from URL");
+      logger4.error({ mcpServerUrl }, "Could not extract Composio server ID from URL");
       return null;
     }
     const composioMcpServer = await composioInstance.mcp.get(serverId);
@@ -1094,23 +1392,23 @@ async function fetchSingleComposioServer(tenantId, projectId, mcpServerUrl) {
     );
     return transformedServer;
   } catch (error) {
-    logger3.error({ error, mcpServerUrl }, "Failed to fetch single Composio server");
+    logger4.error({ error, mcpServerUrl }, "Failed to fetch single Composio server");
     return null;
   }
 }
 
 // src/utils/third-party-mcp-servers/third-party-check.ts
-var logger4 = getLogger("third-party-check");
+var logger5 = getLogger("third-party-check");
 async function isThirdPartyMCPServerAuthenticated(tenantId, projectId, mcpServerUrl) {
   const composioServerId = extractComposioServerId(mcpServerUrl);
   if (composioServerId) {
-    logger4.debug({ mcpServerUrl }, "Detected Composio MCP server, checking auth status");
+    logger5.debug({ mcpServerUrl }, "Detected Composio MCP server, checking auth status");
     return isComposioMCPServerAuthenticated(tenantId, projectId, mcpServerUrl);
   }
-  logger4.info({ mcpServerUrl }, "Unknown third-party MCP server provider");
+  logger5.info({ mcpServerUrl }, "Unknown third-party MCP server provider");
   return false;
 }
-var logger5 = getLogger("tracer");
+var logger6 = getLogger("tracer");
 var createNoOpSpan = () => ({
   setAttributes: () => ({}),
   recordException: () => ({}),
@@ -1139,23 +1437,23 @@ var noopTracer = {
     return createNoOpSpan();
   }
 };
-function setSpanWithError(span, error, logger6, logMessage) {
+function setSpanWithError(span, error, logger7, logMessage) {
   span.recordException(error);
   span.setStatus({
     code: SpanStatusCode.ERROR,
     message: error.message
   });
-  if (logger6 && logMessage) {
-    logger6.error({ error: error.message }, logMessage);
+  if (logger7 && logMessage) {
+    logger7.error({ error: error.message }, logMessage);
   }
 }
 function getTracer(serviceName, serviceVersion) {
   try {
     return trace.getTracer(serviceName, serviceVersion);
   } catch (_error) {
-    logger5.debug({}, "OpenTelemetry tracer not available, using no-op tracer");
+    logger6.debug({}, "OpenTelemetry tracer not available, using no-op tracer");
     return noopTracer;
   }
 }
 
-export { CONVERSATION_HISTORY_DEFAULT_LIMIT, CONVERSATION_HISTORY_MAX_OUTPUT_TOKENS_DEFAULT, ERROR_DOCS_BASE_URL, ErrorCode, MCP_TOOL_CONNECTION_TIMEOUT_MS, MCP_TOOL_INITIAL_RECONNECTION_DELAY_MS, MCP_TOOL_MAX_RECONNECTION_DELAY_MS, MCP_TOOL_MAX_RETRIES, MCP_TOOL_RECONNECTION_DELAY_GROWTH_FACTOR, McpClient, commonCreateErrorResponses, commonDeleteErrorResponses, commonGetErrorResponses, commonUpdateErrorResponses, createApiError, createExecutionContext, errorResponseSchema, errorSchemaFactory, executionLimitsSharedDefaults, extractComposioServerId, extractPublicId, fetchComposioServers, fetchSingleComposioServer, generateApiKey, generateId, generateServiceToken, getConversationId, getCredentialStoreLookupKeyFromRetrievalParams, getRequestExecutionContext, getTracer, handleApiError, hashApiKey, isApiKeyExpired, isComposioMCPServerAuthenticated, isThirdPartyMCPServerAuthenticated, maskApiKey, normalizeDateString, problemDetailsSchema, setSpanWithError, signTempToken, validateApiKey, validateTargetAgent, validateTenantId, verifyAuthorizationHeader, verifyServiceToken, verifyTempToken };
+export { CONVERSATION_HISTORY_DEFAULT_LIMIT, CONVERSATION_HISTORY_MAX_OUTPUT_TOKENS_DEFAULT, ERROR_DOCS_BASE_URL, ErrorCode, MCP_TOOL_CONNECTION_TIMEOUT_MS, MCP_TOOL_INITIAL_RECONNECTION_DELAY_MS, MCP_TOOL_MAX_RECONNECTION_DELAY_MS, MCP_TOOL_MAX_RETRIES, MCP_TOOL_RECONNECTION_DELAY_GROWTH_FACTOR, McpClient, ModelFactory, commonCreateErrorResponses, commonDeleteErrorResponses, commonGetErrorResponses, commonUpdateErrorResponses, createApiError, createExecutionContext, errorResponseSchema, errorSchemaFactory, executionLimitsSharedDefaults, extractComposioServerId, extractPublicId, fetchComposioServers, fetchSingleComposioServer, formatMessagesForLLM, formatMessagesForLLMContext, generateApiKey, generateId, generateServiceToken, getConversationId, getCredentialStoreLookupKeyFromRetrievalParams, getRequestExecutionContext, getTracer, handleApiError, hashApiKey, isApiKeyExpired, isComposioMCPServerAuthenticated, isThirdPartyMCPServerAuthenticated, maskApiKey, normalizeDateString, problemDetailsSchema, setSpanWithError, signTempToken, toISODateString, validateApiKey, validateTargetAgent, validateTenantId, verifyAuthorizationHeader, verifyServiceToken, verifyTempToken };