@inkeep/agents-core 0.35.2 → 0.35.4

package/dist/{chunk-ZYSTJ4XY.js → chunk-D3NGJEP2.js}

@@ -1,13 +1,6 @@
-import { getLogger } from './chunk-W3L4M7FO.js';
+import { loadEnvironmentFiles, env } from './chunk-4RVJB4KV.js';
+import { getLogger } from './chunk-DN4B564Y.js';
 import { CredentialStoreType, MCPTransportType } from './chunk-YFHT5M2R.js';
-import { schema_exports, projects } from './chunk-NFYCSHD3.js';
-import { organization } from './chunk-NOPEANIU.js';
-import fs from 'fs';
-import os from 'os';
-import path, { dirname, join } from 'path';
-import dotenv from 'dotenv';
-import { expand } from 'dotenv-expand';
-import { findUpSync } from 'find-up';
 import { z } from 'zod';
 import { customAlphabet } from 'nanoid';
 import { scrypt, randomBytes, timingSafeEqual } from 'crypto';
@@ -23,61 +16,8 @@ import { tool } from 'ai';
 import { asyncExitHook, gracefulExit } from 'exit-hook';
 import { match } from 'ts-pattern';
 import { SignJWT, jwtVerify } from 'jose';
+import { Composio } from '@composio/core';
 import { SpanStatusCode, trace } from '@opentelemetry/api';
-import { fileURLToPath } from 'url';
-import { PGlite } from '@electric-sql/pglite';
-import { sql } from 'drizzle-orm';
-import { drizzle } from 'drizzle-orm/pglite';
-import { migrate } from 'drizzle-orm/pglite/migrator';
-
-var loadEnvironmentFiles = () => {
-  const environmentFiles = [];
-  const currentEnv = path.resolve(process.cwd(), ".env");
-  if (fs.existsSync(currentEnv)) {
-    environmentFiles.push(currentEnv);
-  }
-  const rootEnv = findUpSync(".env", { cwd: path.dirname(process.cwd()) });
-  if (rootEnv) {
-    if (rootEnv !== currentEnv) {
-      environmentFiles.push(rootEnv);
-    }
-  }
-  const userConfigPath = path.join(os.homedir(), ".inkeep", "config");
-  if (fs.existsSync(userConfigPath)) {
-    dotenv.config({ path: userConfigPath, override: true, quiet: true });
-  }
-  if (environmentFiles.length > 0) {
-    dotenv.config({
-      path: environmentFiles,
-      override: false,
-      quiet: true
-    });
-    expand({ processEnv: process.env });
-  }
-};
-loadEnvironmentFiles();
-var envSchema = z.object({
-  ENVIRONMENT: z.enum(["development", "production", "pentest", "test"]).optional(),
-  DATABASE_URL: z.string().optional(),
-  POSTGRES_POOL_SIZE: z.string().optional(),
-  INKEEP_AGENTS_JWT_SIGNING_SECRET: z.string().min(32, "INKEEP_AGENTS_JWT_SIGNING_SECRET must be at least 32 characters").optional()
-});
-var parseEnv = () => {
-  try {
-    const parsedEnv = envSchema.parse(process.env);
-    return parsedEnv;
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      const missingVars = error.issues.map((issue) => issue.path.join("."));
-      throw new Error(
-        `\u274C Invalid environment variables: ${missingVars.join(", ")}
-${error.message}`
-      );
-    }
-    throw error;
-  }
-};
-var env = parseEnv();
 
 // src/constants/execution-limits-shared/defaults.ts
 var executionLimitsSharedDefaults = {
@@ -834,7 +774,324 @@ async function verifyAuthorizationHeader(authHeader) {
   }
   return verifyServiceToken(token);
 }
