@inkeep/agents-core 0.0.0-dev-20251124223719 → 0.0.0-dev-20251124234228

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

@@ -1,4 +1,4 @@
-import { loadEnvironmentFiles, env } from './chunk-Q5U2SVA6.js';
+import { loadEnvironmentFiles, env } from './chunk-NMBNWFIZ.js';
 import { getLogger } from './chunk-DN4B564Y.js';
 import { CredentialStoreType, MCPTransportType } from './chunk-YFHT5M2R.js';
 import { external_exports } from './chunk-OUXC23J7.js';
@@ -14,6 +14,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';
@@ -179,10 +185,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 = external_exports.enum([
   "bad_request",
   "unauthorized",
@@ -462,6 +475,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;
@@ -598,6 +633,9 @@ var McpClient = class {
               case "array":
                 zodType = external_exports.array(external_exports.any());
                 break;
+              case "object":
+                zodType = createZodSchema(propDef);
+                break;
               default:
                 zodType = external_exports.any();
             }
@@ -636,7 +674,259 @@ 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 +936,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 +951,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 +961,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 +973,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 +988,7 @@ async function verifyServiceToken(token) {
       iat: payload.iat,
       exp: payload.exp
     };
-    logger2.debug(
+    logger3.debug(
       {
         originAgentId: validPayload.sub,
         targetAgentId: validPayload.aud,
@@ -712,13 +1002,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 +1017,7 @@ async function verifyServiceToken(token) {
 }
 function validateTenantId(payload, expectedTenantId) {
   if (payload.tenantId !== expectedTenantId) {
-    logger2.warn(
+    logger3.warn(
       {
         tokenTenantId: payload.tenantId,
         expectedTenantId,
@@ -742,7 +1032,7 @@ function validateTenantId(payload, expectedTenantId) {
 }
 function validateTargetAgent(payload, expectedTargetAgentId) {
   if (payload.aud !== expectedTargetAgentId) {
-    logger2.warn(
+    logger3.warn(
       {
         tokenTargetAgentId: payload.aud,
         expectedTargetAgentId,
@@ -793,7 +1083,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 +1157,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 +1180,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 +1216,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 +1240,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 +1252,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 +1261,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 +1298,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 +1341,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 +1384,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 +1429,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 };

package/dist/{chunk-SG75RA63.js → chunk-K54FZSDH.js}

@@ -1,4 +1,4 @@
-import { schema_exports, projects } from './chunk-NFYCSHD3.js';
+import { schema_exports, projects } from './chunk-OHZDHXP7.js';
 import { organization } from './chunk-NOPEANIU.js';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';

package/dist/{chunk-TGESM3JG.js → chunk-MQMMFK2K.js}

@@ -10,7 +10,10 @@ var SPAN_NAMES = {
   CONTEXT_HANDLE: "context.handle_context_resolution",
   AGENT_GENERATION: "agent.generate",
   CONTEXT_FETCHER: "context-fetcher.http-request",
-  ARTIFACT_PROCESSING: "agent_session.process_artifact"
+  ARTIFACT_PROCESSING: "agent_session.process_artifact",
+  TOOL_APPROVAL_REQUESTED: "tool.approval_requested",
+  TOOL_APPROVAL_APPROVED: "tool.approval_approved",
+  TOOL_APPROVAL_DENIED: "tool.approval_denied"
 };
 var AI_OPERATIONS = {
   GENERATE_TEXT: "ai.generateText.doGenerate",
@@ -55,6 +58,8 @@ var SPAN_KEYS = {
   AI_TOOL_CALL_ID: "ai.toolCall.id",
   AI_TOOL_TYPE: "ai.toolType",
   TOOL_PURPOSE: "tool.purpose",
+  TOOL_NAME: "tool.name",
+  TOOL_CALL_ID: "tool.callId",
   // Token usage
   GEN_AI_USAGE_INPUT_TOKENS: "gen_ai.usage.input_tokens",
   GEN_AI_USAGE_OUTPUT_TOKENS: "gen_ai.usage.output_tokens",
@@ -99,7 +104,10 @@ var ACTIVITY_TYPES = {
   USER_MESSAGE: "user_message",
   AI_ASSISTANT_MESSAGE: "ai_assistant_message",
   AI_MODEL_STREAMED_TEXT: "ai_model_streamed_text",
-  AI_MODEL_STREAMED_OBJECT: "ai_model_streamed_object"
+  AI_MODEL_STREAMED_OBJECT: "ai_model_streamed_object",
+  TOOL_APPROVAL_REQUESTED: "tool_approval_requested",
+  TOOL_APPROVAL_APPROVED: "tool_approval_approved",
+  TOOL_APPROVAL_DENIED: "tool_approval_denied"
 };
 var ACTIVITY_STATUS = {
   SUCCESS: "success",
@@ -231,7 +239,10 @@ var QUERY_EXPRESSIONS = {
   DURATION_SPANS: "durationSpans",
   AGENT_GENERATIONS: "agentGenerations",
   SPANS_WITH_ERRORS: "spansWithErrors",
-  ARTIFACT_PROCESSING: "artifactProcessing"
+  ARTIFACT_PROCESSING: "artifactProcessing",
+  TOOL_APPROVAL_REQUESTED: "toolApprovalRequested",
+  TOOL_APPROVAL_APPROVED: "toolApprovalApproved",
+  TOOL_APPROVAL_DENIED: "toolApprovalDenied"
 };
 var REDUCE_OPERATIONS = {
   SUM: "sum",