@inkeep/agents-core 0.36.1 → 0.37.1

package/dist/{chunk-4OISWRFK.js → chunk-ROXPFQAM.js}

@@ -1,4 +1,4 @@
-import { loadEnvironmentFiles, env } from './chunk-4RVJB4KV.js';
+import { loadEnvironmentFiles, env } from './chunk-LL6F3EAR.js';
 import { getLogger } from './chunk-DN4B564Y.js';
 import { CredentialStoreType, MCPTransportType } from './chunk-YFHT5M2R.js';
 import { z } from 'zod';
@@ -15,6 +15,13 @@ 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';
 import { SpanStatusCode, trace } from '@opentelemetry/api';
@@ -177,10 +184,17 @@ 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;
 }
+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",
@@ -460,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;
@@ -596,6 +632,9 @@ var McpClient = class {
               case "array":
                 zodType = z.array(z.any());
                 break;
+              case "object":
+                zodType = createZodSchema(propDef);
+                break;
               default:
                 zodType = z.any();
             }
@@ -634,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";
@@ -644,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!"
     );
@@ -659,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,
@@ -669,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");
   }
 }
@@ -681,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"
@@ -696,7 +996,7 @@ async function verifyServiceToken(token) {
       iat: payload.iat,
       exp: payload.exp
     };
-    logger2.debug(
+    logger3.debug(
       {
         originAgentId: validPayload.sub,
         targetAgentId: validPayload.aud,
@@ -710,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"
@@ -725,7 +1025,7 @@ async function verifyServiceToken(token) {
 }
 function validateTenantId(payload, expectedTenantId) {
   if (payload.tenantId !== expectedTenantId) {
-    logger2.warn(
+    logger3.warn(
       {
         tokenTenantId: payload.tenantId,
         expectedTenantId,
@@ -740,7 +1040,7 @@ function validateTenantId(payload, expectedTenantId) {
 }
 function validateTargetAgent(payload, expectedTargetAgentId) {
   if (payload.aud !== expectedTargetAgentId) {
-    logger2.warn(
+    logger3.warn(
       {
         tokenTargetAgentId: payload.aud,
         expectedTargetAgentId,
@@ -774,7 +1074,24 @@ async function verifyAuthorizationHeader(authHeader) {
   }
   return verifyServiceToken(token);
 }
-var logger3 = getLogger("composio-client");
+async function signTempToken(privateKeyPem, payload, userId) {
+  const privateKey = await jose.importPKCS8(privateKeyPem, "RS256");
+  const jwt = await new jose.SignJWT(payload).setProtectedHeader({ alg: "RS256", typ: "JWT" }).setIssuedAt().setExpirationTime("1h").setIssuer("inkeep-manage-api").setAudience("inkeep-run-api").setSubject(userId).setJti(generateId()).sign(privateKey);
+  const expiresAt = new Date(Date.now() + 60 * 60 * 1e3).toISOString();
+  return { token: jwt, expiresAt };
+}
+async function verifyTempToken(publicKeyPem, token) {
+  const publicKey = await jose.importSPKI(publicKeyPem, "RS256");
+  const { payload } = await jose.jwtVerify(token, publicKey, {
+    issuer: "inkeep-manage-api",
+    audience: "inkeep-run-api"
+  });
+  if (payload.type !== "temporary") {
+    throw new Error("Invalid token type");
+  }
+  return payload;
+}
+var logger4 = getLogger("composio-client");
 var TOOLKIT_TO_CATEGORY = {
   github: "development",
   gitlab: "development",
@@ -848,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 {
@@ -871,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 {
@@ -907,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;
   }
 }
@@ -931,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(
@@ -943,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(
@@ -952,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"
     );
@@ -989,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 {
@@ -1032,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);
@@ -1075,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: () => ({}),
@@ -1120,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, validateApiKey, validateTargetAgent, validateTenantId, verifyAuthorizationHeader, verifyServiceToken };
+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 };

package/dist/{chunk-OEHP46F7.js → chunk-W3QDM7WH.js}

@@ -1,4 +1,4 @@
-import { AgentWithinContextOfProjectSchema, resourceIdSchema, MAX_ID_LENGTH } from './chunk-ZCEKN54E.js';
+import { AgentWithinContextOfProjectSchema, resourceIdSchema, MAX_ID_LENGTH } from './chunk-K6GMXJPW.js';
 import { z } from 'zod';
 
 // src/validation/cycleDetection.ts

package/dist/{chunk-KMLLKRUY.js → chunk-ZEZCCHV7.js}

@@ -1,5 +1,5 @@
 import { schemaValidationDefaults } from './chunk-Z64UK4CA.js';
-import { loadEnvironmentFiles } from './chunk-4RVJB4KV.js';
+import { loadEnvironmentFiles } from './chunk-LL6F3EAR.js';
 import { z } from 'zod';
 
 loadEnvironmentFiles();

package/dist/{client-HrEgt7wv.d.ts → client-B_3j-V4-.d.ts}

@@ -1,6 +1,6 @@
 import { NodePgDatabase } from 'drizzle-orm/node-postgres';
 import { PgliteDatabase } from 'drizzle-orm/pglite';
-import { s as schema } from './schema-CoC3tYFX.js';
+import { s as schema } from './schema-DKbG39on.js';
 
 type DatabaseClient = NodePgDatabase<typeof schema> | PgliteDatabase<typeof schema>;
 interface DatabaseConfig {