@inkeep/agents-core 0.0.0-dev-20251010175818 → 0.0.0-dev-20251010180500

package/dist/index.js

@@ -1,15 +1,15 @@
 export { ACTIVITY_NAMES, ACTIVITY_STATUS, ACTIVITY_TYPES, AGENT_IDS, AGGREGATE_OPERATORS, AI_OPERATIONS, AI_TOOL_TYPES, DATA_SOURCES, DATA_TYPES, DELEGATION_FROM_SUB_AGENT_ID, DELEGATION_ID, DELEGATION_TO_SUB_AGENT_ID, FIELD_TYPES, OPERATORS, ORDER_DIRECTIONS, PANEL_TYPES, QUERY_DEFAULTS, QUERY_EXPRESSIONS, QUERY_FIELD_CONFIGS, QUERY_TYPES, REDUCE_OPERATIONS, SPAN_KEYS, SPAN_NAMES, TOOL_NAMES, TRANSFER_FROM_SUB_AGENT_ID, TRANSFER_TO_SUB_AGENT_ID, UNKNOWN_VALUE } from './chunk-TCLX6C3C.js';
 export { TaskState } from './chunk-H2F72PDA.js';
-import { getLogger, convertZodToJsonSchema } from './chunk-R2EERZSW.js';
-export { PinoLogger, convertZodToJsonSchema, convertZodToJsonSchemaWithPreview, extractPreviewFields, getLogger, isZodSchema, loggerFactory, preview } from './chunk-R2EERZSW.js';
-import { validateAndTypeGraphData, validateGraphStructure, isInternalAgent, isExternalAgent } from './chunk-2TJ2L67D.js';
-export { A2AMessageMetadataSchema, DataOperationDetailsSchema, DataOperationEventSchema, DelegationReturnedDataSchema, DelegationSentDataSchema, TransferDataSchema, generateIdFromName, isExternalAgent, isInternalAgent, isValidResourceId, validateAgentRelationships, validateAndTypeGraphData, validateArtifactComponentReferences, validateDataComponentReferences, validateGraphStructure, validateToolReferences } from './chunk-2TJ2L67D.js';
-import { ContextConfigApiUpdateSchema, validatePropsAsJsonSchema } from './chunk-NEJ3QDK6.js';
-export { AgentGraphApiInsertSchema, AgentGraphApiSelectSchema, AgentGraphApiUpdateSchema, AgentGraphInsertSchema, AgentGraphSelectSchema, AgentGraphUpdateSchema, AllAgentSchema, ApiKeyApiCreationResponseSchema, ApiKeyApiInsertSchema, ApiKeyApiSelectSchema, ApiKeyApiUpdateSchema, ApiKeyInsertSchema, ApiKeySelectSchema, ApiKeyUpdateSchema, ArtifactComponentApiInsertSchema, ArtifactComponentApiSelectSchema, ArtifactComponentApiUpdateSchema, ArtifactComponentInsertSchema, ArtifactComponentSelectSchema, ArtifactComponentUpdateSchema, CanUseItemSchema, ContextCacheApiInsertSchema, ContextCacheApiSelectSchema, ContextCacheApiUpdateSchema, ContextCacheInsertSchema, ContextCacheSelectSchema, ContextCacheUpdateSchema, ContextConfigApiInsertSchema, ContextConfigApiSelectSchema, ContextConfigApiUpdateSchema, ContextConfigInsertSchema, ContextConfigSelectSchema, ContextConfigUpdateSchema, ConversationApiInsertSchema, ConversationApiSelectSchema, ConversationApiUpdateSchema, ConversationInsertSchema, ConversationSelectSchema, ConversationUpdateSchema, CredentialReferenceApiInsertSchema, CredentialReferenceApiSelectSchema, CredentialReferenceApiUpdateSchema, CredentialReferenceInsertSchema, CredentialReferenceSelectSchema, CredentialReferenceUpdateSchema, DataComponentApiInsertSchema, DataComponentApiSelectSchema, DataComponentApiUpdateSchema, DataComponentBaseSchema, DataComponentInsertSchema, DataComponentSelectSchema, DataComponentUpdateSchema, ErrorResponseSchema, ExistsResponseSchema, ExternalAgentApiInsertSchema, ExternalAgentApiSelectSchema, ExternalAgentApiUpdateSchema, ExternalAgentInsertSchema, ExternalAgentSelectSchema, ExternalAgentUpdateSchema, ExternalSubAgentRelationApiInsertSchema, ExternalSubAgentRelationInsertSchema, FetchConfigSchema, FetchDefinitionSchema, FullGraphAgentInsertSchema, FullProjectDefinitionSchema, FunctionApiInsertSchema, FunctionApiSelectSchema, FunctionApiUpdateSchema, FunctionInsertSchema, FunctionSelectSchema, FunctionToolConfigSchema, FunctionUpdateSchema, GraphStopWhenSchema, GraphWithinContextOfProjectSchema, HeadersScopeSchema, LedgerArtifactApiInsertSchema, LedgerArtifactApiSelectSchema, LedgerArtifactApiUpdateSchema, LedgerArtifactInsertSchema, LedgerArtifactSelectSchema, LedgerArtifactUpdateSchema, ListResponseSchema, MAX_ID_LENGTH, MCPToolConfigSchema, MIN_ID_LENGTH, McpToolDefinitionSchema, McpToolSchema, McpTransportConfigSchema, MessageApiInsertSchema, MessageApiSelectSchema, MessageApiUpdateSchema, MessageInsertSchema, MessageSelectSchema, MessageUpdateSchema, ModelSchema, ModelSettingsSchema, PaginationQueryParamsSchema, PaginationSchema, ProjectApiInsertSchema, ProjectApiSelectSchema, ProjectApiUpdateSchema, ProjectInsertSchema, ProjectModelSchema, ProjectSelectSchema, ProjectUpdateSchema, RemovedResponseSchema, SandboxConfigSchema, SingleResponseSchema, StatusComponentSchema, StatusUpdateSchema, StopWhenSchema, SubAgentApiInsertSchema, SubAgentApiSelectSchema, SubAgentApiUpdateSchema, SubAgentArtifactComponentApiInsertSchema, SubAgentArtifactComponentApiSelectSchema, SubAgentArtifactComponentApiUpdateSchema, SubAgentArtifactComponentInsertSchema, SubAgentArtifactComponentSelectSchema, SubAgentArtifactComponentUpdateSchema, SubAgentDataComponentApiInsertSchema, SubAgentDataComponentApiSelectSchema, SubAgentDataComponentApiUpdateSchema, SubAgentDataComponentInsertSchema, SubAgentDataComponentSelectSchema, SubAgentDataComponentUpdateSchema, SubAgentInsertSchema, SubAgentRelationApiInsertSchema, SubAgentRelationApiSelectSchema, SubAgentRelationApiUpdateSchema, SubAgentRelationInsertSchema, SubAgentRelationQuerySchema, SubAgentRelationSelectSchema, SubAgentRelationUpdateSchema, SubAgentSelectSchema, SubAgentStopWhenSchema, SubAgentToolRelationApiInsertSchema, SubAgentToolRelationApiSelectSchema, SubAgentToolRelationApiUpdateSchema, SubAgentToolRelationInsertSchema, SubAgentToolRelationSelectSchema, SubAgentToolRelationUpdateSchema, SubAgentUpdateSchema, TaskApiInsertSchema, TaskApiSelectSchema, TaskApiUpdateSchema, TaskInsertSchema, TaskRelationApiInsertSchema, TaskRelationApiSelectSchema, TaskRelationApiUpdateSchema, TaskRelationInsertSchema, TaskRelationSelectSchema, TaskRelationUpdateSchema, TaskSelectSchema, TaskUpdateSchema, TenantIdParamsSchema, TenantParamsSchema, TenantProjectGraphIdParamsSchema, TenantProjectGraphParamsSchema, TenantProjectGraphSubAgentIdParamsSchema, TenantProjectGraphSubAgentParamsSchema, TenantProjectIdParamsSchema, TenantProjectParamsSchema, ToolApiInsertSchema, ToolApiSelectSchema, ToolApiUpdateSchema, ToolInsertSchema, ToolSelectSchema, ToolStatusSchema, ToolUpdateSchema, URL_SAFE_ID_PATTERN, resourceIdSchema, validatePropsAsJsonSchema } from './chunk-NEJ3QDK6.js';
-import { schema_exports, contextConfigs, externalAgents, functions, subAgentRelations, subAgents, subAgentToolRelations, tools, credentialReferences, agentGraph, subAgentDataComponents, subAgentArtifactComponents, dataComponents, artifactComponents, projects, apiKeys, contextCache, conversations, messages, ledgerArtifacts, tasks, taskRelations } from './chunk-5LRSB445.js';
-export { agentGraph, agentGraphRelations, agentToolRelationsRelations, apiKeys, apiKeysRelations, artifactComponents, artifactComponentsRelations, contextCache, contextCacheRelations, contextConfigs, contextConfigsRelations, conversations, conversationsRelations, credentialReferences, credentialReferencesRelations, dataComponents, dataComponentsRelations, externalAgents, externalAgentsRelations, functions, functionsRelations, ledgerArtifacts, ledgerArtifactsRelations, messages, messagesRelations, projects, projectsRelations, subAgentArtifactComponents, subAgentArtifactComponentsRelations, subAgentDataComponents, subAgentDataComponentsRelations, subAgentRelations, subAgentRelationsRelations, subAgentToolRelations, subAgents, subAgentsRelations, taskRelations, taskRelationsRelations, tasks, tasksRelations, tools, toolsRelations } from './chunk-5LRSB445.js';
+import { validateAndTypeGraphData, validateGraphStructure, isInternalAgent, isExternalAgent } from './chunk-JTHQYGCX.js';
+export { A2AMessageMetadataSchema, DataOperationDetailsSchema, DataOperationEventSchema, DelegationReturnedDataSchema, DelegationSentDataSchema, TransferDataSchema, generateIdFromName, isExternalAgent, isInternalAgent, isValidResourceId, validateAgentRelationships, validateAndTypeGraphData, validateArtifactComponentReferences, validateDataComponentReferences, validateGraphStructure, validateToolReferences } from './chunk-JTHQYGCX.js';
+import { ContextConfigApiUpdateSchema, validatePropsAsJsonSchema } from './chunk-E4SFK6AI.js';
+export { AgentGraphApiInsertSchema, AgentGraphApiSelectSchema, AgentGraphApiUpdateSchema, AgentGraphInsertSchema, AgentGraphSelectSchema, AgentGraphUpdateSchema, AllAgentSchema, ApiKeyApiCreationResponseSchema, ApiKeyApiInsertSchema, ApiKeyApiSelectSchema, ApiKeyApiUpdateSchema, ApiKeyInsertSchema, ApiKeySelectSchema, ApiKeyUpdateSchema, ArtifactComponentApiInsertSchema, ArtifactComponentApiSelectSchema, ArtifactComponentApiUpdateSchema, ArtifactComponentInsertSchema, ArtifactComponentSelectSchema, ArtifactComponentUpdateSchema, CanUseItemSchema, ContextCacheApiInsertSchema, ContextCacheApiSelectSchema, ContextCacheApiUpdateSchema, ContextCacheInsertSchema, ContextCacheSelectSchema, ContextCacheUpdateSchema, ContextConfigApiInsertSchema, ContextConfigApiSelectSchema, ContextConfigApiUpdateSchema, ContextConfigInsertSchema, ContextConfigSelectSchema, ContextConfigUpdateSchema, ConversationApiInsertSchema, ConversationApiSelectSchema, ConversationApiUpdateSchema, ConversationInsertSchema, ConversationSelectSchema, ConversationUpdateSchema, CredentialReferenceApiInsertSchema, CredentialReferenceApiSelectSchema, CredentialReferenceApiUpdateSchema, CredentialReferenceInsertSchema, CredentialReferenceSelectSchema, CredentialReferenceUpdateSchema, DataComponentApiInsertSchema, DataComponentApiSelectSchema, DataComponentApiUpdateSchema, DataComponentBaseSchema, DataComponentInsertSchema, DataComponentSelectSchema, DataComponentUpdateSchema, ErrorResponseSchema, ExistsResponseSchema, ExternalAgentApiInsertSchema, ExternalAgentApiSelectSchema, ExternalAgentApiUpdateSchema, ExternalAgentInsertSchema, ExternalAgentSelectSchema, ExternalAgentUpdateSchema, ExternalSubAgentRelationApiInsertSchema, ExternalSubAgentRelationInsertSchema, FetchConfigSchema, FetchDefinitionSchema, FullGraphAgentInsertSchema, FullGraphDefinitionSchema, FullProjectDefinitionSchema, FunctionApiInsertSchema, FunctionApiSelectSchema, FunctionApiUpdateSchema, FunctionInsertSchema, FunctionSelectSchema, FunctionToolApiInsertSchema, FunctionToolApiSelectSchema, FunctionToolApiUpdateSchema, FunctionToolConfigSchema, FunctionToolInsertSchema, FunctionToolSelectSchema, FunctionToolUpdateSchema, FunctionUpdateSchema, GraphStopWhenSchema, GraphWithinContextOfProjectSchema, HeadersScopeSchema, LedgerArtifactApiInsertSchema, LedgerArtifactApiSelectSchema, LedgerArtifactApiUpdateSchema, LedgerArtifactInsertSchema, LedgerArtifactSelectSchema, LedgerArtifactUpdateSchema, ListResponseSchema, MAX_ID_LENGTH, MCPToolConfigSchema, MIN_ID_LENGTH, McpToolDefinitionSchema, McpToolSchema, McpTransportConfigSchema, MessageApiInsertSchema, MessageApiSelectSchema, MessageApiUpdateSchema, MessageInsertSchema, MessageSelectSchema, MessageUpdateSchema, ModelSchema, ModelSettingsSchema, PaginationQueryParamsSchema, PaginationSchema, ProjectApiInsertSchema, ProjectApiSelectSchema, ProjectApiUpdateSchema, ProjectInsertSchema, ProjectModelSchema, ProjectSelectSchema, ProjectUpdateSchema, RemovedResponseSchema, SandboxConfigSchema, SingleResponseSchema, StatusComponentSchema, StatusUpdateSchema, StopWhenSchema, SubAgentApiInsertSchema, SubAgentApiSelectSchema, SubAgentApiUpdateSchema, SubAgentArtifactComponentApiInsertSchema, SubAgentArtifactComponentApiSelectSchema, SubAgentArtifactComponentApiUpdateSchema, SubAgentArtifactComponentInsertSchema, SubAgentArtifactComponentSelectSchema, SubAgentArtifactComponentUpdateSchema, SubAgentDataComponentApiInsertSchema, SubAgentDataComponentApiSelectSchema, SubAgentDataComponentApiUpdateSchema, SubAgentDataComponentInsertSchema, SubAgentDataComponentSelectSchema, SubAgentDataComponentUpdateSchema, SubAgentInsertSchema, SubAgentRelationApiInsertSchema, SubAgentRelationApiSelectSchema, SubAgentRelationApiUpdateSchema, SubAgentRelationInsertSchema, SubAgentRelationQuerySchema, SubAgentRelationSelectSchema, SubAgentRelationUpdateSchema, SubAgentSelectSchema, SubAgentStopWhenSchema, SubAgentToolRelationApiInsertSchema, SubAgentToolRelationApiSelectSchema, SubAgentToolRelationApiUpdateSchema, SubAgentToolRelationInsertSchema, SubAgentToolRelationSelectSchema, SubAgentToolRelationUpdateSchema, SubAgentUpdateSchema, TaskApiInsertSchema, TaskApiSelectSchema, TaskApiUpdateSchema, TaskInsertSchema, TaskRelationApiInsertSchema, TaskRelationApiSelectSchema, TaskRelationApiUpdateSchema, TaskRelationInsertSchema, TaskRelationSelectSchema, TaskRelationUpdateSchema, TaskSelectSchema, TaskUpdateSchema, TenantIdParamsSchema, TenantParamsSchema, TenantProjectGraphIdParamsSchema, TenantProjectGraphParamsSchema, TenantProjectGraphSubAgentIdParamsSchema, TenantProjectGraphSubAgentParamsSchema, TenantProjectIdParamsSchema, TenantProjectParamsSchema, ToolApiInsertSchema, ToolApiSelectSchema, ToolApiUpdateSchema, ToolInsertSchema, ToolSelectSchema, ToolStatusSchema, ToolUpdateSchema, URL_SAFE_ID_PATTERN, resourceIdSchema, validatePropsAsJsonSchema } from './chunk-E4SFK6AI.js';
+import { schema_exports, contextConfigs, externalAgents, functions, functionTools, agentFunctionToolRelations, subAgentRelations, subAgents, subAgentToolRelations, tools, credentialReferences, agentGraph, subAgentDataComponents, subAgentArtifactComponents, dataComponents, artifactComponents, projects, apiKeys, contextCache, conversations, messages, ledgerArtifacts, tasks, taskRelations } from './chunk-ID4CFGVF.js';
+export { agentFunctionToolRelations, agentFunctionToolRelationsRelations, agentGraph, agentGraphRelations, agentToolRelationsRelations, apiKeys, apiKeysRelations, artifactComponents, artifactComponentsRelations, contextCache, contextCacheRelations, contextConfigs, contextConfigsRelations, conversations, conversationsRelations, credentialReferences, credentialReferencesRelations, dataComponents, dataComponentsRelations, externalAgents, externalAgentsRelations, functionTools, functionToolsRelations, functions, functionsRelations, ledgerArtifacts, ledgerArtifactsRelations, messages, messagesRelations, projects, projectsRelations, subAgentArtifactComponents, subAgentArtifactComponentsRelations, subAgentDataComponents, subAgentDataComponentsRelations, subAgentRelations, subAgentRelationsRelations, subAgentToolRelations, subAgents, subAgentsRelations, taskRelations, taskRelationsRelations, tasks, tasksRelations, tools, toolsRelations } from './chunk-ID4CFGVF.js';
 import { CredentialStoreType, MCPServerType, MCPTransportType } from './chunk-YFHT5M2R.js';
 export { CredentialStoreType, MCPServerType, MCPTransportType, TOOL_STATUS_VALUES, VALID_RELATION_TYPES } from './chunk-YFHT5M2R.js';