-var logger3 = getLogger("tracer");
+var logger3 = getLogger("composio-client");
+var TOOLKIT_TO_CATEGORY = {
+  github: "development",
+  gitlab: "development",
+  bitbucket: "development",
+  jira: "project_management",
+  asana: "project_management",
+  linear: "project_management",
+  trello: "project_management",
+  monday: "project_management",
+  slack: "communication",
+  discord: "communication",
+  teams: "communication",
+  zoom: "communication",
+  notion: "knowledge",
+  confluence: "knowledge",
+  docs: "knowledge",
+  drive: "storage",
+  dropbox: "storage",
+  box: "storage",
+  stripe: "payments",
+  paypal: "payments",
+  square: "payments",
+  gmail: "communication",
+  outlook: "communication",
+  calendar: "productivity",
+  sheets: "productivity",
+  airtable: "database",
+  salesforce: "crm",
+  hubspot: "crm",
+  zendesk: "communication",
+  intercom: "communication"
+};
+var composio = null;
+function getComposioInstance() {
+  if (!process.env.COMPOSIO_API_KEY) {
+    return null;
+  }
+  if (!composio) {
+    composio = new Composio({
+      apiKey: process.env.COMPOSIO_API_KEY
+    });
+  }
+  return composio;
+}
+function deriveComposioUserId(tenantId, projectId) {
+  const SEPARATOR = "||";
+  return `${tenantId}${SEPARATOR}${projectId}`;
+}
+function extractComposioServerId(mcpUrl) {
+  if (!mcpUrl.includes("composio.dev")) {
+    return null;
+  }
+  try {
+    const urlObj = new URL(mcpUrl);
+    const pathParts = urlObj.pathname.split("/");
+    const mcpIndex = pathParts.indexOf("mcp");
+    if (mcpIndex !== -1 && pathParts[mcpIndex + 1]) {
+      return pathParts[mcpIndex + 1];
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function addUserIdToUrl(url, userId) {
+  const urlObj = new URL(url);
+  urlObj.searchParams.set("user_id", userId);
+  urlObj.searchParams.delete("transport");
+  return urlObj.toString();
+}
+async function deleteComposioConnectedAccount(accountId) {
+  const composioInstance = getComposioInstance();
+  if (!composioInstance) {
+    logger3.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");
+    return false;
+  }
+}
+async function fetchComposioConnectedAccounts(derivedUserId) {
+  const composioInstance = getComposioInstance();
+  if (!composioInstance) {
+    logger3.info({}, "Composio not configured, skipping connected accounts fetch");
+    return null;
+  }
+  try {
+    const connectedAccounts = await composioInstance.connectedAccounts.list({
+      userIds: [derivedUserId]
+    });
+    return connectedAccounts;
+  } catch (error) {
+    logger3.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");
+    return false;
+  }
+  const serverId = extractComposioServerId(mcpServerUrl);
+  if (!serverId) {
+    logger3.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");
+    return false;
+  }
+  try {
+    const composioMcpServer = await composioInstance.mcp.get(serverId);
+    const firstAuthConfigId = composioMcpServer.authConfigIds.length > 0 ? composioMcpServer.authConfigIds[0] : null;
+    if (!firstAuthConfigId) {
+      return false;
+    }
+    const connectedAccounts = await fetchComposioConnectedAccounts(derivedUserId);
+    if (!connectedAccounts) {
+      return false;
+    }
+    const activeAccount = connectedAccounts.items.find(
+      (account) => account.authConfig.id === firstAuthConfigId && account.status === "ACTIVE"
+    );
+    return !!activeAccount;
+  } catch (error) {
+    logger3.error({ error, mcpServerUrl }, "Error checking Composio authentication status");
+    return false;
+  }
+}
+function transformComposioServerData(composioMcpServer, isAuthenticated, url, thirdPartyConnectAccountUrl) {
+  const firstToolkit = composioMcpServer.toolkits[0];
+  const category = firstToolkit ? TOOLKIT_TO_CATEGORY[firstToolkit] || "integration" : "integration";
+  const imageUrl = composioMcpServer.toolkitIcons?.[firstToolkit];
+  const description = composioMcpServer.toolkits.length > 0 ? `${composioMcpServer.toolkits.slice(0, 3).join(", ")} integration${composioMcpServer.toolkits.length > 1 ? "s" : ""} via Composio` : "Integration via Composio";
+  return {
+    id: composioMcpServer.id,
+    name: composioMcpServer.name,
+    url,
+    transport: MCPTransportType.streamableHttp,
+    imageUrl,
+    category,
+    description,
+    isOpen: isAuthenticated,
+    thirdPartyConnectAccountUrl
+  };
+}
+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");
+    return null;
+  }
+  const existingInitiatedAccount = initiatedAccounts.find(
+    (account) => account.authConfig.id === firstAuthConfigId
+  );
+  if (existingInitiatedAccount) {
+    await deleteComposioConnectedAccount(existingInitiatedAccount.id);
+  }
+  try {
+    const composioInstance = getComposioInstance();
+    if (!composioInstance) {
+      logger3.error({ serverId: composioMcpServer.id }, "Composio not configured");
+      return null;
+    }
+    const createAccountResponse = await composioInstance.connectedAccounts.link(
+      derivedUserId,
+      firstAuthConfigId
+    );
+    return createAccountResponse.redirectUrl ?? null;
+  } catch (error) {
+    logger3.error(
+      { serverId: composioMcpServer.id, error },
+      "Error creating connected account for MCP server"
+    );
+    return null;
+  }
+}
+async function transformComposioServer(composioMcpServer, authenticatedAuthConfigIds, initiatedAccounts, derivedUserId) {
+  const isAuthenticated = composioMcpServer.authConfigIds.some(
+    (authConfigId) => authenticatedAuthConfigIds.has(authConfigId)
+  );
+  let url = composioMcpServer.MCPUrl;
+  let thirdPartyConnectAccountUrl;
+  if (isAuthenticated) {
+    url = addUserIdToUrl(url, derivedUserId);
+  } else {
+    const redirectUrl = await ensureComposioAccount(
+      composioMcpServer,
+      derivedUserId,
+      initiatedAccounts
+    );
+    if (!redirectUrl) {
+      return null;
+    }
+    thirdPartyConnectAccountUrl = redirectUrl;
+    url = addUserIdToUrl(url, derivedUserId);
+  }
+  return transformComposioServerData(
+    composioMcpServer,
+    isAuthenticated,
+    url,
+    thirdPartyConnectAccountUrl
+  );
+}
+async function fetchComposioServers(tenantId, projectId) {
+  const composioApiKey = process.env.COMPOSIO_API_KEY;
+  if (!composioApiKey) {
+    logger3.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");
+    return [];
+  }
+  try {
+    const composioMcpServers = await composioInstance.mcp.list({
+      limit: 100,
+      toolkits: [],
+      page: 1,
+      authConfigs: []
+    });
+    const userConnectedAccounts = await composioInstance.connectedAccounts.list({
+      userIds: [derivedUserId]
+    });
+    const activeAccounts = userConnectedAccounts?.items.filter(
+      (account) => account.status === "ACTIVE"
+    );
+    const initiatedAccounts = userConnectedAccounts?.items.filter(
+      (account) => account.status === "INITIATED"
+    );
+    const authenticatedAuthConfigIds = new Set(
+      activeAccounts?.map((account) => account.authConfig.id) ?? []
+    );
+    const transformedServers = await Promise.all(
+      composioMcpServers?.items.map(
+        (server) => transformComposioServer(
+          server,
+          authenticatedAuthConfigIds,
+          initiatedAccounts ?? [],
+          derivedUserId
+        )
+      )
+    );
+    const validServers = transformedServers.filter(
+      (server) => server !== null
+    );
+    return validServers;
+  } catch (error) {
+    logger3.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");
+    return null;
+  }
+  const derivedUserId = deriveComposioUserId(tenantId, projectId);
+  const composioInstance = getComposioInstance();
+  if (!composioInstance) {
+    logger3.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");
+      return null;
+    }
+    const composioMcpServer = await composioInstance.mcp.get(serverId);
+    const userConnectedAccounts = await composioInstance.connectedAccounts.list({
+      userIds: [derivedUserId]
+    });
+    const activeAccounts = userConnectedAccounts?.items.filter(
+      (account) => account.status === "ACTIVE"
+    );
+    const initiatedAccounts = userConnectedAccounts?.items.filter(
+      (account) => account.status === "INITIATED"
+    );
+    const authenticatedAuthConfigIds = new Set(
+      activeAccounts?.map((account) => account.authConfig.id) ?? []
+    );
+    const transformedServer = await transformComposioServer(
+      composioMcpServer,
+      authenticatedAuthConfigIds,
+      initiatedAccounts ?? [],
+      derivedUserId
+    );
+    return transformedServer;
+  } catch (error) {
+    logger3.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");
+async function isThirdPartyMCPServerAuthenticated(tenantId, projectId, mcpServerUrl) {
+  const composioServerId = extractComposioServerId(mcpServerUrl);
+  if (composioServerId) {
+    logger4.debug({ mcpServerUrl }, "Detected Composio MCP server, checking auth status");
+    return isComposioMCPServerAuthenticated(tenantId, projectId, mcpServerUrl);
+  }
+  logger4.info({ mcpServerUrl }, "Unknown third-party MCP server provider");
+  return false;
+}
+var logger5 = getLogger("tracer");
 var createNoOpSpan = () => ({
   setAttributes: () => ({}),
   recordException: () => ({}),
@@ -863,86 +1120,23 @@ var noopTracer = {
     return createNoOpSpan();
   }
 };
-function setSpanWithError(span, error, logger4, logMessage) {
+function setSpanWithError(span, error, logger6, logMessage) {
   span.recordException(error);
   span.setStatus({
     code: SpanStatusCode.ERROR,
     message: error.message
   });
-  if (logger4 && logMessage) {
-    logger4.error({ error: error.message }, logMessage);
+  if (logger6 && logMessage) {
+    logger6.error({ error: error.message }, logMessage);
   }
 }
 function getTracer(serviceName, serviceVersion) {
   try {
     return trace.getTracer(serviceName, serviceVersion);
   } catch (_error) {
-    logger3.debug({}, "OpenTelemetry tracer not available, using no-op tracer");
+    logger5.debug({}, "OpenTelemetry tracer not available, using no-op tracer");
     return noopTracer;
   }
 }
-var FILENAME = fileURLToPath(import.meta.url);
-var DIRNAME = dirname(FILENAME);
-async function createTestDatabaseClient(drizzleDir) {
-  const client = new PGlite();
-  const db = drizzle(client, { schema: schema_exports });
-  try {
-    if (!drizzleDir) {
-      drizzleDir = join(DIRNAME, "../../drizzle");
-    }
-    await migrate(db, { migrationsFolder: drizzleDir });
-  } catch (error) {
-    console.error("Failed to initialize test database schema:", error);
-    throw error;
-  }
-  return db;
-}
-async function cleanupTestDatabase(db) {
-  try {
-    const result = await db.execute(
-      sql.raw(`
-      SELECT tablename 
-      FROM pg_tables 
-      WHERE schemaname = 'public'
-    `)
-    );
-    const tables = result.rows.map((row) => row.tablename);
-    if (tables.length === 0) {
-      return;
-    }
-    const tableList = tables.map((t) => `"${t}"`).join(", ");
-    await db.execute(sql.raw(`TRUNCATE TABLE ${tableList} RESTART IDENTITY CASCADE`));
-  } catch (error) {
-    console.debug("Could not clean test database:", error);
-  }
-}
-async function closeTestDatabase(db) {
-  try {
-    if ("close" in db && typeof db.close === "function") {
-      db.close();
-    }
-  } catch (error) {
-    console.debug("Error closing database:", error);
-  }
-}
-async function createTestOrganization(db, tenantId) {
-  const slug = tenantId.replace(/^test-tenant-/, "").substring(0, 50);
-  await db.insert(organization).values({
-    id: tenantId,
-    name: `Test Organization ${tenantId}`,
-    slug,
-    createdAt: /* @__PURE__ */ new Date(),
-    metadata: null
-  }).onConflictDoNothing();
-}
-async function createTestProject(db, tenantId, projectId = "default") {
-  await createTestOrganization(db, tenantId);
-  await db.insert(projects).values({
-    tenantId,
-    id: projectId,
-    name: `Test Project ${projectId}`,
-    description: `Test project for ${projectId}`
-  }).onConflictDoNothing();
-}
 
-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, cleanupTestDatabase, closeTestDatabase, commonCreateErrorResponses, commonDeleteErrorResponses, commonGetErrorResponses, commonUpdateErrorResponses, createApiError, createExecutionContext, createTestDatabaseClient, createTestOrganization, createTestProject, env, errorResponseSchema, errorSchemaFactory, executionLimitsSharedDefaults, extractPublicId, generateApiKey, generateId, generateServiceToken, getConversationId, getCredentialStoreLookupKeyFromRetrievalParams, getRequestExecutionContext, getTracer, handleApiError, hashApiKey, isApiKeyExpired, loadEnvironmentFiles, 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, 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 };

package/dist/{chunk-W3L4M7FO.js → chunk-DN4B564Y.js}

@@ -1,8 +1,7 @@
-import { z } from 'zod';
 import pino from 'pino';
 import pinoPretty from 'pino-pretty';
 
-// src/utils/schema-conversion.ts
+// src/utils/logger.ts
 var PinoLogger = class {
   constructor(name, config = {}) {
     this.name = name;
@@ -128,22 +127,22 @@ var LoggerFactory = class {
    */
   getLogger(name) {
     if (this.loggers.has(name)) {
-      const logger3 = this.loggers.get(name);
-      if (!logger3) {
+      const logger2 = this.loggers.get(name);
+      if (!logger2) {
         throw new Error(`Logger '${name}' not found in cache`);
       }
-      return logger3;
+      return logger2;
     }
-    let logger2;
+    let logger;
     if (this.config.loggerFactory) {
-      logger2 = this.config.loggerFactory(name);
+      logger = this.config.loggerFactory(name);
     } else if (this.config.defaultLogger) {
-      logger2 = this.config.defaultLogger;
+      logger = this.config.defaultLogger;
     } else {
-      logger2 = new PinoLogger(name, this.config.pinoConfig);
+      logger = new PinoLogger(name, this.config.pinoConfig);
     }
-    this.loggers.set(name, logger2);
-    return logger2;
+    this.loggers.set(name, logger);
+    return logger;
   }
   /**
    * Reset factory to default state
@@ -158,64 +157,4 @@ function getLogger(name) {
   return loggerFactory.getLogger(name);
 }
 
-// src/utils/schema-conversion.ts
-var logger = getLogger("schema-conversion");
-function convertZodToJsonSchema(zodSchema) {
-  try {
-    const jsonSchema = z.toJSONSchema(zodSchema);
-    if (jsonSchema.$schema) {
-      delete jsonSchema.$schema;
-    }
-    return jsonSchema;
-  } catch (error) {
-    logger.error(
-      {
-        error: error instanceof Error ? error.message : "Unknown error",
-        stack: error instanceof Error ? error.stack : void 0
-      },
-      "Failed to convert Zod schema to JSON Schema"
-    );
-    throw new Error("Failed to convert Zod schema to JSON Schema");
-  }
-}
-var preview = (schema) => {
-  schema._def.inPreview = true;
-  return schema;
-};
-function convertZodToJsonSchemaWithPreview(zodSchema) {
-  const jsonSchema = convertZodToJsonSchema(zodSchema);
-  if (zodSchema instanceof z.ZodObject && jsonSchema.properties) {
-    const shape = zodSchema.shape;
-    for (const [key, fieldSchema] of Object.entries(shape)) {
-      if (fieldSchema?._def?.inPreview === true) {
-        jsonSchema.properties[key].inPreview = true;
-      }
-    }
-  }
-  return jsonSchema;
-}
-function isZodSchema(value) {
-  return value?._def?.type === "object";
-}
-function extractPreviewFields(schema) {
-  const previewFields = [];
-  if (schema instanceof z.ZodObject) {
-    const shape = schema.shape;
-    for (const [key, fieldSchema] of Object.entries(shape)) {
-      if (fieldSchema?._def?.inPreview === true) {
-        previewFields.push(key);
-      }
-    }
-    return previewFields;
-  }
-  if (schema?.type === "object" && schema.properties) {
-    for (const [key, prop] of Object.entries(schema.properties)) {
-      if (prop.inPreview === true) {
-        previewFields.push(key);
-      }
-    }
-  }
-  return previewFields;
-}
-
-export { PinoLogger, convertZodToJsonSchema, convertZodToJsonSchemaWithPreview, extractPreviewFields, getLogger, isZodSchema, loggerFactory, preview };
+export { PinoLogger, getLogger, loggerFactory };