+import { getLogger, convertZodToJsonSchema } from './chunk-R2EERZSW.js';
+export { PinoLogger, convertZodToJsonSchema, convertZodToJsonSchemaWithPreview, extractPreviewFields, getLogger, isZodSchema, loggerFactory, preview } from './chunk-R2EERZSW.js';
 import { __publicField } from './chunk-MKBO26DX.js';
 import { z as z$1 } from 'zod';
 import { customAlphabet, nanoid } from 'nanoid';
@@ -556,11 +556,11 @@ function getCredentialStoreLookupKeyFromRetrievalParams({
 
 // src/credential-stuffer/CredentialStuffer.ts
 var CredentialStuffer = class {
-  constructor(credentialStoreRegistry, contextResolver, logger12) {
+  constructor(credentialStoreRegistry, contextResolver, logger13) {
     this.credentialStoreRegistry = credentialStoreRegistry;
     this.contextResolver = contextResolver;
     __publicField(this, "logger");
-    this.logger = logger12 || getLogger("credential-stuffer");
+    this.logger = logger13 || getLogger("credential-stuffer");
   }
   /**
    * Retrieve credentials from credential store registry
@@ -1114,6 +1114,212 @@ var deleteFunction = (db) => async (params) => {
     )
   );
 };
+var logger3 = getLogger("functionTools");
+var getFunctionToolById = (db) => async (params) => {
+  const result = await db.select().from(functionTools).where(
+    and(
+      eq(functionTools.tenantId, params.scopes.tenantId),
+      eq(functionTools.projectId, params.scopes.projectId),
+      eq(functionTools.graphId, params.scopes.graphId),
+      eq(functionTools.id, params.functionToolId)
+    )
+  ).limit(1);
+  return result[0] ?? null;
+};
+var listFunctionTools = (db) => async (params) => {
+  const page = params.pagination?.page || 1;
+  const limit = Math.min(params.pagination?.limit || 10, 100);
+  const offset = (page - 1) * limit;
+  const whereClause = and(
+    eq(functionTools.tenantId, params.scopes.tenantId),
+    eq(functionTools.projectId, params.scopes.projectId),
+    eq(functionTools.graphId, params.scopes.graphId)
+  );
+  const [functionToolsDbResults, totalResult] = await Promise.all([
+    db.select().from(functionTools).where(whereClause).limit(limit).offset(offset).orderBy(desc(functionTools.createdAt)),
+    db.select({ count: count() }).from(functionTools).where(whereClause)
+  ]);
+  const total = totalResult[0]?.count || 0;
+  const pages = Math.ceil(total / limit);
+  return {
+    data: functionToolsDbResults,
+    pagination: { page, limit, total, pages }
+  };
+};
+var createFunctionTool = (db) => async (params) => {
+  const { data, scopes } = params;
+  const { tenantId, projectId, graphId } = scopes;
+  const [created] = await db.insert(functionTools).values({
+    tenantId,
+    projectId,
+    graphId,
+    id: data.id,
+    name: data.name,
+    description: data.description,
+    functionId: data.functionId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }).returning();
+  return created;
+};
+var updateFunctionTool = (db) => async (params) => {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const [updated] = await db.update(functionTools).set({
+    ...params.data,
+    updatedAt: now
+  }).where(
+    and(
+      eq(functionTools.tenantId, params.scopes.tenantId),
+      eq(functionTools.projectId, params.scopes.projectId),
+      eq(functionTools.graphId, params.scopes.graphId),
+      eq(functionTools.id, params.functionToolId)
+    )
+  ).returning();
+  return updated ?? null;
+};
+var deleteFunctionTool = (db) => async (params) => {
+  const [deleted] = await db.delete(functionTools).where(
+    and(
+      eq(functionTools.tenantId, params.scopes.tenantId),
+      eq(functionTools.projectId, params.scopes.projectId),
+      eq(functionTools.graphId, params.scopes.graphId),
+      eq(functionTools.id, params.functionToolId)
+    )
+  ).returning();
+  return !!deleted;
+};
+var upsertFunctionTool = (db) => async (params) => {
+  const scopes = {
+    tenantId: params.scopes.tenantId,
+    projectId: params.scopes.projectId,
+    graphId: params.scopes.graphId
+  };
+  const existing = await getFunctionToolById(db)({
+    scopes,
+    functionToolId: params.data.id
+  });
+  if (existing) {
+    return await updateFunctionTool(db)({
+      scopes,
+      functionToolId: params.data.id,
+      data: {
+        name: params.data.name,
+        description: params.data.description,
+        functionId: params.data.functionId
+      }
+    });
+  } else {
+    return await createFunctionTool(db)({
+      data: params.data,
+      scopes
+    });
+  }
+};
+var getFunctionToolsForSubAgent = (db) => {
+  return async (params) => {
+    const { scopes, subAgentId } = params;
+    const { tenantId, projectId, graphId } = scopes;
+    try {
+      const functionToolsList = await listFunctionTools(db)({
+        scopes: { tenantId, projectId, graphId },
+        pagination: { page: 1, limit: 1e3 }
+      });
+      const relations = await db.select().from(agentFunctionToolRelations).where(
+        and(
+          eq(agentFunctionToolRelations.tenantId, tenantId),
+          eq(agentFunctionToolRelations.projectId, projectId),
+          eq(agentFunctionToolRelations.graphId, graphId),
+          eq(agentFunctionToolRelations.subAgentId, subAgentId)
+        )
+      );
+      const relatedFunctionToolIds = new Set(relations.map((r) => r.functionToolId));
+      const agentFunctionTools = functionToolsList.data.filter(
+        (ft) => relatedFunctionToolIds.has(ft.id)
+      );
+      return {
+        data: agentFunctionTools,
+        pagination: functionToolsList.pagination
+      };
+    } catch (error) {
+      logger3.error(
+        { tenantId, projectId, graphId, subAgentId, error },
+        "Failed to get function tools for agent"
+      );
+      throw error;
+    }
+  };
+};
+var upsertSubAgentFunctionToolRelation = (db) => async (params) => {
+  if (params.relationId) {
+    return await updateSubAgentFunctionToolRelation(db)({
+      scopes: params.scopes,
+      relationId: params.relationId,
+      data: {
+        subAgentId: params.subAgentId,
+        functionToolId: params.functionToolId
+      }
+    });
+  }
+  return await addFunctionToolToSubAgent(db)(params);
+};
+var addFunctionToolToSubAgent = (db) => {
+  return async (params) => {
+    const { scopes, subAgentId, functionToolId } = params;
+    const { tenantId, projectId, graphId } = scopes;
+    try {
+      const relationId = nanoid();
+      await db.insert(agentFunctionToolRelations).values({
+        id: relationId,
+        tenantId,
+        projectId,
+        graphId,
+        subAgentId,
+        functionToolId
+      });
+      logger3.info(
+        { tenantId, projectId, graphId, subAgentId, functionToolId, relationId },
+        "Function tool added to agent"
+      );
+      return { id: relationId };
+    } catch (error) {
+      logger3.error(
+        { tenantId, projectId, graphId, subAgentId, functionToolId, error },
+        "Failed to add function tool to agent"
+      );
+      throw error;
+    }
+  };
+};
+var updateSubAgentFunctionToolRelation = (db) => {
+  return async (params) => {
+    const { scopes, relationId, data } = params;
+    const { tenantId, projectId, graphId } = scopes;
+    try {
+      await db.update(agentFunctionToolRelations).set({
+        subAgentId: data.subAgentId,
+        functionToolId: data.functionToolId
+      }).where(
+        and(
+          eq(agentFunctionToolRelations.id, relationId),
+          eq(agentFunctionToolRelations.tenantId, tenantId),
+          eq(agentFunctionToolRelations.projectId, projectId),
+          eq(agentFunctionToolRelations.graphId, graphId)
+        )
+      );
+      logger3.info(
+        { tenantId, projectId, graphId, relationId, data },
+        "Agent-function tool relation updated"
+      );
+      return { id: relationId };
+    } catch (error) {
+      logger3.error(
+        { tenantId, projectId, graphId, relationId, data, error },
+        "Failed to update agent-function tool relation"
+      );
+      throw error;
+    }
+  };
+};
 var getAgentRelationById = (db) => async (params) => {
   return db.query.subAgentRelations.findFirst({
     where: and(
@@ -1526,7 +1732,6 @@ var getToolsForAgent = (db) => async (params) => {
         name: tools.name,
         description: tools.description,
         config: tools.config,
-        functionId: tools.functionId,
         createdAt: tools.createdAt,
         updatedAt: tools.updatedAt,
         capabilities: tools.capabilities,
@@ -1772,7 +1977,7 @@ var getSubAgentsByIds = (db) => async (params) => {
   );
 };
 var scryptAsync = promisify(scrypt);
-var logger3 = getLogger("api-key");
+var logger4 = getLogger("api-key");
 var API_KEY_LENGTH = 32;
 var SALT_LENGTH = 32;
 var KEY_LENGTH = 64;
@@ -1809,7 +2014,7 @@ async function validateApiKey(key, storedHash) {
     const hashedBuffer = await scryptAsync(key, salt, KEY_LENGTH);
     return timingSafeEqual(storedHashBuffer, hashedBuffer);
   } catch (error) {
-    logger3.error({ error }, "Error validating API key");
+    logger4.error({ error }, "Error validating API key");
     return false;
   }
 }
@@ -1859,7 +2064,7 @@ var buildOAuthConfig = (metadata) => ({
   registrationUrl: metadata.registration_endpoint,
   supportsDynamicRegistration: !!metadata.registration_endpoint
 });
-var tryWellKnownEndpoints = async (baseUrl, logger12) => {
+var tryWellKnownEndpoints = async (baseUrl, logger13) => {
   const wellKnownUrls = getWellKnownUrls(baseUrl);
   for (const wellKnownUrl of wellKnownUrls) {
     try {
@@ -1867,21 +2072,21 @@ var tryWellKnownEndpoints = async (baseUrl, logger12) => {
       if (response.ok) {
         const metadata = await response.json();
         if (validateOAuthMetadata(metadata)) {
-          logger12?.debug({ baseUrl, wellKnownUrl }, "OAuth 2.1/PKCE support detected");
+          logger13?.debug({ baseUrl, wellKnownUrl }, "OAuth 2.1/PKCE support detected");
           return buildOAuthConfig(metadata);
         }
       }
     } catch (error) {
-      logger12?.debug({ wellKnownUrl, error }, "OAuth endpoint check failed");
+      logger13?.debug({ wellKnownUrl, error }, "OAuth endpoint check failed");
     }
   }
   return null;
 };
-var checkForOAuthEndpoints = async (serverUrl, logger12) => {
-  const config = await discoverOAuthEndpoints(serverUrl, logger12);
+var checkForOAuthEndpoints = async (serverUrl, logger13) => {
+  const config = await discoverOAuthEndpoints(serverUrl, logger13);
   return config !== null;
 };
-var discoverOAuthEndpoints = async (serverUrl, logger12) => {
+var discoverOAuthEndpoints = async (serverUrl, logger13) => {
   try {
     const response = await fetch(serverUrl, {
       method: "POST",
@@ -1897,7 +2102,7 @@ var discoverOAuthEndpoints = async (serverUrl, logger12) => {
           if (metadataResponse.ok) {
             const metadata = await metadataResponse.json();
             if (metadata.authorization_servers?.length > 0) {
-              return await tryWellKnownEndpoints(metadata.authorization_servers[0], logger12);
+              return await tryWellKnownEndpoints(metadata.authorization_servers[0], logger13);
             }
           }
         }
@@ -1907,25 +2112,25 @@ var discoverOAuthEndpoints = async (serverUrl, logger12) => {
   }
   const url = new URL(serverUrl);
   const baseUrl = `${url.protocol}//${url.host}`;
-  return await tryWellKnownEndpoints(baseUrl, logger12);
+  return await tryWellKnownEndpoints(baseUrl, logger13);
 };
 var detectAuthenticationRequired = async ({
   serverUrl,
   toolId,
   error,
-  logger: logger12
+  logger: logger13
 }) => {
   try {
-    const hasOAuthEndpoints = await checkForOAuthEndpoints(serverUrl, logger12);
+    const hasOAuthEndpoints = await checkForOAuthEndpoints(serverUrl, logger13);
     if (hasOAuthEndpoints) {
-      logger12?.info(
+      logger13?.info(
         { toolId, serverUrl },
         "OAuth 2.1/PKCE support confirmed via endpoint discovery"
       );
       return true;
     }
   } catch (discoveryError) {
-    logger12?.debug({ toolId, discoveryError }, "OAuth endpoint discovery failed");
+    logger13?.debug({ toolId, discoveryError }, "OAuth endpoint discovery failed");
   }
   try {
     const response = await fetch(serverUrl, {
@@ -1944,13 +2149,13 @@ var detectAuthenticationRequired = async ({
         const authLower = wwwAuth.toLowerCase();
         const hasActiveOAuthFlow = authLower.includes("authorization_uri") || authLower.includes("as_uri=") || authLower.includes("bearer") && (authLower.includes("scope=") || authLower.includes("error_uri="));
         if (hasActiveOAuthFlow) {
-          logger12?.info(
+          logger13?.info(
             { toolId, wwwAuth },
             "Active OAuth flow detected via WWW-Authenticate parameters"
           );
           return true;
         } else {
-          logger12?.debug(
+          logger13?.debug(
             { toolId, wwwAuth },
             "Bearer authentication detected - likely simple token auth, not OAuth"
           );
@@ -1958,9 +2163,9 @@ var detectAuthenticationRequired = async ({
       }
     }
   } catch (fetchError) {
-    logger12?.debug({ toolId, fetchError }, "Direct fetch authentication check failed");
+    logger13?.debug({ toolId, fetchError }, "Direct fetch authentication check failed");
   }
-  logger12?.debug(
+  logger13?.debug(
     { toolId, error: error.message },
     "No OAuth 2.1/PKCE authentication requirement detected"
   );
@@ -2420,7 +2625,7 @@ var McpClient = class {
     return results;
   }
 };
-var logger4 = getLogger("tracer");
+var logger5 = getLogger("tracer");
 var createNoOpSpan = () => ({
   setAttributes: () => ({}),
   recordException: () => ({}),
@@ -2449,21 +2654,21 @@ var noopTracer = {
     return createNoOpSpan();
   }
 };
-function setSpanWithError(span, error, logger12, logMessage) {
+function setSpanWithError(span, error, logger13, logMessage) {
   span.recordException(error);
   span.setStatus({
     code: SpanStatusCode.ERROR,
     message: error.message
   });
-  if (logger12 && logMessage) {
-    logger12.error({ error: error.message }, logMessage);
+  if (logger13 && logMessage) {
+    logger13.error({ error: error.message }, logMessage);
   }
 }
 function getTracer(serviceName, serviceVersion) {
   try {
     return trace.getTracer(serviceName, serviceVersion);
   } catch (_error) {
-    logger4.debug({}, "OpenTelemetry tracer not available, using no-op tracer");
+    logger5.debug({}, "OpenTelemetry tracer not available, using no-op tracer");
     return noopTracer;
   }
 }
@@ -2626,7 +2831,7 @@ var upsertCredentialReference = (db) => async (params) => {
 };
 
 // src/data-access/tools.ts
-var logger5 = getLogger("tools");
+var logger6 = getLogger("tools");
 function extractInputSchema(toolDef) {
   if (toolDef.inputSchema) {
     return toolDef.inputSchema;
@@ -2726,7 +2931,7 @@ var discoverToolsFromServer = async (tool2, dbClient, credentialStoreRegistry) =
     );
     return toolDefinitions;
   } catch (error) {
-    logger5.error({ toolId: tool2.id, error }, "Tool discovery failed");
+    logger6.error({ toolId: tool2.id, error }, "Tool discovery failed");
     throw error;
   }
 };
@@ -2735,8 +2940,6 @@ var dbResultToMcpTool = async (dbResult, dbClient, credentialStoreRegistry) => {
   if (dbResult.config.type !== "mcp") {
     return {
       ...rest,
-      functionId: rest.functionId || void 0,
-      // Convert null to undefined
       status: "unknown",
       availableTools: [],
       capabilities: capabilities || void 0,
@@ -2760,7 +2963,7 @@ var dbResultToMcpTool = async (dbResult, dbClient, credentialStoreRegistry) => {
       serverUrl: dbResult.config.mcp.server.url,
       toolId: dbResult.id,
       error,
-      logger: logger5
+      logger: logger6
     });
     status = toolNeedsAuth ? "needs_auth" : "unhealthy";
     lastErrorComputed = toolNeedsAuth ? "Authentication required - OAuth login needed" : error instanceof Error ? error.message : "Tool discovery failed";
@@ -2776,8 +2979,6 @@ var dbResultToMcpTool = async (dbResult, dbClient, credentialStoreRegistry) => {
   });
   return {
     ...rest,
-    functionId: rest.functionId || void 0,
-    // Convert null to undefined
     status,
     availableTools,
     capabilities: capabilities || void 0,
@@ -2880,7 +3081,7 @@ var removeToolFromAgent = (db) => async (params) => {
   ).returning();
   return deleted;
 };
-var upsertAgentToolRelation = (db) => async (params) => {
+var upsertSubAgentToolRelation = (db) => async (params) => {
   if (params.relationId) {
     return await updateAgentToolRelation(db)({
       scopes: params.scopes,
@@ -3154,6 +3355,33 @@ var getFullGraphDefinition = (db) => async ({
           eq(subAgentToolRelations.subAgentId, agent.id)
         )
       );
+      const agentFunctionTools = await db.select({
+        id: functionTools.id,
+        name: functionTools.name,
+        description: functionTools.description,
+        functionId: functionTools.functionId,
+        createdAt: functionTools.createdAt,
+        updatedAt: functionTools.updatedAt,
+        tenantId: functionTools.tenantId,
+        projectId: functionTools.projectId,
+        graphId: functionTools.graphId,
+        agentToolRelationId: agentFunctionToolRelations.id
+      }).from(agentFunctionToolRelations).innerJoin(
+        functionTools,
+        and(
+          eq(agentFunctionToolRelations.functionToolId, functionTools.id),
+          eq(agentFunctionToolRelations.tenantId, functionTools.tenantId),
+          eq(agentFunctionToolRelations.projectId, functionTools.projectId),
+          eq(agentFunctionToolRelations.graphId, functionTools.graphId)
+        )
+      ).where(
+        and(
+          eq(agentFunctionToolRelations.tenantId, tenantId),
+          eq(agentFunctionToolRelations.projectId, projectId),
+          eq(agentFunctionToolRelations.graphId, graphId),
+          eq(agentFunctionToolRelations.subAgentId, agent.id)
+        )
+      );
       const agentDataComponentRelations = await db.query.subAgentDataComponents.findMany({
         where: and(
           eq(subAgentDataComponents.tenantId, tenantId),
@@ -3170,12 +3398,21 @@ var getFullGraphDefinition = (db) => async ({
       const agentArtifactComponentIds = agentArtifactComponentRelations.map(
         (rel) => rel.artifactComponentId
       );
-      const canUse = subAgentTools.map((tool2) => ({
+      const mcpToolCanUse = subAgentTools.map((tool2) => ({
         agentToolRelationId: tool2.agentToolRelationId,
         toolId: tool2.id,
         toolSelection: tool2.selectedTools || null,
         headers: tool2.headers || null
       }));
+      const functionToolCanUse = agentFunctionTools.map((tool2) => ({
+        agentToolRelationId: tool2.agentToolRelationId,
+        toolId: tool2.id,
+        toolSelection: null,
+        // Function tools don't have tool selection
+        headers: null
+        // Function tools don't have headers
+      }));
+      const canUse = [...mcpToolCanUse, ...functionToolCanUse];
       return {
         id: agent.id,
         name: agent.name,
@@ -3364,16 +3601,29 @@ var getFullGraphDefinition = (db) => async ({
         name: tool2.name,
         description: tool2.description,
         config: tool2.config,
-        functionId: tool2.functionId,
         credentialReferenceId: tool2.credentialReferenceId,
         imageUrl: tool2.imageUrl
       };
     }
     result.tools = toolsObject;
+    const functionToolsList = await listFunctionTools(db)({
+      scopes: { tenantId, projectId, graphId },
+      pagination: { page: 1, limit: 1e3 }
+    });
+    const functionToolsObject = {};
+    for (const functionTool of functionToolsList.data) {
+      functionToolsObject[functionTool.id] = {
+        id: functionTool.id,
+        name: functionTool.name,
+        description: functionTool.description,
+        functionId: functionTool.functionId
+      };
+    }
+    result.functionTools = functionToolsObject;
     const functionIds = /* @__PURE__ */ new Set();
-    for (const tool2 of toolsList.data) {
-      if (tool2.functionId) {
-        functionIds.add(tool2.functionId);
+    for (const functionTool of functionToolsList.data) {
+      if (functionTool.functionId) {
+        functionIds.add(functionTool.functionId);
       }
     }
     if (functionIds.size > 0) {
@@ -4393,18 +4643,18 @@ var defaultLogger = {
   error: () => {
   }
 };
-async function applyExecutionLimitsInheritance(db, logger12, scopes, graphData) {
+async function applyExecutionLimitsInheritance(db, logger13, scopes, graphData) {
   const { tenantId, projectId } = scopes;
   try {
     const project = await db.query.projects.findFirst({
       where: and(eq(projects.tenantId, tenantId), eq(projects.id, projectId))
     });
     if (!project?.stopWhen) {
-      logger12.info({ projectId }, "No project stopWhen configuration found");
+      logger13.info({ projectId }, "No project stopWhen configuration found");
       return;
     }
     const projectStopWhen = project.stopWhen;
-    logger12.info(
+    logger13.info(
       {
         projectId,
         projectStopWhen
@@ -4416,7 +4666,7 @@ async function applyExecutionLimitsInheritance(db, logger12, scopes, graphData)
     }
     if (graphData.stopWhen.transferCountIs === void 0 && projectStopWhen?.transferCountIs !== void 0) {
       graphData.stopWhen.transferCountIs = projectStopWhen.transferCountIs;
-      logger12.info(
+      logger13.info(
         {
           graphId: graphData.id,
           inheritedValue: projectStopWhen.transferCountIs
@@ -4426,7 +4676,7 @@ async function applyExecutionLimitsInheritance(db, logger12, scopes, graphData)
     }
     if (graphData.stopWhen.transferCountIs === void 0) {
       graphData.stopWhen.transferCountIs = 10;
-      logger12.info(
+      logger13.info(
         {
           graphId: graphData.id,
           defaultValue: 10
@@ -4435,7 +4685,7 @@ async function applyExecutionLimitsInheritance(db, logger12, scopes, graphData)
       );
     }
     if (projectStopWhen?.stepCountIs !== void 0) {
-      logger12.info(
+      logger13.info(
         {
           projectId,
           stepCountIs: projectStopWhen.stepCountIs
@@ -4450,7 +4700,7 @@ async function applyExecutionLimitsInheritance(db, logger12, scopes, graphData)
           }
           if (agent.stopWhen.stepCountIs === void 0) {
             agent.stopWhen.stepCountIs = projectStopWhen.stepCountIs;
-            logger12.info(
+            logger13.info(
               {
                 subAgentId,
                 inheritedValue: projectStopWhen.stepCountIs
@@ -4462,7 +4712,7 @@ async function applyExecutionLimitsInheritance(db, logger12, scopes, graphData)
       }
     }
   } catch (error) {
-    logger12.error(
+    logger13.error(
       {
         projectId,
         error: error instanceof Error ? error.message : "Unknown error"
@@ -4471,21 +4721,21 @@ async function applyExecutionLimitsInheritance(db, logger12, scopes, graphData)
     );
   }
 }
-var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes, graphData) => {
+var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes, graphData) => {
   const { tenantId, projectId } = scopes;
   const typed = validateAndTypeGraphData(graphData);
   validateGraphStructure(typed);
-  await applyExecutionLimitsInheritance(db, logger12, { tenantId, projectId }, typed);
+  await applyExecutionLimitsInheritance(db, logger13, { tenantId, projectId }, typed);
   try {
-    logger12.info(
+    logger13.info(
       {},
       "CredentialReferences are project-scoped - skipping credential reference creation in graph"
     );
-    logger12.info({}, "Tools are project-scoped - skipping tool creation in graph");
+    logger13.info({}, "MCP Tools are project-scoped - skipping tool creation in graph");
     let finalGraphId;
     try {
       const graphId = typed.id || nanoid();
-      logger12.info({ graphId }, "Creating agent graph metadata");
+      logger13.info({ graphId }, "Creating agent graph metadata");
       const agentGraph2 = await upsertAgentGraph(db)({
         data: {
           id: graphId,
@@ -4503,15 +4753,15 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
         }
       });
       finalGraphId = agentGraph2.id;
-      logger12.info({ graphId: finalGraphId }, "Agent graph metadata created successfully");
+      logger13.info({ graphId: finalGraphId }, "Agent graph metadata created successfully");
     } catch (error) {
-      logger12.error({ graphId: typed.id, error }, "Failed to create/update graph metadata");
+      logger13.error({ graphId: typed.id, error }, "Failed to create/update graph metadata");
       throw error;
     }
     let contextConfigId;
     if (typed.contextConfig) {
       try {
-        logger12.info({ contextConfigId: typed.contextConfig.id }, "Processing context config");
+        logger13.info({ contextConfigId: typed.contextConfig.id }, "Processing context config");
         const contextConfig2 = await upsertContextConfig(db)({
           data: {
             ...typed.contextConfig,
@@ -4521,9 +4771,9 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
           }
         });
         contextConfigId = contextConfig2.id;
-        logger12.info({ contextConfigId }, "Context config processed successfully");
+        logger13.info({ contextConfigId }, "Context config processed successfully");
       } catch (error) {
-        logger12.error(
+        logger13.error(
           { contextConfigId: typed.contextConfig.id, error },
           "Failed to create/update context config"
         );
@@ -4532,7 +4782,7 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
     }
     if (contextConfigId) {
       try {
-        logger12.info(
+        logger13.info(
           { graphId: finalGraphId, contextConfigId },
           "Updating graph with contextConfigId"
         );
@@ -4551,30 +4801,112 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
             stopWhen: typed.stopWhen
           }
         });
-        logger12.info(
+        logger13.info(
           { graphId: finalGraphId, contextConfigId },
           "Graph updated with contextConfigId successfully"
         );
       } catch (error) {
-        logger12.error(
+        logger13.error(
           { graphId: finalGraphId, contextConfigId, error },
           "Failed to update graph with contextConfigId"
         );
         throw error;
       }
     }
-    logger12.info(
+    logger13.info(
       {},
       "DataComponents are project-scoped - skipping dataComponent creation in graph"
     );
-    logger12.info(
+    logger13.info(
       {},
       "ArtifactComponents are project-scoped - skipping artifactComponent creation in graph"
     );
+    if (typed.functions && Object.keys(typed.functions).length > 0) {
+      logger13.info(
+        {
+          graphId: finalGraphId,
+          functionCount: Object.keys(typed.functions).length
+        },
+        "Creating functions for graph"
+      );
+      const functionPromises = Object.entries(typed.functions).map(
+        async ([functionId, functionData]) => {
+          try {
+            logger13.info({ graphId: finalGraphId, functionId }, "Creating function for graph");
+            await upsertFunction(db)({
+              data: {
+                ...functionData,
+                id: functionId
+              },
+              scopes: { tenantId, projectId }
+            });
+            logger13.info({ graphId: finalGraphId, functionId }, "Function created successfully");
+          } catch (error) {
+            logger13.error(
+              { graphId: finalGraphId, functionId, error },
+              "Failed to create function for graph"
+            );
+            throw error;
+          }
+        }
+      );
+      await Promise.all(functionPromises);
+      logger13.info(
+        {
+          graphId: finalGraphId,
+          functionCount: Object.keys(typed.functions).length
+        },
+        "All functions created successfully"
+      );
+    }
+    if (typed.functionTools && Object.keys(typed.functionTools).length > 0) {
+      logger13.info(
+        {
+          graphId: finalGraphId,
+          functionToolCount: Object.keys(typed.functionTools).length
+        },
+        "Creating function tools for graph"
+      );
+      const functionToolPromises = Object.entries(typed.functionTools).map(
+        async ([functionToolId, functionToolData]) => {
+          try {
+            logger13.info(
+              { graphId: finalGraphId, functionToolId },
+              "Creating function tool in graph"
+            );
+            await upsertFunctionTool(db)({
+              data: {
+                ...functionToolData,
+                id: functionToolId
+              },
+              scopes: { tenantId, projectId, graphId: finalGraphId }
+            });
+            logger13.info(
+              { graphId: finalGraphId, functionToolId },
+              "Function tool created successfully"
+            );
+          } catch (error) {
+            logger13.error(
+              { graphId: finalGraphId, functionToolId, error },
+              "Failed to create function tool in graph"
+            );
+            throw error;
+          }
+        }
+      );
+      await Promise.all(functionToolPromises);
+      logger13.info(
+        {
+          graphId: finalGraphId,
+          functionToolCount: Object.keys(typed.functionTools).length
+        },
+        "All function tools created successfully"
+      );
+    }
     const internalAgentPromises = Object.entries(typed.subAgents).filter(([_, agentData]) => isInternalAgent(agentData)).map(async ([subAgentId, agentData]) => {
       const internalAgent = agentData;
       try {
-        logger12.info({ subAgentId }, "Processing internal agent");
+        logger13.info({ subAgentId }, "Processing internal agent");
         await upsertSubAgent(db)({
           data: {
             id: subAgentId,
@@ -4589,9 +4921,9 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
             stopWhen: internalAgent.stopWhen
           }
         });
-        logger12.info({ subAgentId }, "Internal agent processed successfully");
+        logger13.info({ subAgentId }, "Internal agent processed successfully");
       } catch (error) {
-        logger12.error({ subAgentId, error }, "Failed to create/update internal agent");
+        logger13.error({ subAgentId, error }, "Failed to create/update internal agent");
         throw error;
       }
     });
@@ -4599,11 +4931,11 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
     const internalAgentCount = Object.entries(typed.subAgents).filter(
       ([_, agentData]) => isInternalAgent(agentData)
     ).length;
-    logger12.info({ internalAgentCount }, "All internal agents created/updated successfully");
+    logger13.info({ internalAgentCount }, "All internal agents created/updated successfully");
     const externalAgentPromises = Object.entries(typed.subAgents).filter(([_, agentData]) => isExternalAgent(agentData)).map(async ([subAgentId, agentData]) => {
       const externalAgent = agentData;
       try {
-        logger12.info({ subAgentId }, "Processing external agent");
+        logger13.info({ subAgentId }, "Processing external agent");
         await upsertExternalAgent(db)({
           data: {
             id: subAgentId,
@@ -4617,9 +4949,9 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
             headers: externalAgent.headers || void 0
           }
         });
-        logger12.info({ subAgentId }, "External agent processed successfully");
+        logger13.info({ subAgentId }, "External agent processed successfully");
       } catch (error) {
-        logger12.error({ subAgentId, error }, "Failed to create/update external agent");
+        logger13.error({ subAgentId, error }, "Failed to create/update external agent");
         throw error;
       }
     });
@@ -4627,10 +4959,10 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
     const externalAgentCount = Object.entries(typed.subAgents).filter(
       ([_, agentData]) => isExternalAgent(agentData)
     ).length;
-    logger12.info({ externalAgentCount }, "All external agents created/updated successfully");
+    logger13.info({ externalAgentCount }, "All external agents created/updated successfully");
     if (contextConfigId) {
       try {
-        logger12.info(
+        logger13.info(
           { graphId: finalGraphId, contextConfigId },
           "Updating graph with context config"
         );
@@ -4638,9 +4970,9 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
           scopes: { tenantId, projectId, graphId: finalGraphId },
           data: { contextConfigId }
         });
-        logger12.info({ graphId: finalGraphId }, "Graph updated with context config");
+        logger13.info({ graphId: finalGraphId }, "Graph updated with context config");
       } catch (error) {
-        logger12.error(
+        logger13.error(
           { graphId: finalGraphId, error },
           "Failed to update graph with context config"
         );
@@ -4655,18 +4987,46 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
             (async () => {
               try {
                 const { toolId, toolSelection, headers: headers2, agentToolRelationId } = canUseItem;
-                logger12.info({ subAgentId, toolId }, "Processing agent-tool relation");
-                await upsertAgentToolRelation(db)({
-                  scopes: { tenantId, projectId, graphId: finalGraphId },
-                  subAgentId,
-                  toolId,
-                  selectedTools: toolSelection || void 0,
-                  headers: headers2 || void 0,
-                  relationId: agentToolRelationId
-                });
-                logger12.info({ subAgentId, toolId }, "Agent-tool relation processed successfully");
+                const isFunctionTool = typed.functionTools && toolId in typed.functionTools;
+                logger13.info(
+                  {
+                    subAgentId,
+                    toolId,
+                    hasFunctionTools: !!typed.functionTools,
+                    functionToolKeys: typed.functionTools ? Object.keys(typed.functionTools) : [],
+                    isFunctionTool
+                  },
+                  "Processing canUse item"
+                );
+                if (isFunctionTool) {
+                  logger13.info({ subAgentId, toolId }, "Processing agent-function tool relation");
+                  await upsertSubAgentFunctionToolRelation(db)({
+                    scopes: { tenantId, projectId, graphId: finalGraphId },
+                    subAgentId,
+                    functionToolId: toolId,
+                    relationId: agentToolRelationId
+                  });
+                  logger13.info(
+                    { subAgentId, toolId },
+                    "Agent-function tool relation processed successfully"
+                  );
+                } else {
+                  logger13.info({ subAgentId, toolId }, "Processing agent-MCP tool relation");
+                  await upsertSubAgentToolRelation(db)({
+                    scopes: { tenantId, projectId, graphId: finalGraphId },
+                    subAgentId,
+                    toolId,
+                    selectedTools: toolSelection || void 0,
+                    headers: headers2 || void 0,
+                    relationId: agentToolRelationId
+                  });
+                  logger13.info(
+                    { subAgentId, toolId },
+                    "Agent-MCP tool relation processed successfully"
+                  );
+                }
               } catch (error) {
-                logger12.error(
+                logger13.error(
                   { subAgentId, toolId: canUseItem.toolId, error },
                   "Failed to create agent-tool relation"
                 );
@@ -4677,7 +5037,7 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
       }
     }
     await Promise.all(agentToolPromises);
-    logger12.info(
+    logger13.info(
       { agentToolCount: Object.keys(typed.subAgents).length },
       "All agent-tool relations created"
     );
@@ -4688,7 +5048,7 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
           agentDataComponentPromises.push(
             (async () => {
               try {
-                logger12.info(
+                logger13.info(
                   { subAgentId, dataComponentId },
                   "Processing agent-data component relation"
                 );
@@ -4696,12 +5056,12 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
                   scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId },
                   dataComponentId
                 });
-                logger12.info(
+                logger13.info(
                   { subAgentId, dataComponentId },
                   "Agent-data component relation processed successfully"
                 );
               } catch (error) {
-                logger12.error(
+                logger13.error(
                   { subAgentId, dataComponentId, error },
                   "Failed to create agent-data component relation"
                 );
@@ -4712,7 +5072,7 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
       }
     }
     await Promise.all(agentDataComponentPromises);
-    logger12.info({}, "All agent-data component relations created");
+    logger13.info({}, "All agent-data component relations created");
     const agentArtifactComponentPromises = [];
     for (const [subAgentId, agentData] of Object.entries(typed.subAgents)) {
       if (isInternalAgent(agentData) && agentData.artifactComponents) {
@@ -4720,7 +5080,7 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
           agentArtifactComponentPromises.push(
             (async () => {
               try {
-                logger12.info(
+                logger13.info(
                   { subAgentId, artifactComponentId },
                   "Processing agent-artifact component relation"
                 );
@@ -4728,12 +5088,12 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
                   scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId },
                   artifactComponentId
                 });
-                logger12.info(
+                logger13.info(
                   { subAgentId, artifactComponentId },
                   "Agent-artifact component relation processed successfully"
                 );
               } catch (error) {
-                logger12.error(
+                logger13.error(
                   { subAgentId, artifactComponentId, error },
                   "Failed to create agent-artifact component relation"
                 );
@@ -4744,7 +5104,7 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
       }
     }
     await Promise.all(agentArtifactComponentPromises);
-    logger12.info({}, "All agent-artifact component relations created");
+    logger13.info({}, "All agent-artifact component relations created");
     const agentRelationPromises = [];
     for (const [subAgentId, agentData] of Object.entries(typed.subAgents)) {
       if (isInternalAgent(agentData) && agentData.canTransferTo) {
@@ -4752,7 +5112,7 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
           agentRelationPromises.push(
             (async () => {
               try {
-                logger12.info(
+                logger13.info(
                   { subAgentId, targetSubAgentId, type: "transfer" },
                   "Processing agent transfer relation"
                 );
@@ -4765,12 +5125,12 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
                   targetSubAgentId,
                   relationType: "transfer"
                 });
-                logger12.info(
+                logger13.info(
                   { subAgentId, targetSubAgentId, type: "transfer" },
                   "Agent transfer relation processed successfully"
                 );
               } catch (error) {
-                logger12.error(
+                logger13.error(
                   { subAgentId, targetSubAgentId, type: "transfer", error },
                   "Failed to create transfer relation"
                 );
@@ -4786,7 +5146,7 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
           agentRelationPromises.push(
             (async () => {
               try {
-                logger12.info(
+                logger13.info(
                   { subAgentId, targetSubAgentId, type: "delegate" },
                   "Processing agent delegation relation"
                 );
@@ -4800,12 +5160,12 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
                   externalSubAgentId: isTargetExternal ? targetSubAgentId : void 0,
                   relationType: "delegate"
                 });
-                logger12.info(
+                logger13.info(
                   { subAgentId, targetSubAgentId, type: "delegate" },
                   "Agent delegation relation processed successfully"
                 );
               } catch (error) {
-                logger12.error(
+                logger13.error(
                   { subAgentId, targetSubAgentId, type: "delegate", error },
                   "Failed to create delegation relation"
                 );
@@ -4816,7 +5176,7 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
       }
     }
     await Promise.all(agentRelationPromises);
-    logger12.info(
+    logger13.info(
       { agentRelationCount: agentRelationPromises.length },
       "All agent relations created"
     );
@@ -4826,21 +5186,21 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
     if (!createdGraph) {
       throw new Error("Failed to retrieve created graph");
     }
-    logger12.info({ tenantId, graphId: finalGraphId }, "Full graph created successfully");
+    logger13.info({ tenantId, graphId: finalGraphId }, "Full graph created successfully");
     return createdGraph;
   } catch (error) {
     const errorGraphId = typed.id || "unknown";
-    logger12.error({ tenantId, graphId: errorGraphId, error }, "Failed to create full graph");
+    logger13.error({ tenantId, graphId: errorGraphId, error }, "Failed to create full graph");
     throw error;
   }
 };
-var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes, graphData) => {
+var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes, graphData) => {
   const { tenantId, projectId } = scopes;
   const typedGraphDefinition = validateAndTypeGraphData(graphData);
   if (!typedGraphDefinition.id) {
     throw new Error("Graph ID is required");
   }
-  logger12.info(
+  logger13.info(
     {
       tenantId,
       graphId: typedGraphDefinition.id,
@@ -4851,7 +5211,7 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
   validateGraphStructure(typedGraphDefinition);
   await applyExecutionLimitsInheritance(
     db,
-    logger12,
+    logger13,
     { tenantId, projectId },
     typedGraphDefinition
   );
@@ -4860,22 +5220,22 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
       scopes: { tenantId, projectId, graphId: typedGraphDefinition.id }
     });
     if (!existingGraph) {
-      logger12.info(
+      logger13.info(
         { graphId: typedGraphDefinition.id },
         "Graph does not exist, creating new graph"
       );
-      return createFullGraphServerSide(db)(scopes, graphData);
+      return createFullGraphServerSide(db, logger13)(scopes, graphData);
     }
     const existingGraphModels = existingGraph.models;
-    logger12.info(
+    logger13.info(
       {},
       "CredentialReferences are project-scoped - skipping credential reference update in graph"
     );
-    logger12.info({}, "Tools are project-scoped - skipping tool creation in graph update");
+    logger13.info({}, "MCP Tools are project-scoped - skipping tool creation in graph update");
     let finalGraphId;
     try {
       const graphId = typedGraphDefinition.id || nanoid();
-      logger12.info({ graphId }, "Getting/creating agent graph metadata");
+      logger13.info({ graphId }, "Getting/creating agent graph metadata");
       const agentGraph2 = await upsertAgentGraph(db)({
         data: {
           id: graphId,
@@ -4893,9 +5253,9 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
         }
       });
       finalGraphId = agentGraph2.id;
-      logger12.info({ graphId: finalGraphId }, "Agent graph metadata ready");
+      logger13.info({ graphId: finalGraphId }, "Agent graph metadata ready");
     } catch (error) {
-      logger12.error(
+      logger13.error(
         { graphId: typedGraphDefinition.id, error },
         "Failed to get/update graph metadata"
       );
@@ -4903,7 +5263,7 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
     }
     let contextConfigId;
     if (typedGraphDefinition.contextConfig) {
-      logger12.info(
+      logger13.info(
         { contextConfigId: typedGraphDefinition.contextConfig?.id },
         " context config exists"
       );
@@ -4919,9 +5279,9 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
           }
         });
         contextConfigId = contextConfig2.id;
-        logger12.info({ contextConfigId }, "Context config processed successfully");
+        logger13.info({ contextConfigId }, "Context config processed successfully");
       } catch (error) {
-        logger12.error(
+        logger13.error(
           { contextConfigId: typedGraphDefinition.contextConfig.id, error },
           "Failed to create/update context config"
         );
@@ -4930,7 +5290,7 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
     }
     if (contextConfigId) {
       try {
-        logger12.info(
+        logger13.info(
           { graphId: finalGraphId, contextConfigId },
           "Updating graph with contextConfigId"
         );
@@ -4949,23 +5309,105 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
             stopWhen: typedGraphDefinition.stopWhen
           }
         });
-        logger12.info(
+        logger13.info(
           { graphId: finalGraphId, contextConfigId },
           "Graph updated with contextConfigId successfully"
         );
       } catch (error) {
-        logger12.error(
+        logger13.error(
           { graphId: finalGraphId, contextConfigId, error },
           "Failed to update graph with contextConfigId"
         );
         throw error;
       }
     }
-    logger12.info({}, "DataComponents are project-scoped - skipping dataComponent update in graph");
-    logger12.info(
+    logger13.info({}, "DataComponents are project-scoped - skipping dataComponent update in graph");
+    logger13.info(
       {},
       "ArtifactComponents are project-scoped - skipping artifactComponent update in graph"
     );
+    if (typedGraphDefinition.functions && Object.keys(typedGraphDefinition.functions).length > 0) {
+      logger13.info(
+        {
+          graphId: finalGraphId,
+          functionCount: Object.keys(typedGraphDefinition.functions).length
+        },
+        "Updating functions for graph"
+      );
+      const functionPromises = Object.entries(typedGraphDefinition.functions).map(
+        async ([functionId, functionData]) => {
+          try {
+            logger13.info({ graphId: finalGraphId, functionId }, "Updating function for graph");
+            await upsertFunction(db)({
+              data: {
+                ...functionData,
+                id: functionId
+              },
+              scopes: { tenantId, projectId }
+            });
+            logger13.info({ graphId: finalGraphId, functionId }, "Function updated successfully");
+          } catch (error) {
+            logger13.error(
+              { graphId: finalGraphId, functionId, error },
+              "Failed to update function for graph"
+            );
+            throw error;
+          }
+        }
+      );
+      await Promise.all(functionPromises);
+      logger13.info(
+        {
+          graphId: finalGraphId,
+          functionCount: Object.keys(typedGraphDefinition.functions).length
+        },
+        "All functions updated successfully"
+      );
+    }
+    if (typedGraphDefinition.functionTools && Object.keys(typedGraphDefinition.functionTools).length > 0) {
+      logger13.info(
+        {
+          graphId: finalGraphId,
+          functionToolCount: Object.keys(typedGraphDefinition.functionTools).length
+        },
+        "Updating function tools for graph"
+      );
+      const functionToolPromises = Object.entries(typedGraphDefinition.functionTools).map(
+        async ([functionToolId, functionToolData]) => {
+          try {
+            logger13.info(
+              { graphId: finalGraphId, functionToolId },
+              "Updating function tool in graph"
+            );
+            await upsertFunctionTool(db)({
+              data: {
+                ...functionToolData,
+                id: functionToolId
+              },
+              scopes: { tenantId, projectId, graphId: finalGraphId }
+            });
+            logger13.info(
+              { graphId: finalGraphId, functionToolId },
+              "Function tool updated successfully"
+            );
+          } catch (error) {
+            logger13.error(
+              { graphId: finalGraphId, functionToolId, error },
+              "Failed to update function tool in graph"
+            );
+            throw error;
+          }
+        }
+      );
+      await Promise.all(functionToolPromises);
+      logger13.info(
+        {
+          graphId: finalGraphId,
+          functionToolCount: Object.keys(typedGraphDefinition.functionTools).length
+        },
+        "All function tools updated successfully"
+      );
+    }
     const internalAgentPromises = Object.entries(typedGraphDefinition.subAgents).filter(([_, agentData]) => isInternalAgent(agentData)).map(async ([subAgentId, agentData]) => {
       const internalAgent = agentData;
       let existingAgent = null;
@@ -4993,7 +5435,7 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
           (graphModels[modelType].model !== existingGraphModels[modelType].model || // OR providerOptions changed
           JSON.stringify(graphModels[modelType].providerOptions) !== JSON.stringify(existingGraphModels[modelType].providerOptions))) {
             cascadedModels[modelType] = graphModels[modelType];
-            logger12.info(
+            logger13.info(
               {
                 subAgentId,
                 modelType,
@@ -5008,7 +5450,7 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
         finalModelSettings = cascadedModels;
       }
       try {
-        logger12.info({ subAgentId }, "Processing internal agent");
+        logger13.info({ subAgentId }, "Processing internal agent");
         await upsertSubAgent(db)({
           data: {
             id: subAgentId,
@@ -5023,9 +5465,9 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
             stopWhen: internalAgent.stopWhen
           }
         });
-        logger12.info({ subAgentId }, "Internal agent processed successfully");
+        logger13.info({ subAgentId }, "Internal agent processed successfully");
       } catch (error) {
-        logger12.error({ subAgentId, error }, "Failed to create/update internal agent");
+        logger13.error({ subAgentId, error }, "Failed to create/update internal agent");
         throw error;
       }
     });
@@ -5033,11 +5475,11 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
     const internalAgentCount = Object.entries(typedGraphDefinition.subAgents).filter(
       ([_, agentData]) => isInternalAgent(agentData)
     ).length;
-    logger12.info({ internalAgentCount }, "All internal agents created/updated successfully");
+    logger13.info({ internalAgentCount }, "All internal agents created/updated successfully");
     const externalAgentPromises = Object.entries(typedGraphDefinition.subAgents).filter(([_, agentData]) => isExternalAgent(agentData)).map(async ([subAgentId, agentData]) => {
       const externalAgent = agentData;
       try {
-        logger12.info({ subAgentId }, "Processing external agent");
+        logger13.info({ subAgentId }, "Processing external agent");
         await upsertExternalAgent(db)({
           data: {
             id: subAgentId,
@@ -5051,9 +5493,9 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
             headers: externalAgent.headers || void 0
           }
         });
-        logger12.info({ subAgentId }, "External agent processed successfully");
+        logger13.info({ subAgentId }, "External agent processed successfully");
       } catch (error) {
-        logger12.error({ subAgentId, error }, "Failed to create/update external agent");
+        logger13.error({ subAgentId, error }, "Failed to create/update external agent");
         throw error;
       }
     });
@@ -5061,7 +5503,7 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
     const externalAgentCount = Object.entries(typedGraphDefinition.subAgents).filter(
       ([_, agentData]) => isExternalAgent(agentData)
     ).length;
-    logger12.info({ externalAgentCount }, "All external agents created/updated successfully");
+    logger13.info({ externalAgentCount }, "All external agents created/updated successfully");
     const incomingAgentIds = new Set(Object.keys(typedGraphDefinition.subAgents));
     const existingInternalAgents = await listSubAgents(db)({
       scopes: { tenantId, projectId, graphId: finalGraphId }
@@ -5078,9 +5520,9 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
             subAgentId: agent.id
           });
           deletedInternalCount++;
-          logger12.info({ subAgentId: agent.id }, "Deleted orphaned internal agent");
+          logger13.info({ subAgentId: agent.id }, "Deleted orphaned internal agent");
         } catch (error) {
-          logger12.error(
+          logger13.error(
             { subAgentId: agent.id, error },
             "Failed to delete orphaned internal agent"
           );
@@ -5096,9 +5538,9 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
             subAgentId: agent.id
           });
           deletedExternalCount++;
-          logger12.info({ subAgentId: agent.id }, "Deleted orphaned external agent");
+          logger13.info({ subAgentId: agent.id }, "Deleted orphaned external agent");
         } catch (error) {
-          logger12.error(
+          logger13.error(
             { subAgentId: agent.id, error },
             "Failed to delete orphaned external agent"
           );
@@ -5106,7 +5548,7 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
       }
     }
     if (deletedInternalCount > 0 || deletedExternalCount > 0) {
-      logger12.info(
+      logger13.info(
         {
           deletedInternalCount,
           deletedExternalCount,
@@ -5128,7 +5570,7 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
         stopWhen: typedGraphDefinition.stopWhen
       }
     });
-    logger12.info({ graphId: typedGraphDefinition.id }, "Graph metadata updated");
+    logger13.info({ graphId: typedGraphDefinition.id }, "Graph metadata updated");
     const incomingRelationshipIds = /* @__PURE__ */ new Set();
     for (const [_subAgentId, agentData] of Object.entries(typedGraphDefinition.subAgents)) {
       if (isInternalAgent(agentData) && agentData.canUse && Array.isArray(agentData.canUse)) {
@@ -5165,10 +5607,10 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
           deletedCount = result.rowsAffected || 0;
         }
         if (deletedCount > 0) {
-          logger12.info({ subAgentId, deletedCount }, "Deleted orphaned agent-tool relations");
+          logger13.info({ subAgentId, deletedCount }, "Deleted orphaned agent-tool relations");
         }
       } catch (error) {
-        logger12.error({ subAgentId, error }, "Failed to delete orphaned agent-tool relations");
+        logger13.error({ subAgentId, error }, "Failed to delete orphaned agent-tool relations");
       }
     }
     const agentToolPromises = [];
@@ -5179,21 +5621,36 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
             (async () => {
               try {
                 const { toolId, toolSelection, headers: headers2, agentToolRelationId } = canUseItem;
-                logger12.info({ subAgentId, toolId }, "Processing agent-tool relation");
-                await upsertAgentToolRelation(db)({
-                  scopes: { tenantId, projectId, graphId: finalGraphId },
-                  subAgentId,
-                  toolId,
-                  selectedTools: toolSelection || void 0,
-                  headers: headers2 || void 0,
-                  relationId: agentToolRelationId
-                });
-                logger12.info(
-                  { subAgentId, toolId, relationId: agentToolRelationId },
-                  "Agent-tool relation upserted"
-                );
+                const isFunctionTool = typedGraphDefinition.functionTools && toolId in typedGraphDefinition.functionTools;
+                if (isFunctionTool) {
+                  logger13.info({ subAgentId, toolId }, "Processing agent-function tool relation");
+                  await upsertSubAgentFunctionToolRelation(db)({
+                    scopes: { tenantId, projectId, graphId: finalGraphId },
+                    subAgentId,
+                    functionToolId: toolId,
+                    relationId: agentToolRelationId
+                  });
+                  logger13.info(
+                    { subAgentId, toolId, relationId: agentToolRelationId },
+                    "Agent-function tool relation upserted"
+                  );
+                } else {
+                  logger13.info({ subAgentId, toolId }, "Processing agent-MCP tool relation");
+                  await upsertSubAgentToolRelation(db)({
+                    scopes: { tenantId, projectId, graphId: finalGraphId },
+                    subAgentId,
+                    toolId,
+                    selectedTools: toolSelection || void 0,
+                    headers: headers2 || void 0,
+                    relationId: agentToolRelationId
+                  });
+                  logger13.info(
+                    { subAgentId, toolId, relationId: agentToolRelationId },
+                    "Agent-MCP tool relation upserted"
+                  );
+                }
               } catch (error) {
-                logger12.error(
+                logger13.error(
                   {
                     subAgentId,
                     toolId: canUseItem.toolId,
@@ -5209,7 +5666,7 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
       }
     }
     await Promise.all(agentToolPromises);
-    logger12.info(
+    logger13.info(
       { agentToolPromisesCount: agentToolPromises.length },
       "All agent-tool relations updated"
     );
@@ -5229,12 +5686,12 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
                   scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId },
                   dataComponentId
                 });
-                logger12.info(
+                logger13.info(
                   { subAgentId, dataComponentId },
                   "Agent-dataComponent relation created"
                 );
               } catch (error) {
-                logger12.error(
+                logger13.error(
                   { subAgentId, dataComponentId, error },
                   "Failed to create agent-dataComponent relation"
                 );
@@ -5245,7 +5702,7 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
       }
     }
     await Promise.all(agentDataComponentPromises);
-    logger12.info(
+    logger13.info(
       { agentDataComponentPromisesCount: agentDataComponentPromises.length },
       "All agent-dataComponent relations updated"
     );
@@ -5265,12 +5722,12 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
                   scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId },
                   artifactComponentId
                 });
-                logger12.info(
+                logger13.info(
                   { subAgentId, artifactComponentId },
                   "Agent-artifactComponent relation created"
                 );
               } catch (error) {
-                logger12.error(
+                logger13.error(
                   { subAgentId, artifactComponentId, error },
                   "Failed to create agent-artifactComponent relation"
                 );
@@ -5281,7 +5738,7 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
       }
     }
     await Promise.all(agentArtifactComponentPromises);
-    logger12.info(
+    logger13.info(
       { agentArtifactComponentPromisesCount: agentArtifactComponentPromises.length },
       "All agent-artifactComponent relations updated"
     );
@@ -5310,12 +5767,12 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
                   projectId,
                   ...relationData
                 });
-                logger12.info(
+                logger13.info(
                   { subAgentId, targetSubAgentId, isTargetExternal },
                   "Transfer relation created"
                 );
               } catch (error) {
-                logger12.error(
+                logger13.error(
                   { subAgentId, targetSubAgentId, error },
                   "Failed to create transfer relation"
                 );
@@ -5344,9 +5801,9 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
                   projectId,
                   ...relationData
                 });
-                logger12.info({ subAgentId, targetSubAgentId }, "Delegation relation created");
+                logger13.info({ subAgentId, targetSubAgentId }, "Delegation relation created");
               } catch (error) {
-                logger12.error(
+                logger13.error(
                   { subAgentId, targetSubAgentId, error },
                   "Failed to create delegation relation"
                 );
@@ -5357,7 +5814,7 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
       }
     }
     await Promise.all(agentRelationPromises);
-    logger12.info(
+    logger13.info(
       { agentRelationPromisesCount: agentRelationPromises.length },
       "All agent relations updated"
     );
@@ -5367,26 +5824,26 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
     if (!updatedGraph) {
       throw new Error("Failed to retrieve updated graph");
     }
-    logger12.info({ graphId: typedGraphDefinition.id }, "Full graph updated successfully");
+    logger13.info({ graphId: typedGraphDefinition.id }, "Full graph updated successfully");
     return updatedGraph;
   } catch (error) {
-    logger12.error({ graphId: typedGraphDefinition.id, error }, "Failed to update full graph");
+    logger13.error({ graphId: typedGraphDefinition.id, error }, "Failed to update full graph");
     throw error;
   }
 };
-var getFullGraph = (db, logger12 = defaultLogger) => async (params) => {
+var getFullGraph = (db, logger13 = defaultLogger) => async (params) => {
   const { scopes } = params;
   const { tenantId, projectId } = scopes;
-  logger12.info({ tenantId, graphId: scopes.graphId }, "Retrieving full graph definition");
+  logger13.info({ tenantId, graphId: scopes.graphId }, "Retrieving full graph definition");
   try {
     const graph = await getFullGraphDefinition(db)({
       scopes: { tenantId, projectId, graphId: scopes.graphId }
     });
     if (!graph) {
-      logger12.info({ tenantId, graphId: scopes.graphId }, "Graph not found");
+      logger13.info({ tenantId, graphId: scopes.graphId }, "Graph not found");
       return null;
     }
-    logger12.info(
+    logger13.info(
       {
         tenantId,
         graphId: scopes.graphId,
@@ -5396,7 +5853,7 @@ var getFullGraph = (db, logger12 = defaultLogger) => async (params) => {
     );
     return graph;
   } catch (error) {
-    logger12.error(
+    logger13.error(
       {
         tenantId,
         graphId: scopes.graphId,
@@ -5407,21 +5864,21 @@ var getFullGraph = (db, logger12 = defaultLogger) => async (params) => {
     throw error;
   }
 };
-var deleteFullGraph = (db, logger12 = defaultLogger) => async (params) => {
+var deleteFullGraph = (db, logger13 = defaultLogger) => async (params) => {
   const { tenantId, projectId, graphId } = params.scopes;
-  logger12.info({ tenantId, graphId }, "Deleting full graph and related entities");
+  logger13.info({ tenantId, graphId }, "Deleting full graph and related entities");
   try {
     const graph = await getFullGraphDefinition(db)({
       scopes: { tenantId, projectId, graphId }
     });
     if (!graph) {
-      logger12.info({ tenantId, graphId }, "Graph not found for deletion");
+      logger13.info({ tenantId, graphId }, "Graph not found for deletion");
       return false;
     }
     await deleteAgentRelationsByGraph(db)({
       scopes: { tenantId, projectId, graphId }
     });
-    logger12.info({ tenantId, graphId }, "Agent relations deleted");
+    logger13.info({ tenantId, graphId }, "Agent relations deleted");
     const subAgentIds = Object.keys(graph.subAgents);
     if (subAgentIds.length > 0) {
       for (const subAgentId of subAgentIds) {
@@ -5429,7 +5886,7 @@ var deleteFullGraph = (db, logger12 = defaultLogger) => async (params) => {
           scopes: { tenantId, projectId, graphId, subAgentId }
         });
       }
-      logger12.info(
+      logger13.info(
         { tenantId, graphId, agentCount: subAgentIds.length },
         "Agent-tool relations deleted"
       );
@@ -5437,11 +5894,11 @@ var deleteFullGraph = (db, logger12 = defaultLogger) => async (params) => {
     await deleteAgentGraph(db)({
       scopes: { tenantId, projectId, graphId }
     });
-    logger12.info({ tenantId, graphId }, "Graph metadata deleted");
-    logger12.info({ tenantId, graphId }, "Full graph deleted successfully");
+    logger13.info({ tenantId, graphId }, "Graph metadata deleted");
+    logger13.info({ tenantId, graphId }, "Full graph deleted successfully");
     return true;
   } catch (error) {
-    logger12.error(
+    logger13.error(
       {
         tenantId,
         graphId,
@@ -6031,10 +6488,10 @@ var defaultLogger2 = getLogger("projectFull");
 function validateAndTypeProjectData(projectData) {
   return projectData;
 }
-var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scopes, projectData) => {
+var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scopes, projectData) => {
   const { tenantId } = scopes;
   const typed = validateAndTypeProjectData(projectData);
-  logger12.info(
+  logger13.info(
     {
       tenantId,
       projectId: typed.id,
@@ -6053,11 +6510,11 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    logger12.info({ projectId: typed.id }, "Creating project metadata");
+    logger13.info({ projectId: typed.id }, "Creating project metadata");
     await createProject(db)(projectPayload);
-    logger12.info({ projectId: typed.id }, "Project metadata created successfully");
+    logger13.info({ projectId: typed.id }, "Project metadata created successfully");
     if (typed.credentialReferences && Object.keys(typed.credentialReferences).length > 0) {
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.credentialReferences).length
@@ -6067,7 +6524,7 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       const credentialPromises = Object.entries(typed.credentialReferences).map(
         async ([_credId, credData]) => {
           try {
-            logger12.info(
+            logger13.info(
               { projectId: typed.id, credId: credData.id },
               "Creating credentialReference in project"
             );
@@ -6078,12 +6535,12 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
                 projectId: typed.id
               }
             });
-            logger12.info(
+            logger13.info(
               { projectId: typed.id, credId: credData.id },
               "CredentialReference created successfully"
             );
           } catch (error) {
-            logger12.error(
+            logger13.error(
               { projectId: typed.id, credId: credData.id, error },
               "Failed to create credentialReference in project"
             );
@@ -6092,7 +6549,7 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
         }
       );
       await Promise.all(credentialPromises);
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.credentialReferences).length
@@ -6104,19 +6561,19 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       const functionPromises = Object.entries(typed.functions).map(
         async ([functionId, functionData]) => {
           try {
-            logger12.info({ projectId: typed.id, functionId }, "Creating project function");
+            logger13.info({ projectId: typed.id, functionId }, "Creating project function");
             await upsertFunction(db)({
               data: {
                 ...functionData
               },
               scopes: { tenantId, projectId: typed.id }
             });
-            logger12.info(
+            logger13.info(
               { projectId: typed.id, functionId },
               "Project function created successfully"
             );
           } catch (error) {
-            logger12.error(
+            logger13.error(
               { projectId: typed.id, functionId, error },
               "Failed to create global function"
             );
@@ -6125,7 +6582,7 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
         }
       );
       await Promise.all(functionPromises);
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           functionCount: Object.keys(typed.functions).length
@@ -6134,7 +6591,7 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       );
     }
     if (typed.tools && Object.keys(typed.tools).length > 0) {
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           toolCount: Object.keys(typed.tools).length
@@ -6143,7 +6600,7 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       );
       const toolPromises = Object.entries(typed.tools).map(async ([toolId, toolData]) => {
         try {
-          logger12.info({ projectId: typed.id, toolId }, "Creating tool in project");
+          logger13.info({ projectId: typed.id, toolId }, "Creating tool in project");
           await upsertTool(db)({
             data: {
               tenantId,
@@ -6151,9 +6608,9 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
               ...toolData
             }
           });
-          logger12.info({ projectId: typed.id, toolId }, "Tool created successfully");
+          logger13.info({ projectId: typed.id, toolId }, "Tool created successfully");
         } catch (error) {
-          logger12.error(
+          logger13.error(
             { projectId: typed.id, toolId, error },
             "Failed to create tool in project"
           );
@@ -6161,7 +6618,7 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
         }
       });
       await Promise.all(toolPromises);
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           toolCount: Object.keys(typed.tools).length
@@ -6170,7 +6627,7 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       );
     }
     if (typed.dataComponents && Object.keys(typed.dataComponents).length > 0) {
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.dataComponents).length
@@ -6180,7 +6637,7 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       const dataComponentPromises = Object.entries(typed.dataComponents).map(
         async ([componentId, componentData]) => {
           try {
-            logger12.info(
+            logger13.info(
               { projectId: typed.id, componentId },
               "Creating dataComponent in project"
             );
@@ -6191,12 +6648,12 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
                 projectId: typed.id
               }
             });
-            logger12.info(
+            logger13.info(
               { projectId: typed.id, componentId },
               "DataComponent created successfully"
             );
           } catch (error) {
-            logger12.error(
+            logger13.error(
               { projectId: typed.id, componentId, error },
               "Failed to create dataComponent in project"
             );
@@ -6205,7 +6662,7 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
         }
       );
       await Promise.all(dataComponentPromises);
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.dataComponents).length
@@ -6214,7 +6671,7 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       );
     }
     if (typed.artifactComponents && Object.keys(typed.artifactComponents).length > 0) {
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.artifactComponents).length
@@ -6224,7 +6681,7 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       const artifactComponentPromises = Object.entries(typed.artifactComponents).map(
         async ([componentId, componentData]) => {
           try {
-            logger12.info(
+            logger13.info(
               { projectId: typed.id, componentId },
               "Creating artifactComponent in project"
             );
@@ -6235,12 +6692,12 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
                 projectId: typed.id
               }
             });
-            logger12.info(
+            logger13.info(
               { projectId: typed.id, componentId },
               "ArtifactComponent created successfully"
             );
           } catch (error) {
-            logger12.error(
+            logger13.error(
               { projectId: typed.id, componentId, error },
               "Failed to create artifactComponent in project"
             );
@@ -6249,7 +6706,7 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
         }
       );
       await Promise.all(artifactComponentPromises);
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.artifactComponents).length
@@ -6258,7 +6715,7 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       );
     }
     if (typed.graphs && Object.keys(typed.graphs).length > 0) {
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           graphCount: Object.keys(typed.graphs).length
@@ -6267,27 +6724,25 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       );
       const graphPromises = Object.entries(typed.graphs).map(async ([graphId, graphData]) => {
         try {
-          logger12.info({ projectId: typed.id, graphId }, "Creating graph in project");
+          logger13.info({ projectId: typed.id, graphId }, "Creating graph in project");
           const graphDataWithProjectResources = {
             ...graphData,
-            agents: void 0,
-            // Remove 'agents' property from GraphWithinContextOfProjectSchema
-            subAgents: graphData.subAgents,
-            // Map 'agents' to 'subAgents' for FullGraphDefinitionSchema
             tools: typed.tools || {},
-            // Pass project-level resources for validation
+            // Pass project-level MCP tools for validation
+            functions: typed.functions || {},
+            // Pass project-level functions for validation
             dataComponents: typed.dataComponents || {},
             artifactComponents: typed.artifactComponents || {},
             credentialReferences: typed.credentialReferences || {},
             statusUpdates: graphData.statusUpdates === null ? void 0 : graphData.statusUpdates
           };
-          await createFullGraphServerSide(db, logger12)(
+          await createFullGraphServerSide(db, logger13)(
             { tenantId, projectId: typed.id },
             graphDataWithProjectResources
           );
-          logger12.info({ projectId: typed.id, graphId }, "Graph created successfully in project");
+          logger13.info({ projectId: typed.id, graphId }, "Graph created successfully in project");
         } catch (error) {
-          logger12.error(
+          logger13.error(
             { projectId: typed.id, graphId, error },
             "Failed to create graph in project"
           );
@@ -6295,7 +6750,7 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
         }
       });
       await Promise.all(graphPromises);
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           graphCount: Object.keys(typed.graphs).length
@@ -6303,15 +6758,15 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
         "All project graphs created successfully"
       );
     }
-    logger12.info({ projectId: typed.id }, "Full project created successfully");
+    logger13.info({ projectId: typed.id }, "Full project created successfully");
     return await getFullProject(
       db,
-      logger12
+      logger13
     )({
       scopes: { tenantId, projectId: typed.id }
     });
   } catch (error) {
-    logger12.error(
+    logger13.error(
       {
         tenantId,
         projectId: typed.id,
@@ -6322,13 +6777,13 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
     throw error;
   }
 };
-var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scopes, projectData) => {
+var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scopes, projectData) => {
   const { tenantId } = scopes;
   const typed = validateAndTypeProjectData(projectData);
   if (!typed.id) {
     throw new Error("Project ID is required");
   }
-  logger12.info(
+  logger13.info(
     {
       tenantId,
       projectId: typed.id,
@@ -6341,8 +6796,8 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       scopes: { tenantId, projectId: typed.id }
     });
     if (!existingProject) {
-      logger12.info({ projectId: typed.id }, "Project not found, creating new project");
-      return await createFullProjectServerSide(db, logger12)(
+      logger13.info({ projectId: typed.id }, "Project not found, creating new project");
+      return await createFullProjectServerSide(db, logger13)(
         { tenantId, projectId: typed.id },
         projectData
       );
@@ -6353,14 +6808,14 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       models: typed.models,
       stopWhen: typed.stopWhen
     };
-    logger12.info({ projectId: typed.id }, "Updating project metadata");
+    logger13.info({ projectId: typed.id }, "Updating project metadata");
     await updateProject(db)({
       scopes: { tenantId, projectId: typed.id },
       data: projectUpdatePayload
     });
-    logger12.info({ projectId: typed.id }, "Project metadata updated successfully");
+    logger13.info({ projectId: typed.id }, "Project metadata updated successfully");
     if (typed.credentialReferences && Object.keys(typed.credentialReferences).length > 0) {
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.credentialReferences).length
@@ -6370,7 +6825,7 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       const credentialPromises = Object.entries(typed.credentialReferences).map(
         async ([_credId, credData]) => {
           try {
-            logger12.info(
+            logger13.info(
               { projectId: typed.id, credId: credData.id },
               "Updating credentialReference in project"
             );
@@ -6381,12 +6836,12 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
                 projectId: typed.id
               }
             });
-            logger12.info(
+            logger13.info(
               { projectId: typed.id, credId: credData.id },
               "CredentialReference updated successfully"
             );
           } catch (error) {
-            logger12.error(
+            logger13.error(
               { projectId: typed.id, credId: credData.id, error },
               "Failed to update credentialReference in project"
             );
@@ -6395,7 +6850,7 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
         }
       );
       await Promise.all(credentialPromises);
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.credentialReferences).length
@@ -6404,7 +6859,7 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       );
     }
     if (typed.functions && Object.keys(typed.functions).length > 0) {
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           functionCount: Object.keys(typed.functions).length
@@ -6414,19 +6869,19 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       const functionPromises = Object.entries(typed.functions).map(
         async ([functionId, functionData]) => {
           try {
-            logger12.info({ projectId: typed.id, functionId }, "Updating project function");
+            logger13.info({ projectId: typed.id, functionId }, "Updating project function");
             await upsertFunction(db)({
               data: {
                 ...functionData
               },
               scopes: { tenantId, projectId: typed.id }
             });
-            logger12.info(
+            logger13.info(
               { projectId: typed.id, functionId },
               "Project function updated successfully"
             );
           } catch (error) {
-            logger12.error(
+            logger13.error(
               { projectId: typed.id, functionId, error },
               "Failed to update global function"
             );
@@ -6435,7 +6890,7 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
         }
       );
       await Promise.all(functionPromises);
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           functionCount: Object.keys(typed.functions).length
@@ -6444,7 +6899,7 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       );
     }
     if (typed.tools && Object.keys(typed.tools).length > 0) {
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           toolCount: Object.keys(typed.tools).length
@@ -6453,7 +6908,7 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       );
       const toolPromises = Object.entries(typed.tools).map(async ([toolId, toolData]) => {
         try {
-          logger12.info({ projectId: typed.id, toolId }, "Updating tool in project");
+          logger13.info({ projectId: typed.id, toolId }, "Updating tool in project");
           await upsertTool(db)({
             data: {
               tenantId,
@@ -6461,9 +6916,9 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
               ...toolData
             }
           });
-          logger12.info({ projectId: typed.id, toolId }, "Tool updated successfully");
+          logger13.info({ projectId: typed.id, toolId }, "Tool updated successfully");
         } catch (error) {
-          logger12.error(
+          logger13.error(
             { projectId: typed.id, toolId, error },
             "Failed to update tool in project"
           );
@@ -6471,7 +6926,7 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
         }
       });
       await Promise.all(toolPromises);
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           toolCount: Object.keys(typed.tools).length
@@ -6480,7 +6935,7 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       );
     }
     if (typed.dataComponents && Object.keys(typed.dataComponents).length > 0) {
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.dataComponents).length
@@ -6490,7 +6945,7 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       const dataComponentPromises = Object.entries(typed.dataComponents).map(
         async ([componentId, componentData]) => {
           try {
-            logger12.info(
+            logger13.info(
               { projectId: typed.id, componentId },
               "Updating dataComponent in project"
             );
@@ -6501,12 +6956,12 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
                 projectId: typed.id
               }
             });
-            logger12.info(
+            logger13.info(
               { projectId: typed.id, componentId },
               "DataComponent updated successfully"
             );
           } catch (error) {
-            logger12.error(
+            logger13.error(
               { projectId: typed.id, componentId, error },
               "Failed to update dataComponent in project"
             );
@@ -6515,7 +6970,7 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
         }
       );
       await Promise.all(dataComponentPromises);
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.dataComponents).length
@@ -6524,7 +6979,7 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       );
     }
     if (typed.artifactComponents && Object.keys(typed.artifactComponents).length > 0) {
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.artifactComponents).length
@@ -6534,7 +6989,7 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       const artifactComponentPromises = Object.entries(typed.artifactComponents).map(
         async ([componentId, componentData]) => {
           try {
-            logger12.info(
+            logger13.info(
               { projectId: typed.id, componentId },
               "Updating artifactComponent in project"
             );
@@ -6545,12 +7000,12 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
                 projectId: typed.id
               }
             });
-            logger12.info(
+            logger13.info(
               { projectId: typed.id, componentId },
               "ArtifactComponent updated successfully"
             );
           } catch (error) {
-            logger12.error(
+            logger13.error(
               { projectId: typed.id, componentId, error },
               "Failed to update artifactComponent in project"
             );
@@ -6559,7 +7014,7 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
         }
       );
       await Promise.all(artifactComponentPromises);
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.artifactComponents).length
@@ -6577,14 +7032,14 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
         try {
           await deleteFullGraph(
             db,
-            logger12
+            logger13
           )({
             scopes: { tenantId, projectId: typed.id, graphId: graph.id }
           });
           deletedGraphCount++;
-          logger12.info({ graphId: graph.id }, "Deleted orphaned graph from project");
+          logger13.info({ graphId: graph.id }, "Deleted orphaned graph from project");
         } catch (error) {
-          logger12.error(
+          logger13.error(
             { graphId: graph.id, error },
             "Failed to delete orphaned graph from project"
           );
@@ -6592,7 +7047,7 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       }
     }
     if (deletedGraphCount > 0) {
-      logger12.info(
+      logger13.info(
         {
           deletedGraphCount,
           projectId: typed.id
@@ -6601,7 +7056,7 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       );
     }
     if (typed.graphs && Object.keys(typed.graphs).length > 0) {
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           graphCount: Object.keys(typed.graphs).length
@@ -6610,27 +7065,25 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
       );
       const graphPromises = Object.entries(typed.graphs).map(async ([graphId, graphData]) => {
         try {
-          logger12.info({ projectId: typed.id, graphId }, "Updating graph in project");
+          logger13.info({ projectId: typed.id, graphId }, "Updating graph in project");
           const graphDataWithProjectResources = {
             ...graphData,
-            agents: void 0,
-            // Remove 'agents' property from GraphWithinContextOfProjectSchema
-            subAgents: graphData.subAgents,
-            // Map 'agents' to 'subAgents' for FullGraphDefinitionSchema
             tools: typed.tools || {},
-            // Pass project-level resources for validation
+            // Pass project-level MCP tools for validation
+            functions: typed.functions || {},
+            // Pass project-level functions for validation
             dataComponents: typed.dataComponents || {},
             artifactComponents: typed.artifactComponents || {},
             credentialReferences: typed.credentialReferences || {},
             statusUpdates: graphData.statusUpdates === null ? void 0 : graphData.statusUpdates
           };
-          await updateFullGraphServerSide(db, logger12)(
+          await updateFullGraphServerSide(db, logger13)(
             { tenantId, projectId: typed.id },
             graphDataWithProjectResources
           );
-          logger12.info({ projectId: typed.id, graphId }, "Graph updated successfully in project");
+          logger13.info({ projectId: typed.id, graphId }, "Graph updated successfully in project");
         } catch (error) {
-          logger12.error(
+          logger13.error(
             { projectId: typed.id, graphId, error },
             "Failed to update graph in project"
           );
@@ -6638,7 +7091,7 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
         }
       });
       await Promise.all(graphPromises);
-      logger12.info(
+      logger13.info(
         {
           projectId: typed.id,
           graphCount: Object.keys(typed.graphs).length
@@ -6646,15 +7099,15 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
         "All project graphs updated successfully"
       );
     }
-    logger12.info({ projectId: typed.id }, "Full project updated successfully");
+    logger13.info({ projectId: typed.id }, "Full project updated successfully");
     return await getFullProject(
       db,
-      logger12
+      logger13
     )({
       scopes: { tenantId, projectId: typed.id }
     });
   } catch (error) {
-    logger12.error(
+    logger13.error(
       {
         tenantId,
         projectId: typed.id,
@@ -6665,23 +7118,23 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
     throw error;
   }
 };
-var getFullProject = (db, logger12 = defaultLogger2) => async (params) => {
+var getFullProject = (db, logger13 = defaultLogger2) => async (params) => {
   const { scopes } = params;
   const { tenantId, projectId } = scopes;
-  logger12.info({ tenantId, projectId }, "Retrieving full project definition");
+  logger13.info({ tenantId, projectId }, "Retrieving full project definition");
   try {
     const project = await getProject(db)({
       scopes: { tenantId, projectId }
     });
     if (!project) {
-      logger12.info({ tenantId, projectId }, "Project not found");
+      logger13.info({ tenantId, projectId }, "Project not found");
       return null;
     }
-    logger12.info({ tenantId, projectId }, "Project metadata retrieved");
+    logger13.info({ tenantId, projectId }, "Project metadata retrieved");
     const graphList = await listAgentGraphs(db)({
       scopes: { tenantId, projectId }
     });
-    logger12.info(
+    logger13.info(
       {
         tenantId,
         projectId,
@@ -6709,12 +7162,12 @@ var getFullProject = (db, logger12 = defaultLogger2) => async (params) => {
           // status, lastHealthCheck, availableTools, activeTools, lastToolsSync are all runtime
         };
       }
-      logger12.info(
+      logger13.info(
         { tenantId, projectId, toolCount: Object.keys(projectTools).length },
         "Tools retrieved for project"
       );
     } catch (error) {
-      logger12.warn({ tenantId, projectId, error }, "Failed to retrieve tools for project");
+      logger13.warn({ tenantId, projectId, error }, "Failed to retrieve tools for project");
     }
     const projectDataComponents = {};
     try {
@@ -6729,12 +7182,12 @@ var getFullProject = (db, logger12 = defaultLogger2) => async (params) => {
           props: component.props
         };
       }
-      logger12.info(
+      logger13.info(
         { tenantId, projectId, count: Object.keys(projectDataComponents).length },
         "DataComponents retrieved for project"
       );
     } catch (error) {
-      logger12.warn(
+      logger13.warn(
         { tenantId, projectId, error },
         "Failed to retrieve dataComponents for project"
       );
@@ -6752,12 +7205,12 @@ var getFullProject = (db, logger12 = defaultLogger2) => async (params) => {
           props: component.props
         };
       }
-      logger12.info(
+      logger13.info(
         { tenantId, projectId, count: Object.keys(projectArtifactComponents).length },
         "ArtifactComponents retrieved for project"
       );
     } catch (error) {
-      logger12.warn(
+      logger13.warn(
         { tenantId, projectId, error },
         "Failed to retrieve artifactComponents for project"
       );
@@ -6775,12 +7228,12 @@ var getFullProject = (db, logger12 = defaultLogger2) => async (params) => {
           retrievalParams: credential.retrievalParams
         };
       }
-      logger12.info(
+      logger13.info(
         { tenantId, projectId, count: Object.keys(projectCredentialReferences).length },
         "CredentialReferences retrieved for project"
       );
     } catch (error) {
-      logger12.warn(
+      logger13.warn(
         { tenantId, projectId, error },
         "Failed to retrieve credentialReferences for project"
       );
@@ -6789,7 +7242,7 @@ var getFullProject = (db, logger12 = defaultLogger2) => async (params) => {
     if (graphList.length > 0) {
       const graphPromises = graphList.map(async (graph) => {
         try {
-          logger12.info(
+          logger13.info(
             { tenantId, projectId, graphId: graph.id },
             "Retrieving full graph definition"
           );
@@ -6798,15 +7251,15 @@ var getFullProject = (db, logger12 = defaultLogger2) => async (params) => {
           });
           if (fullGraph) {
             graphs[graph.id] = fullGraph;
-            logger12.info(
+            logger13.info(
               { tenantId, projectId, graphId: graph.id },
               "Full graph definition retrieved"
             );
           } else {
-            logger12.warn({ tenantId, projectId, graphId: graph.id }, "Graph definition not found");
+            logger13.warn({ tenantId, projectId, graphId: graph.id }, "Graph definition not found");
           }
         } catch (error) {
-          logger12.error(
+          logger13.error(
             { tenantId, projectId, graphId: graph.id, error },
             "Failed to retrieve full graph definition"
           );
@@ -6833,7 +7286,7 @@ var getFullProject = (db, logger12 = defaultLogger2) => async (params) => {
       createdAt: project.createdAt,
       updatedAt: project.updatedAt
     };
-    logger12.info(
+    logger13.info(
       {
         tenantId,
         projectId,
@@ -6843,7 +7296,7 @@ var getFullProject = (db, logger12 = defaultLogger2) => async (params) => {
     );
     return fullProjectDefinition;
   } catch (error) {
-    logger12.error(
+    logger13.error(
       {
         tenantId,
         projectId,
@@ -6854,23 +7307,23 @@ var getFullProject = (db, logger12 = defaultLogger2) => async (params) => {
     throw error;
   }
 };
-var deleteFullProject = (db, logger12 = defaultLogger2) => async (params) => {
+var deleteFullProject = (db, logger13 = defaultLogger2) => async (params) => {
   const { scopes } = params;
   const { tenantId, projectId } = scopes;
-  logger12.info({ tenantId, projectId }, "Deleting full project and related entities");
+  logger13.info({ tenantId, projectId }, "Deleting full project and related entities");
   try {
     const project = await getFullProject(
       db,
-      logger12
+      logger13
     )({
       scopes: { tenantId, projectId }
     });
     if (!project) {
-      logger12.info({ tenantId, projectId }, "Project not found for deletion");
+      logger13.info({ tenantId, projectId }, "Project not found for deletion");
       return false;
     }
     if (project.graphs && Object.keys(project.graphs).length > 0) {
-      logger12.info(
+      logger13.info(
         {
           tenantId,
           projectId,
@@ -6880,19 +7333,19 @@ var deleteFullProject = (db, logger12 = defaultLogger2) => async (params) => {
       );
       const graphPromises = Object.keys(project.graphs).map(async (graphId) => {
         try {
-          logger12.info({ tenantId, projectId, graphId }, "Deleting graph from project");
+          logger13.info({ tenantId, projectId, graphId }, "Deleting graph from project");
           await deleteFullGraph(
             db,
-            logger12
+            logger13
           )({
             scopes: { tenantId, projectId, graphId }
           });
-          logger12.info(
+          logger13.info(
             { tenantId, projectId, graphId },
             "Graph deleted successfully from project"
           );
         } catch (error) {
-          logger12.error(
+          logger13.error(
             { tenantId, projectId, graphId, error },
             "Failed to delete graph from project"
           );
@@ -6900,7 +7353,7 @@ var deleteFullProject = (db, logger12 = defaultLogger2) => async (params) => {
         }
       });
       await Promise.all(graphPromises);
-      logger12.info(
+      logger13.info(
         {
           tenantId,
           projectId,
@@ -6913,13 +7366,13 @@ var deleteFullProject = (db, logger12 = defaultLogger2) => async (params) => {
       scopes: { tenantId, projectId }
     });
     if (!deleted) {
-      logger12.warn({ tenantId, projectId }, "Project deletion returned false");
+      logger13.warn({ tenantId, projectId }, "Project deletion returned false");
       return false;
     }
-    logger12.info({ tenantId, projectId }, "Full project deleted successfully");
+    logger13.info({ tenantId, projectId }, "Full project deleted successfully");
     return true;
   } catch (error) {
-    logger12.error(
+    logger13.error(
       {
         tenantId,
         projectId,
@@ -6997,7 +7450,7 @@ var createValidatedDataAccess = (db, dataAccessFunctions) => {
 
 // src/utils/tracer.ts
 var tracer = getTracer("agents-core");
-var logger6 = getLogger("context-cache");
+var logger7 = getLogger("context-cache");
 var ContextCache = class {
   constructor(tenantId, projectId, dbClient) {
     __publicField(this, "tenantId");
@@ -7006,7 +7459,7 @@ var ContextCache = class {
     this.tenantId = tenantId;
     this.projectId = projectId;
     this.dbClient = dbClient;
-    logger6.info(
+    logger7.info(
       {
         tenantId: this.tenantId
       },
@@ -7041,7 +7494,7 @@ var ContextCache = class {
         tenantId: this.tenantId
       };
     } catch (error) {
-      logger6.error(
+      logger7.error(
         {
           conversationId,
           contextConfigId,
@@ -7075,7 +7528,7 @@ var ContextCache = class {
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       await setCacheEntry(this.dbClient)(cacheData);
-      logger6.debug(
+      logger7.debug(
         {
           conversationId: entry.conversationId,
           contextConfigId: entry.contextConfigId,
@@ -7084,7 +7537,7 @@ var ContextCache = class {
         "Cache entry set successfully"
       );
     } catch (error) {
-      logger6.error(
+      logger7.error(
         {
           conversationId: entry.conversationId,
           contextConfigId: entry.contextConfigId,
@@ -7104,7 +7557,7 @@ var ContextCache = class {
         scopes: { tenantId, projectId },
         conversationId
       });
-      logger6.info(
+      logger7.info(
         {
           conversationId,
           rowsCleared: result
@@ -7112,7 +7565,7 @@ var ContextCache = class {
         "Conversation cache cleared successfully"
       );
     } catch (error) {
-      logger6.error(
+      logger7.error(
         {
           conversationId,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -7131,7 +7584,7 @@ var ContextCache = class {
         scopes: { tenantId, projectId },
         contextConfigId
       });
-      logger6.info(
+      logger7.info(
         {
           contextConfigId,
           rowsCleared: result
@@ -7139,7 +7592,7 @@ var ContextCache = class {
         "Context config cache cleared successfully"
       );
     } catch (error) {
-      logger6.error(
+      logger7.error(
         {
           contextConfigId,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -7157,14 +7610,14 @@ var ContextCache = class {
       const result = await cleanupTenantCache(this.dbClient)({
         scopes: { tenantId: this.tenantId, projectId: this.projectId }
       });
-      logger6.info(
+      logger7.info(
         {
           rowsCleared: result
         },
         "Cache cleanup completed"
       );
     } catch (error) {
-      logger6.error(
+      logger7.error(
         {
           error: error instanceof Error ? error.message : "Unknown error"
         },
@@ -7191,7 +7644,7 @@ var ContextCache = class {
 };
 
 // src/context/ContextResolver.ts
-var logger7 = getLogger("context-resolver");
+var logger8 = getLogger("context-resolver");
 var ContextResolver = class {
   constructor(tenantId, projectId, dbClient, credentialStoreRegistry) {
     __publicField(this, "fetcher");
@@ -7202,7 +7655,7 @@ var ContextResolver = class {
     this.projectId = projectId;
     this.fetcher = new ContextFetcher(tenantId, projectId, dbClient, credentialStoreRegistry);
     this.cache = new ContextCache(tenantId, projectId, dbClient);
-    logger7.info(
+    logger8.info(
       {
         tenantId: this.tenantId,
         hasCredentialSupport: !!credentialStoreRegistry
@@ -7215,7 +7668,7 @@ var ContextResolver = class {
    */
   async resolve(contextConfig2, options) {
     const startTime = Date.now();
-    logger7.info(
+    logger8.info(
       {
         contextConfigId: contextConfig2.id,
         triggerEvent: options.triggerEvent,
@@ -7255,7 +7708,7 @@ var ContextResolver = class {
               options.conversationId,
               contextConfig2.id
             );
-            logger7.info(
+            logger8.info(
               {
                 conversationId: options.conversationId,
                 contextConfigId: contextConfig2.id
@@ -7269,7 +7722,7 @@ var ContextResolver = class {
               value: options.headers,
               tenantId: this.tenantId
             });
-            logger7.info(
+            logger8.info(
               {
                 conversationId: options.conversationId,
                 contextConfigId: contextConfig2.id
@@ -7285,7 +7738,7 @@ var ContextResolver = class {
           const contextVariables = contextConfig2.contextVariables || {};
           const contextVariableEntries = Object.entries(contextVariables);
           if (contextVariableEntries.length === 0) {
-            logger7.info(
+            logger8.info(
               {
                 contextConfigId: contextConfig2.id
               },
@@ -7321,7 +7774,7 @@ var ContextResolver = class {
               result
             ).catch((error) => {
               const errorMessage = error instanceof Error ? error.message : "Unknown error";
-              logger7.error(
+              logger8.error(
                 {
                   contextConfigId: contextConfig2.id,
                   definitionId: definition.id,
@@ -7336,7 +7789,7 @@ var ContextResolver = class {
               });
               if (definition.defaultValue !== void 0) {
                 result.resolvedContext[templateKey] = definition.defaultValue;
-                logger7.info(
+                logger8.info(
                   {
                     contextConfigId: contextConfig2.id,
                     definitionId: definition.id,
@@ -7361,7 +7814,7 @@ var ContextResolver = class {
           } else {
             parentSpan.setStatus({ code: SpanStatusCode.OK });
           }
-          logger7.info(
+          logger8.info(
             {
               contextConfigId: contextConfig2.id,
               resolvedKeys: Object.keys(result.resolvedContext),
@@ -7377,7 +7830,7 @@ var ContextResolver = class {
         } catch (error) {
           const durationMs = Date.now() - startTime;
           setSpanWithError(parentSpan, error instanceof Error ? error : new Error(String(error)));
-          logger7.error(
+          logger8.error(
             {
               contextConfigId: contextConfig2.id,
               error: error instanceof Error ? error.message : String(error),
@@ -7405,7 +7858,7 @@ var ContextResolver = class {
     if (cachedEntry) {
       result.resolvedContext[templateKey] = cachedEntry.value;
       result.cacheHits.push(definition.id);
-      logger7.debug(
+      logger8.debug(
         {
           definitionId: definition.id,
           templateKey,
@@ -7416,7 +7869,7 @@ var ContextResolver = class {
       return;
     }
     result.cacheMisses.push(definition.id);
-    logger7.debug(
+    logger8.debug(
       {
         definitionId: definition.id,
         templateKey,
@@ -7473,7 +7926,7 @@ var ContextResolver = class {
       requestHash,
       tenantId: this.tenantId
     });
-    logger7.debug(
+    logger8.debug(
       {
         definitionId: definition.id,
         templateKey,
@@ -7508,7 +7961,7 @@ var ContextResolver = class {
    */
   async clearCache(tenantId, projectId, conversationId) {
     await this.cache.clearConversation(tenantId, projectId, conversationId);
-    logger7.info(
+    logger8.info(
       {
         conversationId
       },
@@ -7518,7 +7971,7 @@ var ContextResolver = class {
 };
 
 // src/middleware/contextValidation.ts
-var logger8 = getLogger("context-validation");
+var logger9 = getLogger("context-validation");
 var ajv = new Ajv({ allErrors: true, strict: false });
 var HTTP_REQUEST_PARTS = ["headers"];
 var MAX_SCHEMA_CACHE_SIZE = 1e3;
@@ -7581,7 +8034,7 @@ function validationHelper(jsonSchema) {
   return getCachedValidator(jsonSchema);
 }
 function validateAgainstJsonSchema(jsonSchema, context) {
-  logger8.debug({ jsonSchema, context }, "Validating context against JSON Schema");
+  logger9.debug({ jsonSchema, context }, "Validating context against JSON Schema");
   const validate = validationHelper(jsonSchema);
   return validate(context);
 }
@@ -7671,7 +8124,7 @@ async function validateHttpRequestHeaders(headersSchema, httpRequest) {
       validatedContext: filteredContext
     };
   } catch (error) {
-    logger8.error(
+    logger9.error(
       { error: error instanceof Error ? error.message : "Unknown error" },
       "Failed to validate headers schema"
     );
@@ -7724,7 +8177,7 @@ async function validateHeaders({
       scopes: { tenantId, projectId, graphId }
     });
     if (!agentGraph2?.contextConfigId) {
-      logger8.debug({ graphId }, "No context config found for graph, skipping validation");
+      logger9.debug({ graphId }, "No context config found for graph, skipping validation");
       return {
         valid: true,
         errors: [],
@@ -7736,7 +8189,7 @@ async function validateHeaders({
       id: agentGraph2.contextConfigId
     });
     if (!contextConfig2) {
-      logger8.warn({ contextConfigId: agentGraph2.contextConfigId }, "Context config not found");
+      logger9.warn({ contextConfigId: agentGraph2.contextConfigId }, "Context config not found");
       return {
         valid: false,
         errors: [
@@ -7748,7 +8201,7 @@ async function validateHeaders({
       };
     }
     if (!contextConfig2.headersSchema) {
-      logger8.debug(
+      logger9.debug(
         { contextConfigId: contextConfig2.id },
         "No headers schema defined, accepting any context"
       );
@@ -7760,7 +8213,7 @@ async function validateHeaders({
     }
     try {
       const schema = contextConfig2.headersSchema;
-      logger8.debug({ contextConfigId: contextConfig2.id }, "Using headers schema validation");
+      logger9.debug({ contextConfigId: contextConfig2.id }, "Using headers schema validation");
       const httpRequest = parsedRequest;
       const validationResult = await validateHttpRequestHeaders(schema, httpRequest);
       if (validationResult.valid) {
@@ -7783,7 +8236,7 @@ async function validateHeaders({
         return validationResult;
       }
     } catch (error) {
-      logger8.error(
+      logger9.error(
         {
           contextConfigId: contextConfig2.id,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -7801,7 +8254,7 @@ async function validateHeaders({
       };
     }
   } catch (error) {
-    logger8.error(
+    logger9.error(
       {
         tenantId,
         graphId,
@@ -7853,7 +8306,7 @@ function contextValidationMiddleware(dbClient) {
         credentialStores
       });
       if (!validationResult.valid) {
-        logger8.warn(
+        logger9.warn(
           {
             tenantId,
             graphId,
@@ -7868,7 +8321,7 @@ function contextValidationMiddleware(dbClient) {
         });
       }
       c.set("validatedContext", validationResult.validatedContext);
-      logger8.debug(
+      logger9.debug(
         {
           tenantId,
           graphId,
@@ -7878,7 +8331,7 @@ function contextValidationMiddleware(dbClient) {
       );
       return next();
     } catch (error) {
-      logger8.error(
+      logger9.error(
         {
           error: error instanceof Error ? error.message : "Unknown error"
         },
@@ -7893,7 +8346,7 @@ function contextValidationMiddleware(dbClient) {
 }
 
 // src/context/ContextFetcher.ts
-var logger9 = getLogger("context-fetcher");
+var logger10 = getLogger("context-fetcher");
 var checkGraphQLErrors = (data) => {
   if (data && typeof data === "object" && "errors" in data) {
     const errorObj = data;
@@ -7922,7 +8375,7 @@ var ContextFetcher = class {
       this.credentialStuffer = new CredentialStuffer(credentialStoreRegistry);
     }
     this.dbClient = dbClient;
-    logger9.info(
+    logger10.info(
       {
         tenantId: this.tenantId,
         defaultTimeout: this.defaultTimeout,
@@ -7936,7 +8389,7 @@ var ContextFetcher = class {
    */
   async fetch(definition, context) {
     const startTime = Date.now();
-    logger9.info(
+    logger10.info(
       {
         definitionId: definition.id,
         url: definition.fetchConfig.url
@@ -7950,7 +8403,7 @@ var ContextFetcher = class {
         definition.credentialReferenceId
       );
       const response = await this.performRequest(resolvedConfig);
-      logger9.info({ response }, "ContextFetcher Response");
+      logger10.info({ response }, "ContextFetcher Response");
       let transformedData = response.data;
       if (definition.fetchConfig.transform) {
         transformedData = this.transformResponse(response.data, definition.fetchConfig.transform);
@@ -7963,7 +8416,7 @@ var ContextFetcher = class {
         );
       }
       const durationMs = Date.now() - startTime;
-      logger9.info(
+      logger10.info(
         {
           definitionId: definition.id,
           source: response.source,
@@ -7975,7 +8428,7 @@ var ContextFetcher = class {
     } catch (error) {
       const durationMs = Date.now() - startTime;
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      logger9.error(
+      logger10.error(
         {
           definitionId: definition.id,
           error: errorMessage,
@@ -7992,7 +8445,7 @@ var ContextFetcher = class {
         scopes: { tenantId: this.tenantId, projectId: this.projectId },
         id: credentialReferenceId
       });
-      logger9.info({ credentialReference }, "Credential reference");
+      logger10.info({ credentialReference }, "Credential reference");
       if (!credentialReference || !this.credentialStuffer) {
         throw new Error(`Credential store not found for reference ID: ${credentialReferenceId}`);
       }
@@ -8010,7 +8463,7 @@ var ContextFetcher = class {
       );
       return credentialData;
     } catch (error) {
-      logger9.error(
+      logger10.error(
         {
           credentialReferenceId,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -8026,7 +8479,7 @@ var ContextFetcher = class {
   async resolveTemplateVariables(fetchConfig, context, credentialReferenceId) {
     const resolved = { ...fetchConfig };
     resolved.url = this.interpolateTemplate(fetchConfig.url, context);
-    logger9.info({ resolvedUrl: resolved.url }, "Resolved URL");
+    logger10.info({ resolvedUrl: resolved.url }, "Resolved URL");
     if (fetchConfig.headers) {
       resolved.headers = {};
       for (const [key, value] of Object.entries(fetchConfig.headers)) {
@@ -8045,7 +8498,7 @@ var ContextFetcher = class {
             ...resolved.headers,
             ...credentialHeaders
           };
-          logger9.info(
+          logger10.info(
             {
               credentialReferenceId
             },
@@ -8053,7 +8506,7 @@ var ContextFetcher = class {
           );
         }
       } catch (error) {
-        logger9.error(
+        logger10.error(
           {
             credentialReferenceId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -8075,7 +8528,7 @@ var ContextFetcher = class {
         preserveUnresolved: true
       });
     } catch (error) {
-      logger9.error(
+      logger10.error(
         {
           template,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -8107,7 +8560,7 @@ var ContextFetcher = class {
   async performRequest(config) {
     const startTime = Date.now();
     try {
-      logger9.debug(
+      logger10.debug(
         {
           url: config.url,
           method: config.method
@@ -8144,7 +8597,7 @@ var ContextFetcher = class {
     } catch (error) {
       const durationMs = Date.now() - startTime;
       const requestError = error instanceof Error ? error : new Error("Unknown error");
-      logger9.warn(
+      logger10.warn(
         {
           url: config.url,
           error: requestError.message,
@@ -8163,7 +8616,7 @@ var ContextFetcher = class {
       const result = jmespath.search(data, transform);
       return result;
     } catch (error) {
-      logger9.error(
+      logger10.error(
         {
           transform,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -8182,7 +8635,7 @@ var ContextFetcher = class {
       if (!isValid) {
         throw new Error("Data does not match JSON Schema");
       }
-      logger9.debug(
+      logger10.debug(
         {
           definitionId,
           dataType: typeof data,
@@ -8192,7 +8645,7 @@ var ContextFetcher = class {
       );
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown validation error";
-      logger9.error(
+      logger10.error(
         {
           definitionId,
           jsonSchema,
@@ -8233,7 +8686,7 @@ var ContextFetcher = class {
     };
   }
 };
-var logger10 = getLogger("context");
+var logger11 = getLogger("context");
 async function determineContextTrigger(tenantId, projectId, conversationId, dbClient) {
   const conversation = await getConversation(dbClient)({
     scopes: { tenantId, projectId },
@@ -8253,7 +8706,7 @@ async function handleContextConfigChange(tenantId, projectId, conversationId, gr
   if (conversation.lastContextResolution) {
     const contextResolver = new ContextResolver(tenantId, projectId, dbClient, credentialStores);
     await contextResolver.clearCache(tenantId, projectId, conversationId);
-    logger10.info(
+    logger11.info(
       {
         conversationId,
         graphId,
@@ -8287,7 +8740,7 @@ async function handleContextResolution({
           scopes: { tenantId, projectId, graphId }
         });
         if (!agentGraph2?.contextConfigId) {
-          logger10.debug({ graphId }, "No context config found for graph");
+          logger11.debug({ graphId }, "No context config found for graph");
           return null;
         }
         await handleContextConfigChange(
@@ -8305,7 +8758,7 @@ async function handleContextResolution({
           id: agentGraph2.contextConfigId
         });
         if (!contextConfig2) {
-          logger10.warn(
+          logger11.warn(
             { contextConfigId: agentGraph2.contextConfigId },
             "Context config not found, proceeding without context resolution"
           );
@@ -8347,7 +8800,7 @@ async function handleContextResolution({
         } else {
           parentSpan.setStatus({ code: SpanStatusCode.OK });
         }
-        logger10.info(
+        logger11.info(
           {
             conversationId,
             graphId,
@@ -8369,7 +8822,7 @@ async function handleContextResolution({
           "context.error_message": errorMessage
         });
         setSpanWithError(parentSpan, error instanceof Error ? error : new Error(String(error)));
-        logger10.error(
+        logger11.error(
           {
             error: errorMessage,
             contextConfigId: agentGraph2?.contextConfigId,
@@ -8710,7 +9163,7 @@ var InMemoryCredentialStore = class {
     return this.credentials.delete(key);
   }
 };
-var logger11 = getLogger("nango-credential-store");
+var logger12 = getLogger("nango-credential-store");
 var CredentialKeySchema = z$1.object({
   connectionId: z$1.string().min(1, "connectionId must be a non-empty string"),
   providerConfigKey: z$1.string().min(1, "providerConfigKey must be a non-empty string")
@@ -8850,7 +9303,7 @@ var NangoCredentialStore = class {
       if (error && typeof error === "object" && "status" in error && error.status === 404) {
         return null;
       }
-      logger11.error(
+      logger12.error(
         { error: error instanceof Error ? error.message : "Unknown error", uniqueKey },
         `Failed to fetch integration ${uniqueKey}`
       );
@@ -8876,7 +9329,7 @@ var NangoCredentialStore = class {
     });
     const result = JSON.stringify(essential);
     if (result.length > 1024) {
-      logger11.error(
+      logger12.error(
         {
           originalLength: tokenData.length,
           essentialLength: result.length,
@@ -8950,7 +9403,7 @@ var NangoCredentialStore = class {
         );
       }
     } catch (error) {
-      logger11.error(
+      logger12.error(
         {
           error: error instanceof Error ? error.message : "Unknown error",
           name
@@ -8985,7 +9438,7 @@ var NangoCredentialStore = class {
       };
       return credentialData;
     } catch (error) {
-      logger11.error(
+      logger12.error(
         {
           error: error instanceof Error ? error.message : "Unknown error",
           connectionId,
@@ -9006,7 +9459,7 @@ var NangoCredentialStore = class {
       try {
         parsedKey = JSON.parse(key);
       } catch (parseError) {
-        logger11.warn(
+        logger12.warn(
           {
             storeId: this.id,
             key: key.substring(0, 50),
@@ -9019,7 +9472,7 @@ var NangoCredentialStore = class {
       }
       const validationResult = CredentialKeySchema.safeParse(parsedKey);
       if (!validationResult.success) {
-        logger11.warn(
+        logger12.warn(
           {
             storeId: this.id,
             key: key.substring(0, 100),
@@ -9037,7 +9490,7 @@ var NangoCredentialStore = class {
       const credentialString = JSON.stringify(credentials);
       return credentialString;
     } catch (error) {
-      logger11.error(
+      logger12.error(
         {
           storeId: this.id,
           key: key.substring(0, 100),
@@ -9066,7 +9519,7 @@ var NangoCredentialStore = class {
       const credentials = await this.get(key);
       return credentials !== null;
     } catch (error) {
-      logger11.error(
+      logger12.error(
         {
           error: error instanceof Error ? error.message : "Unknown error",
           key
@@ -9085,7 +9538,7 @@ var NangoCredentialStore = class {
       try {
         parsedKey = JSON.parse(key);
       } catch (parseError) {
-        logger11.warn(
+        logger12.warn(
           {
             storeId: this.id,
             key: key.substring(0, 50),
@@ -9098,7 +9551,7 @@ var NangoCredentialStore = class {
       }
       const validationResult = CredentialKeySchema.safeParse(parsedKey);
       if (!validationResult.success) {
-        logger11.warn(
+        logger12.warn(
           {
             storeId: this.id,
             key: key.substring(0, 100),
@@ -9112,7 +9565,7 @@ var NangoCredentialStore = class {
       await this.nangoClient.deleteConnection(providerConfigKey, connectionId);
       return true;
     } catch (error) {
-      logger11.error(
+      logger12.error(
         {
           storeId: this.id,
           key: key.substring(0, 100),
@@ -9212,4 +9665,4 @@ ${error.message}`
 };
 parseEnv();
 
-export { ContextCache, ContextConfigBuilder, ContextFetcher, ContextResolver, CredentialStoreRegistry, CredentialStuffer, ERROR_DOCS_BASE_URL, ErrorCode, HTTP_REQUEST_PARTS, InMemoryCredentialStore, KeyChainStore, McpClient, NangoCredentialStore, TemplateEngine, addLedgerArtifacts, addToolToAgent, apiFetch, associateArtifactComponentWithAgent, associateDataComponentWithAgent, cleanupTenantCache, clearContextConfigCache, clearConversationCache, commonCreateErrorResponses, commonDeleteErrorResponses, commonGetErrorResponses, commonUpdateErrorResponses, contextConfig, contextValidationMiddleware, countApiKeys, countArtifactComponents, countArtifactComponentsForAgent, countContextConfigs, countCredentialReferences, countDataComponents, countExternalAgents, countLedgerArtifactsByTask, countMessagesByConversation, countProjects, createAgentGraph, createAgentToolRelation, createApiError, createApiKey, createArtifactComponent, createContextConfig, createConversation, createCredentialReference, createDataComponent, createDatabaseClient, createDefaultCredentialStores, createExecutionContext, createExternalAgent, createExternalAgentRelation, createFullGraphServerSide, createFullProjectServerSide, createInMemoryDatabaseClient, createKeyChainStore, createMessage, createNangoCredentialStore, createOrGetConversation, createProject, createSubAgent, createSubAgentRelation, createTask, createTool, createValidatedDataAccess, dbResultToMcpTool, deleteAgentArtifactComponentRelationByAgent, deleteAgentDataComponentRelationByAgent, deleteAgentGraph, deleteAgentRelationsByGraph, deleteAgentToolRelation, deleteAgentToolRelationByAgent, deleteApiKey, deleteArtifactComponent, deleteContextConfig, deleteConversation, deleteCredentialReference, deleteDataComponent, deleteExternalAgent, deleteFullGraph, deleteFullProject, deleteFunction, deleteLedgerArtifactsByContext, deleteLedgerArtifactsByTask, deleteMessage, deleteProject, deleteSubAgent, deleteSubAgentRelation, deleteTool, detectAuthenticationRequired, determineContextTrigger, discoverOAuthEndpoints, errorResponseSchema, errorSchemaFactory, externalAgentExists, externalAgentUrlExists, extractPublicId, fetchComponentRelationships, fetchDefinition, generateAndCreateApiKey, generateApiKey, generateId, getActiveAgentForConversation, getAgentGraphById, getAgentGraphWithDefaultSubAgent, getAgentRelationById, getAgentRelationByParams, getAgentRelations, getAgentRelationsByGraph, getAgentRelationsBySource, getAgentRelationsByTarget, getAgentToolRelationByAgent, getAgentToolRelationById, getAgentToolRelationByTool, getAgentsForTool, getAgentsUsingArtifactComponent, getAgentsUsingDataComponent, getApiKeyById, getApiKeyByPublicId, getArtifactComponentById, getArtifactComponentsForAgent, getCacheEntry, getCachedValidator, getContextConfigById, getContextConfigCacheEntries, getConversation, getConversationCacheEntries, getConversationHistory, getConversationId, getCredentialReference, getCredentialReferenceById, getCredentialReferenceWithTools, getCredentialStoreLookupKeyFromRetrievalParams, getDataComponent, getDataComponentsForAgent, getExternalAgent, getExternalAgentByUrl, getExternalAgentRelations, getFullGraph, getFullGraphDefinition, getFullProject, getFunction, getGraphAgentInfos, getLedgerArtifacts, getLedgerArtifactsByContext, getMessageById, getMessagesByConversation, getMessagesByTask, getProject, getProjectResourceCounts, getRelatedAgentsForGraph, getRequestExecutionContext, getSubAgentById, getSubAgentsByIds, getTask, getToolById, getToolsForAgent, getTracer, getVisibleMessages, graphHasArtifactComponents, handleApiError, handleContextConfigChange, handleContextResolution, hasApiKey, hasContextConfig, hasCredentialReference, hashApiKey, headers, invalidateHeadersCache, invalidateInvocationDefinitionsCache, isApiKeyExpired, isArtifactComponentAssociatedWithAgent, isDataComponentAssociatedWithAgent, isValidHttpRequest, listAgentGraphs, listAgentGraphsPaginated, listAgentRelations, listAgentToolRelations, listApiKeys, listApiKeysPaginated, listArtifactComponents, listArtifactComponentsPaginated, listContextConfigs, listContextConfigsPaginated, listConversations, listCredentialReferences, listCredentialReferencesPaginated, listDataComponents, listDataComponentsPaginated, listExternalAgents, listExternalAgentsPaginated, listFunctions, listMessages, listProjects, listProjectsPaginated, listSubAgents, listSubAgentsPaginated, listTaskIdsByContextId, listTools, loadEnvironmentFiles, maskApiKey, problemDetailsSchema, projectExists, projectExistsInTable, projectHasResources, removeArtifactComponentFromAgent, removeDataComponentFromAgent, removeToolFromAgent, setActiveAgentForConversation, setActiveAgentForThread, setCacheEntry, setSpanWithError, updateAgentGraph, updateAgentRelation, updateAgentToolRelation, updateApiKey, updateApiKeyLastUsed, updateArtifactComponent, updateContextConfig, updateConversation, updateConversationActiveAgent, updateCredentialReference, updateDataComponent, updateExternalAgent, updateFullGraphServerSide, updateFullProjectServerSide, updateMessage, updateProject, updateSubAgent, updateTask, updateTool, upsertAgentArtifactComponentRelation, upsertAgentDataComponentRelation, upsertAgentGraph, upsertAgentRelation, upsertAgentToolRelation, upsertArtifactComponent, upsertContextConfig, upsertCredentialReference, upsertDataComponent, upsertExternalAgent, upsertFunction, upsertLedgerArtifact, upsertSubAgent, upsertTool, validateAgainstJsonSchema, validateAndGetApiKey, validateApiKey, validateExternalAgent, validateHeaders, validateHttpRequestHeaders, validateInternalSubAgent, validateProjectExists, validationHelper, withProjectValidation };
+export { ContextCache, ContextConfigBuilder, ContextFetcher, ContextResolver, CredentialStoreRegistry, CredentialStuffer, ERROR_DOCS_BASE_URL, ErrorCode, HTTP_REQUEST_PARTS, InMemoryCredentialStore, KeyChainStore, McpClient, NangoCredentialStore, TemplateEngine, addFunctionToolToSubAgent, addLedgerArtifacts, addToolToAgent, apiFetch, associateArtifactComponentWithAgent, associateDataComponentWithAgent, cleanupTenantCache, clearContextConfigCache, clearConversationCache, commonCreateErrorResponses, commonDeleteErrorResponses, commonGetErrorResponses, commonUpdateErrorResponses, contextConfig, contextValidationMiddleware, countApiKeys, countArtifactComponents, countArtifactComponentsForAgent, countContextConfigs, countCredentialReferences, countDataComponents, countExternalAgents, countLedgerArtifactsByTask, countMessagesByConversation, countProjects, createAgentGraph, createAgentToolRelation, createApiError, createApiKey, createArtifactComponent, createContextConfig, createConversation, createCredentialReference, createDataComponent, createDatabaseClient, createDefaultCredentialStores, createExecutionContext, createExternalAgent, createExternalAgentRelation, createFullGraphServerSide, createFullProjectServerSide, createFunctionTool, createInMemoryDatabaseClient, createKeyChainStore, createMessage, createNangoCredentialStore, createOrGetConversation, createProject, createSubAgent, createSubAgentRelation, createTask, createTool, createValidatedDataAccess, dbResultToMcpTool, deleteAgentArtifactComponentRelationByAgent, deleteAgentDataComponentRelationByAgent, deleteAgentGraph, deleteAgentRelationsByGraph, deleteAgentToolRelation, deleteAgentToolRelationByAgent, deleteApiKey, deleteArtifactComponent, deleteContextConfig, deleteConversation, deleteCredentialReference, deleteDataComponent, deleteExternalAgent, deleteFullGraph, deleteFullProject, deleteFunction, deleteFunctionTool, deleteLedgerArtifactsByContext, deleteLedgerArtifactsByTask, deleteMessage, deleteProject, deleteSubAgent, deleteSubAgentRelation, deleteTool, detectAuthenticationRequired, determineContextTrigger, discoverOAuthEndpoints, errorResponseSchema, errorSchemaFactory, externalAgentExists, externalAgentUrlExists, extractPublicId, fetchComponentRelationships, fetchDefinition, generateAndCreateApiKey, generateApiKey, generateId, getActiveAgentForConversation, getAgentGraphById, getAgentGraphWithDefaultSubAgent, getAgentRelationById, getAgentRelationByParams, getAgentRelations, getAgentRelationsByGraph, getAgentRelationsBySource, getAgentRelationsByTarget, getAgentToolRelationByAgent, getAgentToolRelationById, getAgentToolRelationByTool, getAgentsForTool, getAgentsUsingArtifactComponent, getAgentsUsingDataComponent, getApiKeyById, getApiKeyByPublicId, getArtifactComponentById, getArtifactComponentsForAgent, getCacheEntry, getCachedValidator, getContextConfigById, getContextConfigCacheEntries, getConversation, getConversationCacheEntries, getConversationHistory, getConversationId, getCredentialReference, getCredentialReferenceById, getCredentialReferenceWithTools, getCredentialStoreLookupKeyFromRetrievalParams, getDataComponent, getDataComponentsForAgent, getExternalAgent, getExternalAgentByUrl, getExternalAgentRelations, getFullGraph, getFullGraphDefinition, getFullProject, getFunction, getFunctionToolById, getFunctionToolsForSubAgent, getGraphAgentInfos, getLedgerArtifacts, getLedgerArtifactsByContext, getMessageById, getMessagesByConversation, getMessagesByTask, getProject, getProjectResourceCounts, getRelatedAgentsForGraph, getRequestExecutionContext, getSubAgentById, getSubAgentsByIds, getTask, getToolById, getToolsForAgent, getTracer, getVisibleMessages, graphHasArtifactComponents, handleApiError, handleContextConfigChange, handleContextResolution, hasApiKey, hasContextConfig, hasCredentialReference, hashApiKey, headers, invalidateHeadersCache, invalidateInvocationDefinitionsCache, isApiKeyExpired, isArtifactComponentAssociatedWithAgent, isDataComponentAssociatedWithAgent, isValidHttpRequest, listAgentGraphs, listAgentGraphsPaginated, listAgentRelations, listAgentToolRelations, listApiKeys, listApiKeysPaginated, listArtifactComponents, listArtifactComponentsPaginated, listContextConfigs, listContextConfigsPaginated, listConversations, listCredentialReferences, listCredentialReferencesPaginated, listDataComponents, listDataComponentsPaginated, listExternalAgents, listExternalAgentsPaginated, listFunctionTools, listFunctions, listMessages, listProjects, listProjectsPaginated, listSubAgents, listSubAgentsPaginated, listTaskIdsByContextId, listTools, loadEnvironmentFiles, maskApiKey, problemDetailsSchema, projectExists, projectExistsInTable, projectHasResources, removeArtifactComponentFromAgent, removeDataComponentFromAgent, removeToolFromAgent, setActiveAgentForConversation, setActiveAgentForThread, setCacheEntry, setSpanWithError, updateAgentGraph, updateAgentRelation, updateAgentToolRelation, updateApiKey, updateApiKeyLastUsed, updateArtifactComponent, updateContextConfig, updateConversation, updateConversationActiveAgent, updateCredentialReference, updateDataComponent, updateExternalAgent, updateFullGraphServerSide, updateFullProjectServerSide, updateFunctionTool, updateMessage, updateProject, updateSubAgent, updateSubAgentFunctionToolRelation, updateTask, updateTool, upsertAgentArtifactComponentRelation, upsertAgentDataComponentRelation, upsertAgentGraph, upsertAgentRelation, upsertArtifactComponent, upsertContextConfig, upsertCredentialReference, upsertDataComponent, upsertExternalAgent, upsertFunction, upsertFunctionTool, upsertLedgerArtifact, upsertSubAgent, upsertSubAgentFunctionToolRelation, upsertSubAgentToolRelation, upsertTool, validateAgainstJsonSchema, validateAndGetApiKey, validateApiKey, validateExternalAgent, validateHeaders, validateHttpRequestHeaders, validateInternalSubAgent, validateProjectExists, validationHelper, withProjectValidation };