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

package/dist/index.cjs

@@ -465,22 +465,22 @@ var LoggerFactory = class {
    */
   getLogger(name) {
     if (this.loggers.has(name)) {
-      const logger14 = this.loggers.get(name);
-      if (!logger14) {
+      const logger15 = this.loggers.get(name);
+      if (!logger15) {
         throw new Error(`Logger '${name}' not found in cache`);
       }
-      return logger14;
+      return logger15;
     }
-    let logger13;
+    let logger14;
     if (this.config.loggerFactory) {
-      logger13 = this.config.loggerFactory(name);
+      logger14 = this.config.loggerFactory(name);
     } else if (this.config.defaultLogger) {
-      logger13 = this.config.defaultLogger;
+      logger14 = this.config.defaultLogger;
     } else {
-      logger13 = new PinoLogger(name, this.config.pinoConfig);
+      logger14 = new PinoLogger(name, this.config.pinoConfig);
     }
-    this.loggers.set(name, logger13);
-    return logger13;
+    this.loggers.set(name, logger14);
+    return logger14;
   }
   /**
    * Reset factory to default state
@@ -556,6 +556,8 @@ function extractPreviewFields(schema) {
 // src/db/schema.ts
 var schema_exports = {};
 __export(schema_exports, {
+  agentFunctionToolRelations: () => agentFunctionToolRelations,
+  agentFunctionToolRelationsRelations: () => agentFunctionToolRelationsRelations,
   agentGraph: () => agentGraph,
   agentGraphRelations: () => agentGraphRelations,
   agentToolRelationsRelations: () => agentToolRelationsRelations,
@@ -575,6 +577,8 @@ __export(schema_exports, {
   dataComponentsRelations: () => dataComponentsRelations,
   externalAgents: () => externalAgents,
   externalAgentsRelations: () => externalAgentsRelations,
+  functionTools: () => functionTools,
+  functionToolsRelations: () => functionToolsRelations,
   functions: () => functions,
   functionsRelations: () => functionsRelations,
   ledgerArtifacts: () => ledgerArtifacts,
@@ -925,10 +929,7 @@ var tools = sqliteCore.sqliteTable(
     ...projectScoped,
     name: sqliteCore.text("name").notNull(),
     description: sqliteCore.text("description"),
-    // Tool configuration - supports both MCP and function tools
     config: sqliteCore.blob("config", { mode: "json" }).$type().notNull(),
-    // For function tools, reference the global functions table
-    functionId: sqliteCore.text("function_id"),
     credentialReferenceId: sqliteCore.text("credential_reference_id"),
     headers: sqliteCore.blob("headers", { mode: "json" }).$type(),
     // Image URL for custom tool icon (supports regular URLs and base64 encoded images)
@@ -944,12 +945,30 @@ var tools = sqliteCore.sqliteTable(
       columns: [table.tenantId, table.projectId],
       foreignColumns: [projects.tenantId, projects.id],
       name: "tools_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var functionTools = sqliteCore.sqliteTable(
+  "function_tools",
+  {
+    ...graphScoped,
+    name: sqliteCore.text("name").notNull(),
+    description: sqliteCore.text("description"),
+    functionId: sqliteCore.text("function_id").notNull(),
+    ...timestamps
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.graphId],
+      foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
+      name: "function_tools_graph_fk"
     }).onDelete("cascade"),
-    // Foreign key constraint to functions table (for function tools)
+    // Foreign key constraint to functions table
     sqliteCore.foreignKey({
       columns: [table.tenantId, table.projectId, table.functionId],
       foreignColumns: [functions.tenantId, functions.projectId, functions.id],
-      name: "tools_function_fk"
+      name: "function_tools_function_fk"
     }).onDelete("cascade")
   ]
 );
@@ -988,7 +1007,7 @@ var subAgentToolRelations = sqliteCore.sqliteTable(
       foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.graphId, subAgents.id],
       name: "sub_agent_tool_relations_agent_fk"
     }).onDelete("cascade"),
-    // Foreign key constraint to tools table
+    // Foreign key constraint to tools table (MCP tools)
     sqliteCore.foreignKey({
       columns: [table.tenantId, table.projectId, table.toolId],
       foreignColumns: [tools.tenantId, tools.projectId, tools.id],
@@ -996,6 +1015,34 @@ var subAgentToolRelations = sqliteCore.sqliteTable(
     }).onDelete("cascade")
   ]
 );
+var agentFunctionToolRelations = sqliteCore.sqliteTable(
+  "agent_function_tool_relations",
+  {
+    ...subAgentScoped,
+    functionToolId: sqliteCore.text("function_tool_id").notNull(),
+    ...timestamps
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
+    // Foreign key constraint to agents table
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.graphId, subAgents.id],
+      name: "agent_function_tool_relations_agent_fk"
+    }).onDelete("cascade"),
+    // Foreign key constraint to functionTools table
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.graphId, table.functionToolId],
+      foreignColumns: [
+        functionTools.tenantId,
+        functionTools.projectId,
+        functionTools.graphId,
+        functionTools.id
+      ],
+      name: "agent_function_tool_relations_function_tool_fk"
+    }).onDelete("cascade")
+  ]
+);
 var conversations = sqliteCore.sqliteTable(
   "conversations",
   {
@@ -1181,6 +1228,7 @@ var projectsRelations = drizzleOrm.relations(projects, ({ many }) => ({
   subAgents: many(subAgents),
   agentGraphs: many(agentGraph),
   tools: many(tools),
+  functions: many(functions),
   contextConfigs: many(contextConfigs),
   externalAgents: many(externalAgents),
   conversations: many(conversations),
@@ -1239,10 +1287,11 @@ var subAgentsRelations = drizzleOrm.relations(subAgents, ({ many, one }) => ({
     relationName: "associatedAgent"
   }),
   toolRelations: many(subAgentToolRelations),
+  functionToolRelations: many(agentFunctionToolRelations),
   dataComponentRelations: many(subAgentDataComponents),
   artifactComponentRelations: many(subAgentArtifactComponents)
 }));
-var agentGraphRelations = drizzleOrm.relations(agentGraph, ({ one }) => ({
+var agentGraphRelations = drizzleOrm.relations(agentGraph, ({ one, many }) => ({
   project: one(projects, {
     fields: [agentGraph.tenantId, agentGraph.projectId],
     references: [projects.tenantId, projects.id]
@@ -1254,7 +1303,8 @@ var agentGraphRelations = drizzleOrm.relations(agentGraph, ({ one }) => ({
   contextConfig: one(contextConfigs, {
     fields: [agentGraph.contextConfigId],
     references: [contextConfigs.id]
-  })
+  }),
+  functionTools: many(functionTools)
 }));
 var externalAgentsRelations = drizzleOrm.relations(externalAgents, ({ one, many }) => ({
   project: one(projects, {
@@ -1299,10 +1349,6 @@ var toolsRelations = drizzleOrm.relations(tools, ({ one, many }) => ({
   credentialReference: one(credentialReferences, {
     fields: [tools.credentialReferenceId],
     references: [credentialReferences.id]
-  }),
-  function: one(functions, {
-    fields: [tools.functionId],
-    references: [functions.id]
   })
 }));
 var conversationsRelations = drizzleOrm.relations(conversations, ({ one, many }) => ({
@@ -1402,7 +1448,7 @@ var ledgerArtifactsRelations = drizzleOrm.relations(ledgerArtifacts, ({ one }) =
   })
 }));
 var functionsRelations = drizzleOrm.relations(functions, ({ many }) => ({
-  tools: many(tools)
+  functionTools: many(functionTools)
 }));
 var subAgentRelationsRelations = drizzleOrm.relations(subAgentRelations, ({ one }) => ({
   graph: one(agentGraph, {
@@ -1424,6 +1470,34 @@ var subAgentRelationsRelations = drizzleOrm.relations(subAgentRelations, ({ one
     references: [externalAgents.id]
   })
 }));
+var functionToolsRelations = drizzleOrm.relations(functionTools, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [functionTools.tenantId, functionTools.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  graph: one(agentGraph, {
+    fields: [functionTools.tenantId, functionTools.projectId, functionTools.graphId],
+    references: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id]
+  }),
+  function: one(functions, {
+    fields: [functionTools.tenantId, functionTools.projectId, functionTools.functionId],
+    references: [functions.tenantId, functions.projectId, functions.id]
+  }),
+  agentRelations: many(agentFunctionToolRelations)
+}));
+var agentFunctionToolRelationsRelations = drizzleOrm.relations(
+  agentFunctionToolRelations,
+  ({ one }) => ({
+    agent: one(subAgents, {
+      fields: [agentFunctionToolRelations.subAgentId],
+      references: [subAgents.id]
+    }),
+    functionTool: one(functionTools, {
+      fields: [agentFunctionToolRelations.functionToolId],
+      references: [functionTools.id]
+    })
+  })
+);
 
 // src/types/utility.ts
 var TOOL_STATUS_VALUES = ["healthy", "unhealthy", "unknown", "needs_auth"];
@@ -1624,32 +1698,22 @@ var ToolSelectSchema = drizzleZod.createSelectSchema(tools);
 var ToolInsertSchema = drizzleZod.createInsertSchema(tools).extend({
   id: resourceIdSchema,
   imageUrl: imageUrlSchema,
-  functionId: resourceIdSchema.optional(),
-  // For function tools, reference to global functions table
-  config: zodOpenapi.z.discriminatedUnion("type", [
-    // MCP tools
-    zodOpenapi.z.object({
-      type: zodOpenapi.z.literal("mcp"),
-      mcp: zodOpenapi.z.object({
-        server: zodOpenapi.z.object({
-          url: zodOpenapi.z.string().url()
-        }),
-        transport: zodOpenapi.z.object({
-          type: zodOpenapi.z.enum(MCPTransportType),
-          requestInit: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional(),
-          eventSourceInit: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional(),
-          reconnectionOptions: zodOpenapi.z.custom().optional(),
-          sessionId: zodOpenapi.z.string().optional()
-        }).optional(),
-        activeTools: zodOpenapi.z.array(zodOpenapi.z.string()).optional()
-      })
-    }),
-    // Function tools (reference-only, no inline duplication)
-    zodOpenapi.z.object({
-      type: zodOpenapi.z.literal("function")
-      // No inline function details - they're in the functions table via functionId
+  config: zodOpenapi.z.object({
+    type: zodOpenapi.z.literal("mcp"),
+    mcp: zodOpenapi.z.object({
+      server: zodOpenapi.z.object({
+        url: zodOpenapi.z.string().url()
+      }),
+      transport: zodOpenapi.z.object({
+        type: zodOpenapi.z.enum(MCPTransportType),
+        requestInit: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional(),
+        eventSourceInit: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional(),
+        reconnectionOptions: zodOpenapi.z.custom().optional(),
+        sessionId: zodOpenapi.z.string().optional()
+      }).optional(),
+      activeTools: zodOpenapi.z.array(zodOpenapi.z.string()).optional()
     })
-  ])
+  })
 });
 var ConversationSelectSchema = drizzleZod.createSelectSchema(conversations);
 var ConversationInsertSchema = drizzleZod.createInsertSchema(conversations).extend({
@@ -1859,6 +1923,14 @@ var ToolUpdateSchema = ToolInsertSchema.partial();
 var ToolApiSelectSchema = createApiSchema(ToolSelectSchema);
 var ToolApiInsertSchema = createApiInsertSchema(ToolInsertSchema);
 var ToolApiUpdateSchema = createApiUpdateSchema(ToolUpdateSchema);
+var FunctionToolSelectSchema = drizzleZod.createSelectSchema(functionTools);
+var FunctionToolInsertSchema = drizzleZod.createInsertSchema(functionTools).extend({
+  id: resourceIdSchema
+});
+var FunctionToolUpdateSchema = FunctionToolInsertSchema.partial();
+var FunctionToolApiSelectSchema = createApiSchema(FunctionToolSelectSchema);
+var FunctionToolApiInsertSchema = createGraphScopedApiInsertSchema(FunctionToolInsertSchema);
+var FunctionToolApiUpdateSchema = createApiUpdateSchema(FunctionToolUpdateSchema);
 var FunctionSelectSchema = drizzleZod.createSelectSchema(functions);
 var FunctionInsertSchema = drizzleZod.createInsertSchema(functions).extend({
   id: resourceIdSchema
@@ -1961,6 +2033,24 @@ var FullGraphAgentInsertSchema = SubAgentApiInsertSchema.extend({
   canTransferTo: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
   canDelegateTo: zodOpenapi.z.array(zodOpenapi.z.string()).optional()
 });
+var FullGraphDefinitionSchema = AgentGraphApiInsertSchema.extend({
+  subAgents: zodOpenapi.z.record(
+    zodOpenapi.z.string(),
+    zodOpenapi.z.union([FullGraphAgentInsertSchema, ExternalAgentApiInsertSchema])
+  ),
+  // Lookup maps for UI to resolve canUse items
+  tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema).optional(),
+  // MCP tools (project-scoped)
+  functionTools: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionToolApiInsertSchema).optional(),
+  // Function tools (graph-scoped)
+  functions: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionApiInsertSchema).optional(),
+  // Get function code for function tools
+  contextConfig: zodOpenapi.z.optional(ContextConfigApiInsertSchema),
+  statusUpdates: zodOpenapi.z.optional(StatusUpdateSchema),
+  models: ModelSchema.optional(),
+  stopWhen: GraphStopWhenSchema.optional(),
+  graphPrompt: zodOpenapi.z.string().max(5e3, "Graph prompt cannot exceed 5000 characters").optional()
+});
 var GraphWithinContextOfProjectSchema = AgentGraphApiInsertSchema.extend({
   subAgents: zodOpenapi.z.record(
     zodOpenapi.z.string(),
@@ -1969,9 +2059,13 @@ var GraphWithinContextOfProjectSchema = AgentGraphApiInsertSchema.extend({
       ExternalAgentApiInsertSchema.extend({ type: zodOpenapi.z.literal("external") })
     ])
   ),
+  // Lookup maps for UI to resolve canUse items
   tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema).optional(),
-  // Get tool name/description from toolId
+  // MCP tools (project-scoped)
+  functionTools: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionToolApiInsertSchema).optional(),
+  // Function tools (graph-scoped)
   functions: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionApiInsertSchema).optional(),
+  // Get function code for function tools
   contextConfig: zodOpenapi.z.optional(ContextConfigApiInsertSchema),
   statusUpdates: zodOpenapi.z.optional(StatusUpdateSchema),
   models: ModelSchema.optional(),
@@ -2019,9 +2113,9 @@ var ProjectApiUpdateSchema = ProjectUpdateSchema.omit({ tenantId: true });
 var FullProjectDefinitionSchema = ProjectApiInsertSchema.extend({
   graphs: zodOpenapi.z.record(zodOpenapi.z.string(), GraphWithinContextOfProjectSchema),
   tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema),
-  // Now includes both MCP and function tools
+  // MCP tools (project-scoped)
   functions: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionApiInsertSchema).optional(),
-  // Global functions
+  // Functions (project-scoped)
   dataComponents: zodOpenapi.z.record(zodOpenapi.z.string(), DataComponentApiInsertSchema).optional(),
   artifactComponents: zodOpenapi.z.record(zodOpenapi.z.string(), ArtifactComponentApiInsertSchema).optional(),
   statusUpdates: zodOpenapi.z.optional(StatusUpdateSchema),
@@ -2602,11 +2696,11 @@ function getCredentialStoreLookupKeyFromRetrievalParams({
 
 // src/credential-stuffer/CredentialStuffer.ts
 var CredentialStuffer = class {
-  constructor(credentialStoreRegistry, contextResolver, logger13) {
+  constructor(credentialStoreRegistry, contextResolver, logger14) {
     this.credentialStoreRegistry = credentialStoreRegistry;
     this.contextResolver = contextResolver;
     __publicField(this, "logger");
-    this.logger = logger13 || getLogger("credential-stuffer");
+    this.logger = logger14 || getLogger("credential-stuffer");
   }
   /**
    * Retrieve credentials from credential store registry
@@ -3160,6 +3254,212 @@ var deleteFunction = (db) => async (params) => {
     )
   );
 };
+var logger4 = getLogger("functionTools");
+var getFunctionToolById = (db) => async (params) => {
+  const result = await db.select().from(functionTools).where(
+    drizzleOrm.and(
+      drizzleOrm.eq(functionTools.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(functionTools.projectId, params.scopes.projectId),
+      drizzleOrm.eq(functionTools.graphId, params.scopes.graphId),
+      drizzleOrm.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 = drizzleOrm.and(
+    drizzleOrm.eq(functionTools.tenantId, params.scopes.tenantId),
+    drizzleOrm.eq(functionTools.projectId, params.scopes.projectId),
+    drizzleOrm.eq(functionTools.graphId, params.scopes.graphId)
+  );
+  const [functionToolsDbResults, totalResult] = await Promise.all([
+    db.select().from(functionTools).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(functionTools.createdAt)),
+    db.select({ count: drizzleOrm.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(
+    drizzleOrm.and(
+      drizzleOrm.eq(functionTools.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(functionTools.projectId, params.scopes.projectId),
+      drizzleOrm.eq(functionTools.graphId, params.scopes.graphId),
+      drizzleOrm.eq(functionTools.id, params.functionToolId)
+    )
+  ).returning();
+  return updated ?? null;
+};
+var deleteFunctionTool = (db) => async (params) => {
+  const [deleted] = await db.delete(functionTools).where(
+    drizzleOrm.and(
+      drizzleOrm.eq(functionTools.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(functionTools.projectId, params.scopes.projectId),
+      drizzleOrm.eq(functionTools.graphId, params.scopes.graphId),
+      drizzleOrm.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 relations2 = await db.select().from(agentFunctionToolRelations).where(
+        drizzleOrm.and(
+          drizzleOrm.eq(agentFunctionToolRelations.tenantId, tenantId),
+          drizzleOrm.eq(agentFunctionToolRelations.projectId, projectId),
+          drizzleOrm.eq(agentFunctionToolRelations.graphId, graphId),
+          drizzleOrm.eq(agentFunctionToolRelations.subAgentId, subAgentId)
+        )
+      );
+      const relatedFunctionToolIds = new Set(relations2.map((r) => r.functionToolId));
+      const agentFunctionTools = functionToolsList.data.filter(
+        (ft) => relatedFunctionToolIds.has(ft.id)
+      );
+      return {
+        data: agentFunctionTools,
+        pagination: functionToolsList.pagination
+      };
+    } catch (error) {
+      logger4.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.nanoid();
+      await db.insert(agentFunctionToolRelations).values({
+        id: relationId,
+        tenantId,
+        projectId,
+        graphId,
+        subAgentId,
+        functionToolId
+      });
+      logger4.info(
+        { tenantId, projectId, graphId, subAgentId, functionToolId, relationId },
+        "Function tool added to agent"
+      );
+      return { id: relationId };
+    } catch (error) {
+      logger4.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(
+        drizzleOrm.and(
+          drizzleOrm.eq(agentFunctionToolRelations.id, relationId),
+          drizzleOrm.eq(agentFunctionToolRelations.tenantId, tenantId),
+          drizzleOrm.eq(agentFunctionToolRelations.projectId, projectId),
+          drizzleOrm.eq(agentFunctionToolRelations.graphId, graphId)
+        )
+      );
+      logger4.info(
+        { tenantId, projectId, graphId, relationId, data },
+        "Agent-function tool relation updated"
+      );
+      return { id: relationId };
+    } catch (error) {
+      logger4.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: drizzleOrm.and(
@@ -3572,7 +3872,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,
@@ -3818,7 +4117,7 @@ var getSubAgentsByIds = (db) => async (params) => {
   );
 };
 var scryptAsync = util.promisify(crypto.scrypt);
-var logger4 = getLogger("api-key");
+var logger5 = getLogger("api-key");
 var API_KEY_LENGTH = 32;
 var SALT_LENGTH = 32;
 var KEY_LENGTH = 64;
@@ -3855,7 +4154,7 @@ async function validateApiKey(key, storedHash) {
     const hashedBuffer = await scryptAsync(key, salt, KEY_LENGTH);
     return crypto.timingSafeEqual(storedHashBuffer, hashedBuffer);
   } catch (error) {
-    logger4.error({ error }, "Error validating API key");
+    logger5.error({ error }, "Error validating API key");
     return false;
   }
 }
@@ -3905,7 +4204,7 @@ var buildOAuthConfig = (metadata) => ({
   registrationUrl: metadata.registration_endpoint,
   supportsDynamicRegistration: !!metadata.registration_endpoint
 });
-var tryWellKnownEndpoints = async (baseUrl, logger13) => {
+var tryWellKnownEndpoints = async (baseUrl, logger14) => {
   const wellKnownUrls = getWellKnownUrls(baseUrl);
   for (const wellKnownUrl of wellKnownUrls) {
     try {
@@ -3913,21 +4212,21 @@ var tryWellKnownEndpoints = async (baseUrl, logger13) => {
       if (response.ok) {
         const metadata = await response.json();
         if (validateOAuthMetadata(metadata)) {
-          logger13?.debug({ baseUrl, wellKnownUrl }, "OAuth 2.1/PKCE support detected");
+          logger14?.debug({ baseUrl, wellKnownUrl }, "OAuth 2.1/PKCE support detected");
           return buildOAuthConfig(metadata);
         }
       }
     } catch (error) {
-      logger13?.debug({ wellKnownUrl, error }, "OAuth endpoint check failed");
+      logger14?.debug({ wellKnownUrl, error }, "OAuth endpoint check failed");
     }
   }
   return null;
 };
-var checkForOAuthEndpoints = async (serverUrl, logger13) => {
-  const config = await discoverOAuthEndpoints(serverUrl, logger13);
+var checkForOAuthEndpoints = async (serverUrl, logger14) => {
+  const config = await discoverOAuthEndpoints(serverUrl, logger14);
   return config !== null;
 };
-var discoverOAuthEndpoints = async (serverUrl, logger13) => {
+var discoverOAuthEndpoints = async (serverUrl, logger14) => {
   try {
     const response = await fetch(serverUrl, {
       method: "POST",
@@ -3943,7 +4242,7 @@ var discoverOAuthEndpoints = async (serverUrl, logger13) => {
           if (metadataResponse.ok) {
             const metadata = await metadataResponse.json();
             if (metadata.authorization_servers?.length > 0) {
-              return await tryWellKnownEndpoints(metadata.authorization_servers[0], logger13);
+              return await tryWellKnownEndpoints(metadata.authorization_servers[0], logger14);
             }
           }
         }
@@ -3953,25 +4252,25 @@ var discoverOAuthEndpoints = async (serverUrl, logger13) => {
   }
   const url = new URL(serverUrl);
   const baseUrl = `${url.protocol}//${url.host}`;
-  return await tryWellKnownEndpoints(baseUrl, logger13);
+  return await tryWellKnownEndpoints(baseUrl, logger14);
 };
 var detectAuthenticationRequired = async ({
   serverUrl,
   toolId,
   error,
-  logger: logger13
+  logger: logger14
 }) => {
   try {
-    const hasOAuthEndpoints = await checkForOAuthEndpoints(serverUrl, logger13);
+    const hasOAuthEndpoints = await checkForOAuthEndpoints(serverUrl, logger14);
     if (hasOAuthEndpoints) {
-      logger13?.info(
+      logger14?.info(
         { toolId, serverUrl },
         "OAuth 2.1/PKCE support confirmed via endpoint discovery"
       );
       return true;
     }
   } catch (discoveryError) {
-    logger13?.debug({ toolId, discoveryError }, "OAuth endpoint discovery failed");
+    logger14?.debug({ toolId, discoveryError }, "OAuth endpoint discovery failed");
   }
   try {
     const response = await fetch(serverUrl, {
@@ -3990,13 +4289,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) {
-          logger13?.info(
+          logger14?.info(
             { toolId, wwwAuth },
             "Active OAuth flow detected via WWW-Authenticate parameters"
           );
           return true;
         } else {
-          logger13?.debug(
+          logger14?.debug(
             { toolId, wwwAuth },
             "Bearer authentication detected - likely simple token auth, not OAuth"
           );
@@ -4004,9 +4303,9 @@ var detectAuthenticationRequired = async ({
       }
     }
   } catch (fetchError) {
-    logger13?.debug({ toolId, fetchError }, "Direct fetch authentication check failed");
+    logger14?.debug({ toolId, fetchError }, "Direct fetch authentication check failed");
   }
-  logger13?.debug(
+  logger14?.debug(
     { toolId, error: error.message },
     "No OAuth 2.1/PKCE authentication requirement detected"
   );
@@ -4466,7 +4765,7 @@ var McpClient = class {
     return results;
   }
 };
-var logger5 = getLogger("tracer");
+var logger6 = getLogger("tracer");
 var createNoOpSpan = () => ({
   setAttributes: () => ({}),
   recordException: () => ({}),
@@ -4495,21 +4794,21 @@ var noopTracer = {
     return createNoOpSpan();
   }
 };
-function setSpanWithError(span, error, logger13, logMessage) {
+function setSpanWithError(span, error, logger14, logMessage) {
   span.recordException(error);
   span.setStatus({
     code: api.SpanStatusCode.ERROR,
     message: error.message
   });
-  if (logger13 && logMessage) {
-    logger13.error({ error: error.message }, logMessage);
+  if (logger14 && logMessage) {
+    logger14.error({ error: error.message }, logMessage);
   }
 }
 function getTracer(serviceName, serviceVersion) {
   try {
     return api.trace.getTracer(serviceName, serviceVersion);
   } catch (_error) {
-    logger5.debug({}, "OpenTelemetry tracer not available, using no-op tracer");
+    logger6.debug({}, "OpenTelemetry tracer not available, using no-op tracer");
     return noopTracer;
   }
 }
@@ -4672,7 +4971,7 @@ var upsertCredentialReference = (db) => async (params) => {
 };
 
 // src/data-access/tools.ts
-var logger6 = getLogger("tools");
+var logger7 = getLogger("tools");
 function extractInputSchema(toolDef) {
   if (toolDef.inputSchema) {
     return toolDef.inputSchema;
@@ -4772,7 +5071,7 @@ var discoverToolsFromServer = async (tool2, dbClient, credentialStoreRegistry) =
     );
     return toolDefinitions;
   } catch (error) {
-    logger6.error({ toolId: tool2.id, error }, "Tool discovery failed");
+    logger7.error({ toolId: tool2.id, error }, "Tool discovery failed");
     throw error;
   }
 };
@@ -4781,8 +5080,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,
@@ -4806,7 +5103,7 @@ var dbResultToMcpTool = async (dbResult, dbClient, credentialStoreRegistry) => {
       serverUrl: dbResult.config.mcp.server.url,
       toolId: dbResult.id,
       error,
-      logger: logger6
+      logger: logger7
     });
     status = toolNeedsAuth ? "needs_auth" : "unhealthy";
     lastErrorComputed = toolNeedsAuth ? "Authentication required - OAuth login needed" : error instanceof Error ? error.message : "Tool discovery failed";
@@ -4822,8 +5119,6 @@ var dbResultToMcpTool = async (dbResult, dbClient, credentialStoreRegistry) => {
   });
   return {
     ...rest,
-    functionId: rest.functionId || void 0,
-    // Convert null to undefined
     status,
     availableTools,
     capabilities: capabilities || void 0,
@@ -4926,7 +5221,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,
@@ -5200,6 +5495,33 @@ var getFullGraphDefinition = (db) => async ({
           drizzleOrm.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,
+        drizzleOrm.and(
+          drizzleOrm.eq(agentFunctionToolRelations.functionToolId, functionTools.id),
+          drizzleOrm.eq(agentFunctionToolRelations.tenantId, functionTools.tenantId),
+          drizzleOrm.eq(agentFunctionToolRelations.projectId, functionTools.projectId),
+          drizzleOrm.eq(agentFunctionToolRelations.graphId, functionTools.graphId)
+        )
+      ).where(
+        drizzleOrm.and(
+          drizzleOrm.eq(agentFunctionToolRelations.tenantId, tenantId),
+          drizzleOrm.eq(agentFunctionToolRelations.projectId, projectId),
+          drizzleOrm.eq(agentFunctionToolRelations.graphId, graphId),
+          drizzleOrm.eq(agentFunctionToolRelations.subAgentId, agent.id)
+        )
+      );
       const agentDataComponentRelations = await db.query.subAgentDataComponents.findMany({
         where: drizzleOrm.and(
           drizzleOrm.eq(subAgentDataComponents.tenantId, tenantId),
@@ -5216,12 +5538,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,
@@ -5410,16 +5741,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) {
@@ -6658,18 +7002,18 @@ var defaultLogger = {
   error: () => {
   }
 };
-async function applyExecutionLimitsInheritance(db, logger13, scopes, graphData) {
+async function applyExecutionLimitsInheritance(db, logger14, scopes, graphData) {
   const { tenantId, projectId } = scopes;
   try {
     const project = await db.query.projects.findFirst({
       where: drizzleOrm.and(drizzleOrm.eq(projects.tenantId, tenantId), drizzleOrm.eq(projects.id, projectId))
     });
     if (!project?.stopWhen) {
-      logger13.info({ projectId }, "No project stopWhen configuration found");
+      logger14.info({ projectId }, "No project stopWhen configuration found");
       return;
     }
     const projectStopWhen = project.stopWhen;
-    logger13.info(
+    logger14.info(
       {
         projectId,
         projectStopWhen
@@ -6681,7 +7025,7 @@ async function applyExecutionLimitsInheritance(db, logger13, scopes, graphData)
     }
     if (graphData.stopWhen.transferCountIs === void 0 && projectStopWhen?.transferCountIs !== void 0) {
       graphData.stopWhen.transferCountIs = projectStopWhen.transferCountIs;
-      logger13.info(
+      logger14.info(
         {
           graphId: graphData.id,
           inheritedValue: projectStopWhen.transferCountIs
@@ -6691,7 +7035,7 @@ async function applyExecutionLimitsInheritance(db, logger13, scopes, graphData)
     }
     if (graphData.stopWhen.transferCountIs === void 0) {
       graphData.stopWhen.transferCountIs = 10;
-      logger13.info(
+      logger14.info(
         {
           graphId: graphData.id,
           defaultValue: 10
@@ -6700,7 +7044,7 @@ async function applyExecutionLimitsInheritance(db, logger13, scopes, graphData)
       );
     }
     if (projectStopWhen?.stepCountIs !== void 0) {
-      logger13.info(
+      logger14.info(
         {
           projectId,
           stepCountIs: projectStopWhen.stepCountIs
@@ -6715,7 +7059,7 @@ async function applyExecutionLimitsInheritance(db, logger13, scopes, graphData)
           }
           if (agent.stopWhen.stepCountIs === void 0) {
             agent.stopWhen.stepCountIs = projectStopWhen.stepCountIs;
-            logger13.info(
+            logger14.info(
               {
                 subAgentId,
                 inheritedValue: projectStopWhen.stepCountIs
@@ -6727,7 +7071,7 @@ async function applyExecutionLimitsInheritance(db, logger13, scopes, graphData)
       }
     }
   } catch (error) {
-    logger13.error(
+    logger14.error(
       {
         projectId,
         error: error instanceof Error ? error.message : "Unknown error"
@@ -6736,21 +7080,21 @@ async function applyExecutionLimitsInheritance(db, logger13, scopes, graphData)
     );
   }
 }
-var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes, graphData) => {
+var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes, graphData) => {
   const { tenantId, projectId } = scopes;
   const typed = validateAndTypeGraphData(graphData);
   validateGraphStructure(typed);
-  await applyExecutionLimitsInheritance(db, logger13, { tenantId, projectId }, typed);
+  await applyExecutionLimitsInheritance(db, logger14, { tenantId, projectId }, typed);
   try {
-    logger13.info(
+    logger14.info(
       {},
       "CredentialReferences are project-scoped - skipping credential reference creation in graph"
     );
-    logger13.info({}, "Tools are project-scoped - skipping tool creation in graph");
+    logger14.info({}, "MCP Tools are project-scoped - skipping tool creation in graph");
     let finalGraphId;
     try {
       const graphId = typed.id || nanoid.nanoid();
-      logger13.info({ graphId }, "Creating agent graph metadata");
+      logger14.info({ graphId }, "Creating agent graph metadata");
       const agentGraph2 = await upsertAgentGraph(db)({
         data: {
           id: graphId,
@@ -6768,15 +7112,15 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
         }
       });
       finalGraphId = agentGraph2.id;
-      logger13.info({ graphId: finalGraphId }, "Agent graph metadata created successfully");
+      logger14.info({ graphId: finalGraphId }, "Agent graph metadata created successfully");
     } catch (error) {
-      logger13.error({ graphId: typed.id, error }, "Failed to create/update graph metadata");
+      logger14.error({ graphId: typed.id, error }, "Failed to create/update graph metadata");
       throw error;
     }
     let contextConfigId;
     if (typed.contextConfig) {
       try {
-        logger13.info({ contextConfigId: typed.contextConfig.id }, "Processing context config");
+        logger14.info({ contextConfigId: typed.contextConfig.id }, "Processing context config");
         const contextConfig2 = await upsertContextConfig(db)({
           data: {
             ...typed.contextConfig,
@@ -6786,9 +7130,9 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
           }
         });
         contextConfigId = contextConfig2.id;
-        logger13.info({ contextConfigId }, "Context config processed successfully");
+        logger14.info({ contextConfigId }, "Context config processed successfully");
       } catch (error) {
-        logger13.error(
+        logger14.error(
           { contextConfigId: typed.contextConfig.id, error },
           "Failed to create/update context config"
         );
@@ -6797,7 +7141,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     }
     if (contextConfigId) {
       try {
-        logger13.info(
+        logger14.info(
           { graphId: finalGraphId, contextConfigId },
           "Updating graph with contextConfigId"
         );
@@ -6816,30 +7160,112 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             stopWhen: typed.stopWhen
           }
         });
-        logger13.info(
+        logger14.info(
           { graphId: finalGraphId, contextConfigId },
           "Graph updated with contextConfigId successfully"
         );
       } catch (error) {
-        logger13.error(
+        logger14.error(
           { graphId: finalGraphId, contextConfigId, error },
           "Failed to update graph with contextConfigId"
         );
         throw error;
       }
     }
-    logger13.info(
+    logger14.info(
       {},
       "DataComponents are project-scoped - skipping dataComponent creation in graph"
     );
-    logger13.info(
+    logger14.info(
       {},
       "ArtifactComponents are project-scoped - skipping artifactComponent creation in graph"
     );
+    if (typed.functions && Object.keys(typed.functions).length > 0) {
+      logger14.info(
+        {
+          graphId: finalGraphId,
+          functionCount: Object.keys(typed.functions).length
+        },
+        "Creating functions for graph"
+      );
+      const functionPromises = Object.entries(typed.functions).map(
+        async ([functionId, functionData]) => {
+          try {
+            logger14.info({ graphId: finalGraphId, functionId }, "Creating function for graph");
+            await upsertFunction(db)({
+              data: {
+                ...functionData,
+                id: functionId
+              },
+              scopes: { tenantId, projectId }
+            });
+            logger14.info({ graphId: finalGraphId, functionId }, "Function created successfully");
+          } catch (error) {
+            logger14.error(
+              { graphId: finalGraphId, functionId, error },
+              "Failed to create function for graph"
+            );
+            throw error;
+          }
+        }
+      );
+      await Promise.all(functionPromises);
+      logger14.info(
+        {
+          graphId: finalGraphId,
+          functionCount: Object.keys(typed.functions).length
+        },
+        "All functions created successfully"
+      );
+    }
+    if (typed.functionTools && Object.keys(typed.functionTools).length > 0) {
+      logger14.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 {
+            logger14.info(
+              { graphId: finalGraphId, functionToolId },
+              "Creating function tool in graph"
+            );
+            await upsertFunctionTool(db)({
+              data: {
+                ...functionToolData,
+                id: functionToolId
+              },
+              scopes: { tenantId, projectId, graphId: finalGraphId }
+            });
+            logger14.info(
+              { graphId: finalGraphId, functionToolId },
+              "Function tool created successfully"
+            );
+          } catch (error) {
+            logger14.error(
+              { graphId: finalGraphId, functionToolId, error },
+              "Failed to create function tool in graph"
+            );
+            throw error;
+          }
+        }
+      );
+      await Promise.all(functionToolPromises);
+      logger14.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 {
-        logger13.info({ subAgentId }, "Processing internal agent");
+        logger14.info({ subAgentId }, "Processing internal agent");
         await upsertSubAgent(db)({
           data: {
             id: subAgentId,
@@ -6854,9 +7280,9 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             stopWhen: internalAgent.stopWhen
           }
         });
-        logger13.info({ subAgentId }, "Internal agent processed successfully");
+        logger14.info({ subAgentId }, "Internal agent processed successfully");
       } catch (error) {
-        logger13.error({ subAgentId, error }, "Failed to create/update internal agent");
+        logger14.error({ subAgentId, error }, "Failed to create/update internal agent");
         throw error;
       }
     });
@@ -6864,11 +7290,11 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     const internalAgentCount = Object.entries(typed.subAgents).filter(
       ([_, agentData]) => isInternalAgent(agentData)
     ).length;
-    logger13.info({ internalAgentCount }, "All internal agents created/updated successfully");
+    logger14.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 {
-        logger13.info({ subAgentId }, "Processing external agent");
+        logger14.info({ subAgentId }, "Processing external agent");
         await upsertExternalAgent(db)({
           data: {
             id: subAgentId,
@@ -6882,9 +7308,9 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             headers: externalAgent.headers || void 0
           }
         });
-        logger13.info({ subAgentId }, "External agent processed successfully");
+        logger14.info({ subAgentId }, "External agent processed successfully");
       } catch (error) {
-        logger13.error({ subAgentId, error }, "Failed to create/update external agent");
+        logger14.error({ subAgentId, error }, "Failed to create/update external agent");
         throw error;
       }
     });
@@ -6892,10 +7318,10 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     const externalAgentCount = Object.entries(typed.subAgents).filter(
       ([_, agentData]) => isExternalAgent(agentData)
     ).length;
-    logger13.info({ externalAgentCount }, "All external agents created/updated successfully");
+    logger14.info({ externalAgentCount }, "All external agents created/updated successfully");
     if (contextConfigId) {
       try {
-        logger13.info(
+        logger14.info(
           { graphId: finalGraphId, contextConfigId },
           "Updating graph with context config"
         );
@@ -6903,9 +7329,9 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
           scopes: { tenantId, projectId, graphId: finalGraphId },
           data: { contextConfigId }
         });
-        logger13.info({ graphId: finalGraphId }, "Graph updated with context config");
+        logger14.info({ graphId: finalGraphId }, "Graph updated with context config");
       } catch (error) {
-        logger13.error(
+        logger14.error(
           { graphId: finalGraphId, error },
           "Failed to update graph with context config"
         );
@@ -6920,18 +7346,46 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             (async () => {
               try {
                 const { toolId, toolSelection, headers: headers2, agentToolRelationId } = canUseItem;
-                logger13.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
-                });
-                logger13.info({ subAgentId, toolId }, "Agent-tool relation processed successfully");
+                const isFunctionTool = typed.functionTools && toolId in typed.functionTools;
+                logger14.info(
+                  {
+                    subAgentId,
+                    toolId,
+                    hasFunctionTools: !!typed.functionTools,
+                    functionToolKeys: typed.functionTools ? Object.keys(typed.functionTools) : [],
+                    isFunctionTool
+                  },
+                  "Processing canUse item"
+                );
+                if (isFunctionTool) {
+                  logger14.info({ subAgentId, toolId }, "Processing agent-function tool relation");
+                  await upsertSubAgentFunctionToolRelation(db)({
+                    scopes: { tenantId, projectId, graphId: finalGraphId },
+                    subAgentId,
+                    functionToolId: toolId,
+                    relationId: agentToolRelationId
+                  });
+                  logger14.info(
+                    { subAgentId, toolId },
+                    "Agent-function tool relation processed successfully"
+                  );
+                } else {
+                  logger14.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
+                  });
+                  logger14.info(
+                    { subAgentId, toolId },
+                    "Agent-MCP tool relation processed successfully"
+                  );
+                }
               } catch (error) {
-                logger13.error(
+                logger14.error(
                   { subAgentId, toolId: canUseItem.toolId, error },
                   "Failed to create agent-tool relation"
                 );
@@ -6942,7 +7396,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       }
     }
     await Promise.all(agentToolPromises);
-    logger13.info(
+    logger14.info(
       { agentToolCount: Object.keys(typed.subAgents).length },
       "All agent-tool relations created"
     );
@@ -6953,7 +7407,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
           agentDataComponentPromises.push(
             (async () => {
               try {
-                logger13.info(
+                logger14.info(
                   { subAgentId, dataComponentId },
                   "Processing agent-data component relation"
                 );
@@ -6961,12 +7415,12 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
                   scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId },
                   dataComponentId
                 });
-                logger13.info(
+                logger14.info(
                   { subAgentId, dataComponentId },
                   "Agent-data component relation processed successfully"
                 );
               } catch (error) {
-                logger13.error(
+                logger14.error(
                   { subAgentId, dataComponentId, error },
                   "Failed to create agent-data component relation"
                 );
@@ -6977,7 +7431,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       }
     }
     await Promise.all(agentDataComponentPromises);
-    logger13.info({}, "All agent-data component relations created");
+    logger14.info({}, "All agent-data component relations created");
     const agentArtifactComponentPromises = [];
     for (const [subAgentId, agentData] of Object.entries(typed.subAgents)) {
       if (isInternalAgent(agentData) && agentData.artifactComponents) {
@@ -6985,7 +7439,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
           agentArtifactComponentPromises.push(
             (async () => {
               try {
-                logger13.info(
+                logger14.info(
                   { subAgentId, artifactComponentId },
                   "Processing agent-artifact component relation"
                 );
@@ -6993,12 +7447,12 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
                   scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId },
                   artifactComponentId
                 });
-                logger13.info(
+                logger14.info(
                   { subAgentId, artifactComponentId },
                   "Agent-artifact component relation processed successfully"
                 );
               } catch (error) {
-                logger13.error(
+                logger14.error(
                   { subAgentId, artifactComponentId, error },
                   "Failed to create agent-artifact component relation"
                 );
@@ -7009,7 +7463,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       }
     }
     await Promise.all(agentArtifactComponentPromises);
-    logger13.info({}, "All agent-artifact component relations created");
+    logger14.info({}, "All agent-artifact component relations created");
     const agentRelationPromises = [];
     for (const [subAgentId, agentData] of Object.entries(typed.subAgents)) {
       if (isInternalAgent(agentData) && agentData.canTransferTo) {
@@ -7017,7 +7471,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
           agentRelationPromises.push(
             (async () => {
               try {
-                logger13.info(
+                logger14.info(
                   { subAgentId, targetSubAgentId, type: "transfer" },
                   "Processing agent transfer relation"
                 );
@@ -7030,12 +7484,12 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
                   targetSubAgentId,
                   relationType: "transfer"
                 });
-                logger13.info(
+                logger14.info(
                   { subAgentId, targetSubAgentId, type: "transfer" },
                   "Agent transfer relation processed successfully"
                 );
               } catch (error) {
-                logger13.error(
+                logger14.error(
                   { subAgentId, targetSubAgentId, type: "transfer", error },
                   "Failed to create transfer relation"
                 );
@@ -7051,7 +7505,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
           agentRelationPromises.push(
             (async () => {
               try {
-                logger13.info(
+                logger14.info(
                   { subAgentId, targetSubAgentId, type: "delegate" },
                   "Processing agent delegation relation"
                 );
@@ -7065,12 +7519,12 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
                   externalSubAgentId: isTargetExternal ? targetSubAgentId : void 0,
                   relationType: "delegate"
                 });
-                logger13.info(
+                logger14.info(
                   { subAgentId, targetSubAgentId, type: "delegate" },
                   "Agent delegation relation processed successfully"
                 );
               } catch (error) {
-                logger13.error(
+                logger14.error(
                   { subAgentId, targetSubAgentId, type: "delegate", error },
                   "Failed to create delegation relation"
                 );
@@ -7081,7 +7535,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       }
     }
     await Promise.all(agentRelationPromises);
-    logger13.info(
+    logger14.info(
       { agentRelationCount: agentRelationPromises.length },
       "All agent relations created"
     );
@@ -7091,21 +7545,21 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     if (!createdGraph) {
       throw new Error("Failed to retrieve created graph");
     }
-    logger13.info({ tenantId, graphId: finalGraphId }, "Full graph created successfully");
+    logger14.info({ tenantId, graphId: finalGraphId }, "Full graph created successfully");
     return createdGraph;
   } catch (error) {
     const errorGraphId = typed.id || "unknown";
-    logger13.error({ tenantId, graphId: errorGraphId, error }, "Failed to create full graph");
+    logger14.error({ tenantId, graphId: errorGraphId, error }, "Failed to create full graph");
     throw error;
   }
 };
-var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes, graphData) => {
+var updateFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes, graphData) => {
   const { tenantId, projectId } = scopes;
   const typedGraphDefinition = validateAndTypeGraphData(graphData);
   if (!typedGraphDefinition.id) {
     throw new Error("Graph ID is required");
   }
-  logger13.info(
+  logger14.info(
     {
       tenantId,
       graphId: typedGraphDefinition.id,
@@ -7116,7 +7570,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
   validateGraphStructure(typedGraphDefinition);
   await applyExecutionLimitsInheritance(
     db,
-    logger13,
+    logger14,
     { tenantId, projectId },
     typedGraphDefinition
   );
@@ -7125,22 +7579,22 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       scopes: { tenantId, projectId, graphId: typedGraphDefinition.id }
     });
     if (!existingGraph) {
-      logger13.info(
+      logger14.info(
         { graphId: typedGraphDefinition.id },
         "Graph does not exist, creating new graph"
       );
-      return createFullGraphServerSide(db)(scopes, graphData);
+      return createFullGraphServerSide(db, logger14)(scopes, graphData);
     }
     const existingGraphModels = existingGraph.models;
-    logger13.info(
+    logger14.info(
       {},
       "CredentialReferences are project-scoped - skipping credential reference update in graph"
     );
-    logger13.info({}, "Tools are project-scoped - skipping tool creation in graph update");
+    logger14.info({}, "MCP Tools are project-scoped - skipping tool creation in graph update");
     let finalGraphId;
     try {
       const graphId = typedGraphDefinition.id || nanoid.nanoid();
-      logger13.info({ graphId }, "Getting/creating agent graph metadata");
+      logger14.info({ graphId }, "Getting/creating agent graph metadata");
       const agentGraph2 = await upsertAgentGraph(db)({
         data: {
           id: graphId,
@@ -7158,9 +7612,9 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
         }
       });
       finalGraphId = agentGraph2.id;
-      logger13.info({ graphId: finalGraphId }, "Agent graph metadata ready");
+      logger14.info({ graphId: finalGraphId }, "Agent graph metadata ready");
     } catch (error) {
-      logger13.error(
+      logger14.error(
         { graphId: typedGraphDefinition.id, error },
         "Failed to get/update graph metadata"
       );
@@ -7168,7 +7622,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     }
     let contextConfigId;
     if (typedGraphDefinition.contextConfig) {
-      logger13.info(
+      logger14.info(
         { contextConfigId: typedGraphDefinition.contextConfig?.id },
         " context config exists"
       );
@@ -7184,9 +7638,9 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
           }
         });
         contextConfigId = contextConfig2.id;
-        logger13.info({ contextConfigId }, "Context config processed successfully");
+        logger14.info({ contextConfigId }, "Context config processed successfully");
       } catch (error) {
-        logger13.error(
+        logger14.error(
           { contextConfigId: typedGraphDefinition.contextConfig.id, error },
           "Failed to create/update context config"
         );
@@ -7195,7 +7649,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     }
     if (contextConfigId) {
       try {
-        logger13.info(
+        logger14.info(
           { graphId: finalGraphId, contextConfigId },
           "Updating graph with contextConfigId"
         );
@@ -7214,23 +7668,105 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             stopWhen: typedGraphDefinition.stopWhen
           }
         });
-        logger13.info(
+        logger14.info(
           { graphId: finalGraphId, contextConfigId },
           "Graph updated with contextConfigId successfully"
         );
       } catch (error) {
-        logger13.error(
+        logger14.error(
           { graphId: finalGraphId, contextConfigId, error },
           "Failed to update graph with contextConfigId"
         );
         throw error;
       }
     }
-    logger13.info({}, "DataComponents are project-scoped - skipping dataComponent update in graph");
-    logger13.info(
+    logger14.info({}, "DataComponents are project-scoped - skipping dataComponent update in graph");
+    logger14.info(
       {},
       "ArtifactComponents are project-scoped - skipping artifactComponent update in graph"
     );
+    if (typedGraphDefinition.functions && Object.keys(typedGraphDefinition.functions).length > 0) {
+      logger14.info(
+        {
+          graphId: finalGraphId,
+          functionCount: Object.keys(typedGraphDefinition.functions).length
+        },
+        "Updating functions for graph"
+      );
+      const functionPromises = Object.entries(typedGraphDefinition.functions).map(
+        async ([functionId, functionData]) => {
+          try {
+            logger14.info({ graphId: finalGraphId, functionId }, "Updating function for graph");
+            await upsertFunction(db)({
+              data: {
+                ...functionData,
+                id: functionId
+              },
+              scopes: { tenantId, projectId }
+            });
+            logger14.info({ graphId: finalGraphId, functionId }, "Function updated successfully");
+          } catch (error) {
+            logger14.error(
+              { graphId: finalGraphId, functionId, error },
+              "Failed to update function for graph"
+            );
+            throw error;
+          }
+        }
+      );
+      await Promise.all(functionPromises);
+      logger14.info(
+        {
+          graphId: finalGraphId,
+          functionCount: Object.keys(typedGraphDefinition.functions).length
+        },
+        "All functions updated successfully"
+      );
+    }
+    if (typedGraphDefinition.functionTools && Object.keys(typedGraphDefinition.functionTools).length > 0) {
+      logger14.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 {
+            logger14.info(
+              { graphId: finalGraphId, functionToolId },
+              "Updating function tool in graph"
+            );
+            await upsertFunctionTool(db)({
+              data: {
+                ...functionToolData,
+                id: functionToolId
+              },
+              scopes: { tenantId, projectId, graphId: finalGraphId }
+            });
+            logger14.info(
+              { graphId: finalGraphId, functionToolId },
+              "Function tool updated successfully"
+            );
+          } catch (error) {
+            logger14.error(
+              { graphId: finalGraphId, functionToolId, error },
+              "Failed to update function tool in graph"
+            );
+            throw error;
+          }
+        }
+      );
+      await Promise.all(functionToolPromises);
+      logger14.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;
@@ -7258,7 +7794,7 @@ var updateFullGraphServerSide = (db, logger13 = 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];
-            logger13.info(
+            logger14.info(
               {
                 subAgentId,
                 modelType,
@@ -7273,7 +7809,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
         finalModelSettings = cascadedModels;
       }
       try {
-        logger13.info({ subAgentId }, "Processing internal agent");
+        logger14.info({ subAgentId }, "Processing internal agent");
         await upsertSubAgent(db)({
           data: {
             id: subAgentId,
@@ -7288,9 +7824,9 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             stopWhen: internalAgent.stopWhen
           }
         });
-        logger13.info({ subAgentId }, "Internal agent processed successfully");
+        logger14.info({ subAgentId }, "Internal agent processed successfully");
       } catch (error) {
-        logger13.error({ subAgentId, error }, "Failed to create/update internal agent");
+        logger14.error({ subAgentId, error }, "Failed to create/update internal agent");
         throw error;
       }
     });
@@ -7298,11 +7834,11 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     const internalAgentCount = Object.entries(typedGraphDefinition.subAgents).filter(
       ([_, agentData]) => isInternalAgent(agentData)
     ).length;
-    logger13.info({ internalAgentCount }, "All internal agents created/updated successfully");
+    logger14.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 {
-        logger13.info({ subAgentId }, "Processing external agent");
+        logger14.info({ subAgentId }, "Processing external agent");
         await upsertExternalAgent(db)({
           data: {
             id: subAgentId,
@@ -7316,9 +7852,9 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             headers: externalAgent.headers || void 0
           }
         });
-        logger13.info({ subAgentId }, "External agent processed successfully");
+        logger14.info({ subAgentId }, "External agent processed successfully");
       } catch (error) {
-        logger13.error({ subAgentId, error }, "Failed to create/update external agent");
+        logger14.error({ subAgentId, error }, "Failed to create/update external agent");
         throw error;
       }
     });
@@ -7326,7 +7862,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     const externalAgentCount = Object.entries(typedGraphDefinition.subAgents).filter(
       ([_, agentData]) => isExternalAgent(agentData)
     ).length;
-    logger13.info({ externalAgentCount }, "All external agents created/updated successfully");
+    logger14.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 }
@@ -7343,9 +7879,9 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             subAgentId: agent.id
           });
           deletedInternalCount++;
-          logger13.info({ subAgentId: agent.id }, "Deleted orphaned internal agent");
+          logger14.info({ subAgentId: agent.id }, "Deleted orphaned internal agent");
         } catch (error) {
-          logger13.error(
+          logger14.error(
             { subAgentId: agent.id, error },
             "Failed to delete orphaned internal agent"
           );
@@ -7361,9 +7897,9 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             subAgentId: agent.id
           });
           deletedExternalCount++;
-          logger13.info({ subAgentId: agent.id }, "Deleted orphaned external agent");
+          logger14.info({ subAgentId: agent.id }, "Deleted orphaned external agent");
         } catch (error) {
-          logger13.error(
+          logger14.error(
             { subAgentId: agent.id, error },
             "Failed to delete orphaned external agent"
           );
@@ -7371,7 +7907,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       }
     }
     if (deletedInternalCount > 0 || deletedExternalCount > 0) {
-      logger13.info(
+      logger14.info(
         {
           deletedInternalCount,
           deletedExternalCount,
@@ -7393,7 +7929,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
         stopWhen: typedGraphDefinition.stopWhen
       }
     });
-    logger13.info({ graphId: typedGraphDefinition.id }, "Graph metadata updated");
+    logger14.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)) {
@@ -7430,10 +7966,10 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
           deletedCount = result.rowsAffected || 0;
         }
         if (deletedCount > 0) {
-          logger13.info({ subAgentId, deletedCount }, "Deleted orphaned agent-tool relations");
+          logger14.info({ subAgentId, deletedCount }, "Deleted orphaned agent-tool relations");
         }
       } catch (error) {
-        logger13.error({ subAgentId, error }, "Failed to delete orphaned agent-tool relations");
+        logger14.error({ subAgentId, error }, "Failed to delete orphaned agent-tool relations");
       }
     }
     const agentToolPromises = [];
@@ -7444,21 +7980,36 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             (async () => {
               try {
                 const { toolId, toolSelection, headers: headers2, agentToolRelationId } = canUseItem;
-                logger13.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
-                });
-                logger13.info(
-                  { subAgentId, toolId, relationId: agentToolRelationId },
-                  "Agent-tool relation upserted"
-                );
+                const isFunctionTool = typedGraphDefinition.functionTools && toolId in typedGraphDefinition.functionTools;
+                if (isFunctionTool) {
+                  logger14.info({ subAgentId, toolId }, "Processing agent-function tool relation");
+                  await upsertSubAgentFunctionToolRelation(db)({
+                    scopes: { tenantId, projectId, graphId: finalGraphId },
+                    subAgentId,
+                    functionToolId: toolId,
+                    relationId: agentToolRelationId
+                  });
+                  logger14.info(
+                    { subAgentId, toolId, relationId: agentToolRelationId },
+                    "Agent-function tool relation upserted"
+                  );
+                } else {
+                  logger14.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
+                  });
+                  logger14.info(
+                    { subAgentId, toolId, relationId: agentToolRelationId },
+                    "Agent-MCP tool relation upserted"
+                  );
+                }
               } catch (error) {
-                logger13.error(
+                logger14.error(
                   {
                     subAgentId,
                     toolId: canUseItem.toolId,
@@ -7474,7 +8025,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       }
     }
     await Promise.all(agentToolPromises);
-    logger13.info(
+    logger14.info(
       { agentToolPromisesCount: agentToolPromises.length },
       "All agent-tool relations updated"
     );
@@ -7494,12 +8045,12 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
                   scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId },
                   dataComponentId
                 });
-                logger13.info(
+                logger14.info(
                   { subAgentId, dataComponentId },
                   "Agent-dataComponent relation created"
                 );
               } catch (error) {
-                logger13.error(
+                logger14.error(
                   { subAgentId, dataComponentId, error },
                   "Failed to create agent-dataComponent relation"
                 );
@@ -7510,7 +8061,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       }
     }
     await Promise.all(agentDataComponentPromises);
-    logger13.info(
+    logger14.info(
       { agentDataComponentPromisesCount: agentDataComponentPromises.length },
       "All agent-dataComponent relations updated"
     );
@@ -7530,12 +8081,12 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
                   scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId },
                   artifactComponentId
                 });
-                logger13.info(
+                logger14.info(
                   { subAgentId, artifactComponentId },
                   "Agent-artifactComponent relation created"
                 );
               } catch (error) {
-                logger13.error(
+                logger14.error(
                   { subAgentId, artifactComponentId, error },
                   "Failed to create agent-artifactComponent relation"
                 );
@@ -7546,7 +8097,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       }
     }
     await Promise.all(agentArtifactComponentPromises);
-    logger13.info(
+    logger14.info(
       { agentArtifactComponentPromisesCount: agentArtifactComponentPromises.length },
       "All agent-artifactComponent relations updated"
     );
@@ -7575,12 +8126,12 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
                   projectId,
                   ...relationData
                 });
-                logger13.info(
+                logger14.info(
                   { subAgentId, targetSubAgentId, isTargetExternal },
                   "Transfer relation created"
                 );
               } catch (error) {
-                logger13.error(
+                logger14.error(
                   { subAgentId, targetSubAgentId, error },
                   "Failed to create transfer relation"
                 );
@@ -7609,9 +8160,9 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
                   projectId,
                   ...relationData
                 });
-                logger13.info({ subAgentId, targetSubAgentId }, "Delegation relation created");
+                logger14.info({ subAgentId, targetSubAgentId }, "Delegation relation created");
               } catch (error) {
-                logger13.error(
+                logger14.error(
                   { subAgentId, targetSubAgentId, error },
                   "Failed to create delegation relation"
                 );
@@ -7622,7 +8173,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       }
     }
     await Promise.all(agentRelationPromises);
-    logger13.info(
+    logger14.info(
       { agentRelationPromisesCount: agentRelationPromises.length },
       "All agent relations updated"
     );
@@ -7632,26 +8183,26 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     if (!updatedGraph) {
       throw new Error("Failed to retrieve updated graph");
     }
-    logger13.info({ graphId: typedGraphDefinition.id }, "Full graph updated successfully");
+    logger14.info({ graphId: typedGraphDefinition.id }, "Full graph updated successfully");
     return updatedGraph;
   } catch (error) {
-    logger13.error({ graphId: typedGraphDefinition.id, error }, "Failed to update full graph");
+    logger14.error({ graphId: typedGraphDefinition.id, error }, "Failed to update full graph");
     throw error;
   }
 };
-var getFullGraph = (db, logger13 = defaultLogger) => async (params) => {
+var getFullGraph = (db, logger14 = defaultLogger) => async (params) => {
   const { scopes } = params;
   const { tenantId, projectId } = scopes;
-  logger13.info({ tenantId, graphId: scopes.graphId }, "Retrieving full graph definition");
+  logger14.info({ tenantId, graphId: scopes.graphId }, "Retrieving full graph definition");
   try {
     const graph = await getFullGraphDefinition(db)({
       scopes: { tenantId, projectId, graphId: scopes.graphId }
     });
     if (!graph) {
-      logger13.info({ tenantId, graphId: scopes.graphId }, "Graph not found");
+      logger14.info({ tenantId, graphId: scopes.graphId }, "Graph not found");
       return null;
     }
-    logger13.info(
+    logger14.info(
       {
         tenantId,
         graphId: scopes.graphId,
@@ -7661,7 +8212,7 @@ var getFullGraph = (db, logger13 = defaultLogger) => async (params) => {
     );
     return graph;
   } catch (error) {
-    logger13.error(
+    logger14.error(
       {
         tenantId,
         graphId: scopes.graphId,
@@ -7672,21 +8223,21 @@ var getFullGraph = (db, logger13 = defaultLogger) => async (params) => {
     throw error;
   }
 };
-var deleteFullGraph = (db, logger13 = defaultLogger) => async (params) => {
+var deleteFullGraph = (db, logger14 = defaultLogger) => async (params) => {
   const { tenantId, projectId, graphId } = params.scopes;
-  logger13.info({ tenantId, graphId }, "Deleting full graph and related entities");
+  logger14.info({ tenantId, graphId }, "Deleting full graph and related entities");
   try {
     const graph = await getFullGraphDefinition(db)({
       scopes: { tenantId, projectId, graphId }
     });
     if (!graph) {
-      logger13.info({ tenantId, graphId }, "Graph not found for deletion");
+      logger14.info({ tenantId, graphId }, "Graph not found for deletion");
       return false;
     }
     await deleteAgentRelationsByGraph(db)({
       scopes: { tenantId, projectId, graphId }
     });
-    logger13.info({ tenantId, graphId }, "Agent relations deleted");
+    logger14.info({ tenantId, graphId }, "Agent relations deleted");
     const subAgentIds = Object.keys(graph.subAgents);
     if (subAgentIds.length > 0) {
       for (const subAgentId of subAgentIds) {
@@ -7694,7 +8245,7 @@ var deleteFullGraph = (db, logger13 = defaultLogger) => async (params) => {
           scopes: { tenantId, projectId, graphId, subAgentId }
         });
       }
-      logger13.info(
+      logger14.info(
         { tenantId, graphId, agentCount: subAgentIds.length },
         "Agent-tool relations deleted"
       );
@@ -7702,11 +8253,11 @@ var deleteFullGraph = (db, logger13 = defaultLogger) => async (params) => {
     await deleteAgentGraph(db)({
       scopes: { tenantId, projectId, graphId }
     });
-    logger13.info({ tenantId, graphId }, "Graph metadata deleted");
-    logger13.info({ tenantId, graphId }, "Full graph deleted successfully");
+    logger14.info({ tenantId, graphId }, "Graph metadata deleted");
+    logger14.info({ tenantId, graphId }, "Full graph deleted successfully");
     return true;
   } catch (error) {
-    logger13.error(
+    logger14.error(
       {
         tenantId,
         graphId,
@@ -8296,10 +8847,10 @@ var defaultLogger2 = getLogger("projectFull");
 function validateAndTypeProjectData(projectData) {
   return projectData;
 }
-var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scopes, projectData) => {
+var createFullProjectServerSide = (db, logger14 = defaultLogger2) => async (scopes, projectData) => {
   const { tenantId } = scopes;
   const typed = validateAndTypeProjectData(projectData);
-  logger13.info(
+  logger14.info(
     {
       tenantId,
       projectId: typed.id,
@@ -8318,11 +8869,11 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    logger13.info({ projectId: typed.id }, "Creating project metadata");
+    logger14.info({ projectId: typed.id }, "Creating project metadata");
     await createProject(db)(projectPayload);
-    logger13.info({ projectId: typed.id }, "Project metadata created successfully");
+    logger14.info({ projectId: typed.id }, "Project metadata created successfully");
     if (typed.credentialReferences && Object.keys(typed.credentialReferences).length > 0) {
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.credentialReferences).length
@@ -8332,7 +8883,7 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       const credentialPromises = Object.entries(typed.credentialReferences).map(
         async ([_credId, credData]) => {
           try {
-            logger13.info(
+            logger14.info(
               { projectId: typed.id, credId: credData.id },
               "Creating credentialReference in project"
             );
@@ -8343,12 +8894,12 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
                 projectId: typed.id
               }
             });
-            logger13.info(
+            logger14.info(
               { projectId: typed.id, credId: credData.id },
               "CredentialReference created successfully"
             );
           } catch (error) {
-            logger13.error(
+            logger14.error(
               { projectId: typed.id, credId: credData.id, error },
               "Failed to create credentialReference in project"
             );
@@ -8357,7 +8908,7 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
         }
       );
       await Promise.all(credentialPromises);
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.credentialReferences).length
@@ -8369,19 +8920,19 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       const functionPromises = Object.entries(typed.functions).map(
         async ([functionId, functionData]) => {
           try {
-            logger13.info({ projectId: typed.id, functionId }, "Creating project function");
+            logger14.info({ projectId: typed.id, functionId }, "Creating project function");
             await upsertFunction(db)({
               data: {
                 ...functionData
               },
               scopes: { tenantId, projectId: typed.id }
             });
-            logger13.info(
+            logger14.info(
               { projectId: typed.id, functionId },
               "Project function created successfully"
             );
           } catch (error) {
-            logger13.error(
+            logger14.error(
               { projectId: typed.id, functionId, error },
               "Failed to create global function"
             );
@@ -8390,7 +8941,7 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
         }
       );
       await Promise.all(functionPromises);
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           functionCount: Object.keys(typed.functions).length
@@ -8399,7 +8950,7 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       );
     }
     if (typed.tools && Object.keys(typed.tools).length > 0) {
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           toolCount: Object.keys(typed.tools).length
@@ -8408,7 +8959,7 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       );
       const toolPromises = Object.entries(typed.tools).map(async ([toolId, toolData]) => {
         try {
-          logger13.info({ projectId: typed.id, toolId }, "Creating tool in project");
+          logger14.info({ projectId: typed.id, toolId }, "Creating tool in project");
           await upsertTool(db)({
             data: {
               tenantId,
@@ -8416,9 +8967,9 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
               ...toolData
             }
           });
-          logger13.info({ projectId: typed.id, toolId }, "Tool created successfully");
+          logger14.info({ projectId: typed.id, toolId }, "Tool created successfully");
         } catch (error) {
-          logger13.error(
+          logger14.error(
             { projectId: typed.id, toolId, error },
             "Failed to create tool in project"
           );
@@ -8426,7 +8977,7 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
         }
       });
       await Promise.all(toolPromises);
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           toolCount: Object.keys(typed.tools).length
@@ -8435,7 +8986,7 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       );
     }
     if (typed.dataComponents && Object.keys(typed.dataComponents).length > 0) {
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.dataComponents).length
@@ -8445,7 +8996,7 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       const dataComponentPromises = Object.entries(typed.dataComponents).map(
         async ([componentId, componentData]) => {
           try {
-            logger13.info(
+            logger14.info(
               { projectId: typed.id, componentId },
               "Creating dataComponent in project"
             );
@@ -8456,12 +9007,12 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
                 projectId: typed.id
               }
             });
-            logger13.info(
+            logger14.info(
               { projectId: typed.id, componentId },
               "DataComponent created successfully"
             );
           } catch (error) {
-            logger13.error(
+            logger14.error(
               { projectId: typed.id, componentId, error },
               "Failed to create dataComponent in project"
             );
@@ -8470,7 +9021,7 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
         }
       );
       await Promise.all(dataComponentPromises);
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.dataComponents).length
@@ -8479,7 +9030,7 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       );
     }
     if (typed.artifactComponents && Object.keys(typed.artifactComponents).length > 0) {
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.artifactComponents).length
@@ -8489,7 +9040,7 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       const artifactComponentPromises = Object.entries(typed.artifactComponents).map(
         async ([componentId, componentData]) => {
           try {
-            logger13.info(
+            logger14.info(
               { projectId: typed.id, componentId },
               "Creating artifactComponent in project"
             );
@@ -8500,12 +9051,12 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
                 projectId: typed.id
               }
             });
-            logger13.info(
+            logger14.info(
               { projectId: typed.id, componentId },
               "ArtifactComponent created successfully"
             );
           } catch (error) {
-            logger13.error(
+            logger14.error(
               { projectId: typed.id, componentId, error },
               "Failed to create artifactComponent in project"
             );
@@ -8514,7 +9065,7 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
         }
       );
       await Promise.all(artifactComponentPromises);
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.artifactComponents).length
@@ -8523,7 +9074,7 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       );
     }
     if (typed.graphs && Object.keys(typed.graphs).length > 0) {
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           graphCount: Object.keys(typed.graphs).length
@@ -8532,27 +9083,25 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       );
       const graphPromises = Object.entries(typed.graphs).map(async ([graphId, graphData]) => {
         try {
-          logger13.info({ projectId: typed.id, graphId }, "Creating graph in project");
+          logger14.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, logger13)(
+          await createFullGraphServerSide(db, logger14)(
             { tenantId, projectId: typed.id },
             graphDataWithProjectResources
           );
-          logger13.info({ projectId: typed.id, graphId }, "Graph created successfully in project");
+          logger14.info({ projectId: typed.id, graphId }, "Graph created successfully in project");
         } catch (error) {
-          logger13.error(
+          logger14.error(
             { projectId: typed.id, graphId, error },
             "Failed to create graph in project"
           );
@@ -8560,7 +9109,7 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
         }
       });
       await Promise.all(graphPromises);
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           graphCount: Object.keys(typed.graphs).length
@@ -8568,15 +9117,15 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
         "All project graphs created successfully"
       );
     }
-    logger13.info({ projectId: typed.id }, "Full project created successfully");
+    logger14.info({ projectId: typed.id }, "Full project created successfully");
     return await getFullProject(
       db,
-      logger13
+      logger14
     )({
       scopes: { tenantId, projectId: typed.id }
     });
   } catch (error) {
-    logger13.error(
+    logger14.error(
       {
         tenantId,
         projectId: typed.id,
@@ -8587,13 +9136,13 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
     throw error;
   }
 };
-var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scopes, projectData) => {
+var updateFullProjectServerSide = (db, logger14 = defaultLogger2) => async (scopes, projectData) => {
   const { tenantId } = scopes;
   const typed = validateAndTypeProjectData(projectData);
   if (!typed.id) {
     throw new Error("Project ID is required");
   }
-  logger13.info(
+  logger14.info(
     {
       tenantId,
       projectId: typed.id,
@@ -8606,8 +9155,8 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       scopes: { tenantId, projectId: typed.id }
     });
     if (!existingProject) {
-      logger13.info({ projectId: typed.id }, "Project not found, creating new project");
-      return await createFullProjectServerSide(db, logger13)(
+      logger14.info({ projectId: typed.id }, "Project not found, creating new project");
+      return await createFullProjectServerSide(db, logger14)(
         { tenantId, projectId: typed.id },
         projectData
       );
@@ -8618,14 +9167,14 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       models: typed.models,
       stopWhen: typed.stopWhen
     };
-    logger13.info({ projectId: typed.id }, "Updating project metadata");
+    logger14.info({ projectId: typed.id }, "Updating project metadata");
     await updateProject(db)({
       scopes: { tenantId, projectId: typed.id },
       data: projectUpdatePayload
     });
-    logger13.info({ projectId: typed.id }, "Project metadata updated successfully");
+    logger14.info({ projectId: typed.id }, "Project metadata updated successfully");
     if (typed.credentialReferences && Object.keys(typed.credentialReferences).length > 0) {
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.credentialReferences).length
@@ -8635,7 +9184,7 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       const credentialPromises = Object.entries(typed.credentialReferences).map(
         async ([_credId, credData]) => {
           try {
-            logger13.info(
+            logger14.info(
               { projectId: typed.id, credId: credData.id },
               "Updating credentialReference in project"
             );
@@ -8646,12 +9195,12 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
                 projectId: typed.id
               }
             });
-            logger13.info(
+            logger14.info(
               { projectId: typed.id, credId: credData.id },
               "CredentialReference updated successfully"
             );
           } catch (error) {
-            logger13.error(
+            logger14.error(
               { projectId: typed.id, credId: credData.id, error },
               "Failed to update credentialReference in project"
             );
@@ -8660,7 +9209,7 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
         }
       );
       await Promise.all(credentialPromises);
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.credentialReferences).length
@@ -8669,7 +9218,7 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       );
     }
     if (typed.functions && Object.keys(typed.functions).length > 0) {
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           functionCount: Object.keys(typed.functions).length
@@ -8679,19 +9228,19 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       const functionPromises = Object.entries(typed.functions).map(
         async ([functionId, functionData]) => {
           try {
-            logger13.info({ projectId: typed.id, functionId }, "Updating project function");
+            logger14.info({ projectId: typed.id, functionId }, "Updating project function");
             await upsertFunction(db)({
               data: {
                 ...functionData
               },
               scopes: { tenantId, projectId: typed.id }
             });
-            logger13.info(
+            logger14.info(
               { projectId: typed.id, functionId },
               "Project function updated successfully"
             );
           } catch (error) {
-            logger13.error(
+            logger14.error(
               { projectId: typed.id, functionId, error },
               "Failed to update global function"
             );
@@ -8700,7 +9249,7 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
         }
       );
       await Promise.all(functionPromises);
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           functionCount: Object.keys(typed.functions).length
@@ -8709,7 +9258,7 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       );
     }
     if (typed.tools && Object.keys(typed.tools).length > 0) {
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           toolCount: Object.keys(typed.tools).length
@@ -8718,7 +9267,7 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       );
       const toolPromises = Object.entries(typed.tools).map(async ([toolId, toolData]) => {
         try {
-          logger13.info({ projectId: typed.id, toolId }, "Updating tool in project");
+          logger14.info({ projectId: typed.id, toolId }, "Updating tool in project");
           await upsertTool(db)({
             data: {
               tenantId,
@@ -8726,9 +9275,9 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
               ...toolData
             }
           });
-          logger13.info({ projectId: typed.id, toolId }, "Tool updated successfully");
+          logger14.info({ projectId: typed.id, toolId }, "Tool updated successfully");
         } catch (error) {
-          logger13.error(
+          logger14.error(
             { projectId: typed.id, toolId, error },
             "Failed to update tool in project"
           );
@@ -8736,7 +9285,7 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
         }
       });
       await Promise.all(toolPromises);
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           toolCount: Object.keys(typed.tools).length
@@ -8745,7 +9294,7 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       );
     }
     if (typed.dataComponents && Object.keys(typed.dataComponents).length > 0) {
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.dataComponents).length
@@ -8755,7 +9304,7 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       const dataComponentPromises = Object.entries(typed.dataComponents).map(
         async ([componentId, componentData]) => {
           try {
-            logger13.info(
+            logger14.info(
               { projectId: typed.id, componentId },
               "Updating dataComponent in project"
             );
@@ -8766,12 +9315,12 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
                 projectId: typed.id
               }
             });
-            logger13.info(
+            logger14.info(
               { projectId: typed.id, componentId },
               "DataComponent updated successfully"
             );
           } catch (error) {
-            logger13.error(
+            logger14.error(
               { projectId: typed.id, componentId, error },
               "Failed to update dataComponent in project"
             );
@@ -8780,7 +9329,7 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
         }
       );
       await Promise.all(dataComponentPromises);
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.dataComponents).length
@@ -8789,7 +9338,7 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       );
     }
     if (typed.artifactComponents && Object.keys(typed.artifactComponents).length > 0) {
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.artifactComponents).length
@@ -8799,7 +9348,7 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       const artifactComponentPromises = Object.entries(typed.artifactComponents).map(
         async ([componentId, componentData]) => {
           try {
-            logger13.info(
+            logger14.info(
               { projectId: typed.id, componentId },
               "Updating artifactComponent in project"
             );
@@ -8810,12 +9359,12 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
                 projectId: typed.id
               }
             });
-            logger13.info(
+            logger14.info(
               { projectId: typed.id, componentId },
               "ArtifactComponent updated successfully"
             );
           } catch (error) {
-            logger13.error(
+            logger14.error(
               { projectId: typed.id, componentId, error },
               "Failed to update artifactComponent in project"
             );
@@ -8824,7 +9373,7 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
         }
       );
       await Promise.all(artifactComponentPromises);
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           count: Object.keys(typed.artifactComponents).length
@@ -8842,14 +9391,14 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
         try {
           await deleteFullGraph(
             db,
-            logger13
+            logger14
           )({
             scopes: { tenantId, projectId: typed.id, graphId: graph.id }
           });
           deletedGraphCount++;
-          logger13.info({ graphId: graph.id }, "Deleted orphaned graph from project");
+          logger14.info({ graphId: graph.id }, "Deleted orphaned graph from project");
         } catch (error) {
-          logger13.error(
+          logger14.error(
             { graphId: graph.id, error },
             "Failed to delete orphaned graph from project"
           );
@@ -8857,7 +9406,7 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       }
     }
     if (deletedGraphCount > 0) {
-      logger13.info(
+      logger14.info(
         {
           deletedGraphCount,
           projectId: typed.id
@@ -8866,7 +9415,7 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       );
     }
     if (typed.graphs && Object.keys(typed.graphs).length > 0) {
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           graphCount: Object.keys(typed.graphs).length
@@ -8875,27 +9424,25 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
       );
       const graphPromises = Object.entries(typed.graphs).map(async ([graphId, graphData]) => {
         try {
-          logger13.info({ projectId: typed.id, graphId }, "Updating graph in project");
+          logger14.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, logger13)(
+          await updateFullGraphServerSide(db, logger14)(
             { tenantId, projectId: typed.id },
             graphDataWithProjectResources
           );
-          logger13.info({ projectId: typed.id, graphId }, "Graph updated successfully in project");
+          logger14.info({ projectId: typed.id, graphId }, "Graph updated successfully in project");
         } catch (error) {
-          logger13.error(
+          logger14.error(
             { projectId: typed.id, graphId, error },
             "Failed to update graph in project"
           );
@@ -8903,7 +9450,7 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
         }
       });
       await Promise.all(graphPromises);
-      logger13.info(
+      logger14.info(
         {
           projectId: typed.id,
           graphCount: Object.keys(typed.graphs).length
@@ -8911,15 +9458,15 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
         "All project graphs updated successfully"
       );
     }
-    logger13.info({ projectId: typed.id }, "Full project updated successfully");
+    logger14.info({ projectId: typed.id }, "Full project updated successfully");
     return await getFullProject(
       db,
-      logger13
+      logger14
     )({
       scopes: { tenantId, projectId: typed.id }
     });
   } catch (error) {
-    logger13.error(
+    logger14.error(
       {
         tenantId,
         projectId: typed.id,
@@ -8930,23 +9477,23 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
     throw error;
   }
 };
-var getFullProject = (db, logger13 = defaultLogger2) => async (params) => {
+var getFullProject = (db, logger14 = defaultLogger2) => async (params) => {
   const { scopes } = params;
   const { tenantId, projectId } = scopes;
-  logger13.info({ tenantId, projectId }, "Retrieving full project definition");
+  logger14.info({ tenantId, projectId }, "Retrieving full project definition");
   try {
     const project = await getProject(db)({
       scopes: { tenantId, projectId }
     });
     if (!project) {
-      logger13.info({ tenantId, projectId }, "Project not found");
+      logger14.info({ tenantId, projectId }, "Project not found");
       return null;
     }
-    logger13.info({ tenantId, projectId }, "Project metadata retrieved");
+    logger14.info({ tenantId, projectId }, "Project metadata retrieved");
     const graphList = await listAgentGraphs(db)({
       scopes: { tenantId, projectId }
     });
-    logger13.info(
+    logger14.info(
       {
         tenantId,
         projectId,
@@ -8974,12 +9521,12 @@ var getFullProject = (db, logger13 = defaultLogger2) => async (params) => {
           // status, lastHealthCheck, availableTools, activeTools, lastToolsSync are all runtime
         };
       }
-      logger13.info(
+      logger14.info(
         { tenantId, projectId, toolCount: Object.keys(projectTools).length },
         "Tools retrieved for project"
       );
     } catch (error) {
-      logger13.warn({ tenantId, projectId, error }, "Failed to retrieve tools for project");
+      logger14.warn({ tenantId, projectId, error }, "Failed to retrieve tools for project");
     }
     const projectDataComponents = {};
     try {
@@ -8994,12 +9541,12 @@ var getFullProject = (db, logger13 = defaultLogger2) => async (params) => {
           props: component.props
         };
       }
-      logger13.info(
+      logger14.info(
         { tenantId, projectId, count: Object.keys(projectDataComponents).length },
         "DataComponents retrieved for project"
       );
     } catch (error) {
-      logger13.warn(
+      logger14.warn(
         { tenantId, projectId, error },
         "Failed to retrieve dataComponents for project"
       );
@@ -9017,12 +9564,12 @@ var getFullProject = (db, logger13 = defaultLogger2) => async (params) => {
           props: component.props
         };
       }
-      logger13.info(
+      logger14.info(
         { tenantId, projectId, count: Object.keys(projectArtifactComponents).length },
         "ArtifactComponents retrieved for project"
       );
     } catch (error) {
-      logger13.warn(
+      logger14.warn(
         { tenantId, projectId, error },
         "Failed to retrieve artifactComponents for project"
       );
@@ -9040,12 +9587,12 @@ var getFullProject = (db, logger13 = defaultLogger2) => async (params) => {
           retrievalParams: credential.retrievalParams
         };
       }
-      logger13.info(
+      logger14.info(
         { tenantId, projectId, count: Object.keys(projectCredentialReferences).length },
         "CredentialReferences retrieved for project"
       );
     } catch (error) {
-      logger13.warn(
+      logger14.warn(
         { tenantId, projectId, error },
         "Failed to retrieve credentialReferences for project"
       );
@@ -9054,7 +9601,7 @@ var getFullProject = (db, logger13 = defaultLogger2) => async (params) => {
     if (graphList.length > 0) {
       const graphPromises = graphList.map(async (graph) => {
         try {
-          logger13.info(
+          logger14.info(
             { tenantId, projectId, graphId: graph.id },
             "Retrieving full graph definition"
           );
@@ -9063,15 +9610,15 @@ var getFullProject = (db, logger13 = defaultLogger2) => async (params) => {
           });
           if (fullGraph) {
             graphs[graph.id] = fullGraph;
-            logger13.info(
+            logger14.info(
               { tenantId, projectId, graphId: graph.id },
               "Full graph definition retrieved"
             );
           } else {
-            logger13.warn({ tenantId, projectId, graphId: graph.id }, "Graph definition not found");
+            logger14.warn({ tenantId, projectId, graphId: graph.id }, "Graph definition not found");
           }
         } catch (error) {
-          logger13.error(
+          logger14.error(
             { tenantId, projectId, graphId: graph.id, error },
             "Failed to retrieve full graph definition"
           );
@@ -9098,7 +9645,7 @@ var getFullProject = (db, logger13 = defaultLogger2) => async (params) => {
       createdAt: project.createdAt,
       updatedAt: project.updatedAt
     };
-    logger13.info(
+    logger14.info(
       {
         tenantId,
         projectId,
@@ -9108,7 +9655,7 @@ var getFullProject = (db, logger13 = defaultLogger2) => async (params) => {
     );
     return fullProjectDefinition;
   } catch (error) {
-    logger13.error(
+    logger14.error(
       {
         tenantId,
         projectId,
@@ -9119,23 +9666,23 @@ var getFullProject = (db, logger13 = defaultLogger2) => async (params) => {
     throw error;
   }
 };
-var deleteFullProject = (db, logger13 = defaultLogger2) => async (params) => {
+var deleteFullProject = (db, logger14 = defaultLogger2) => async (params) => {
   const { scopes } = params;
   const { tenantId, projectId } = scopes;
-  logger13.info({ tenantId, projectId }, "Deleting full project and related entities");
+  logger14.info({ tenantId, projectId }, "Deleting full project and related entities");
   try {
     const project = await getFullProject(
       db,
-      logger13
+      logger14
     )({
       scopes: { tenantId, projectId }
     });
     if (!project) {
-      logger13.info({ tenantId, projectId }, "Project not found for deletion");
+      logger14.info({ tenantId, projectId }, "Project not found for deletion");
       return false;
     }
     if (project.graphs && Object.keys(project.graphs).length > 0) {
-      logger13.info(
+      logger14.info(
         {
           tenantId,
           projectId,
@@ -9145,19 +9692,19 @@ var deleteFullProject = (db, logger13 = defaultLogger2) => async (params) => {
       );
       const graphPromises = Object.keys(project.graphs).map(async (graphId) => {
         try {
-          logger13.info({ tenantId, projectId, graphId }, "Deleting graph from project");
+          logger14.info({ tenantId, projectId, graphId }, "Deleting graph from project");
           await deleteFullGraph(
             db,
-            logger13
+            logger14
           )({
             scopes: { tenantId, projectId, graphId }
           });
-          logger13.info(
+          logger14.info(
             { tenantId, projectId, graphId },
             "Graph deleted successfully from project"
           );
         } catch (error) {
-          logger13.error(
+          logger14.error(
             { tenantId, projectId, graphId, error },
             "Failed to delete graph from project"
           );
@@ -9165,7 +9712,7 @@ var deleteFullProject = (db, logger13 = defaultLogger2) => async (params) => {
         }
       });
       await Promise.all(graphPromises);
-      logger13.info(
+      logger14.info(
         {
           tenantId,
           projectId,
@@ -9178,13 +9725,13 @@ var deleteFullProject = (db, logger13 = defaultLogger2) => async (params) => {
       scopes: { tenantId, projectId }
     });
     if (!deleted) {
-      logger13.warn({ tenantId, projectId }, "Project deletion returned false");
+      logger14.warn({ tenantId, projectId }, "Project deletion returned false");
       return false;
     }
-    logger13.info({ tenantId, projectId }, "Full project deleted successfully");
+    logger14.info({ tenantId, projectId }, "Full project deleted successfully");
     return true;
   } catch (error) {
-    logger13.error(
+    logger14.error(
       {
         tenantId,
         projectId,
@@ -9262,7 +9809,7 @@ var createValidatedDataAccess = (db, dataAccessFunctions) => {
 
 // src/utils/tracer.ts
 var tracer = getTracer("agents-core");
-var logger7 = getLogger("context-cache");
+var logger8 = getLogger("context-cache");
 var ContextCache = class {
   constructor(tenantId, projectId, dbClient) {
     __publicField(this, "tenantId");
@@ -9271,7 +9818,7 @@ var ContextCache = class {
     this.tenantId = tenantId;
     this.projectId = projectId;
     this.dbClient = dbClient;
-    logger7.info(
+    logger8.info(
       {
         tenantId: this.tenantId
       },
@@ -9306,7 +9853,7 @@ var ContextCache = class {
         tenantId: this.tenantId
       };
     } catch (error) {
-      logger7.error(
+      logger8.error(
         {
           conversationId,
           contextConfigId,
@@ -9340,7 +9887,7 @@ var ContextCache = class {
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       await setCacheEntry(this.dbClient)(cacheData);
-      logger7.debug(
+      logger8.debug(
         {
           conversationId: entry.conversationId,
           contextConfigId: entry.contextConfigId,
@@ -9349,7 +9896,7 @@ var ContextCache = class {
         "Cache entry set successfully"
       );
     } catch (error) {
-      logger7.error(
+      logger8.error(
         {
           conversationId: entry.conversationId,
           contextConfigId: entry.contextConfigId,
@@ -9369,7 +9916,7 @@ var ContextCache = class {
         scopes: { tenantId, projectId },
         conversationId
       });
-      logger7.info(
+      logger8.info(
         {
           conversationId,
           rowsCleared: result
@@ -9377,7 +9924,7 @@ var ContextCache = class {
         "Conversation cache cleared successfully"
       );
     } catch (error) {
-      logger7.error(
+      logger8.error(
         {
           conversationId,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -9396,7 +9943,7 @@ var ContextCache = class {
         scopes: { tenantId, projectId },
         contextConfigId
       });
-      logger7.info(
+      logger8.info(
         {
           contextConfigId,
           rowsCleared: result
@@ -9404,7 +9951,7 @@ var ContextCache = class {
         "Context config cache cleared successfully"
       );
     } catch (error) {
-      logger7.error(
+      logger8.error(
         {
           contextConfigId,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -9422,14 +9969,14 @@ var ContextCache = class {
       const result = await cleanupTenantCache(this.dbClient)({
         scopes: { tenantId: this.tenantId, projectId: this.projectId }
       });
-      logger7.info(
+      logger8.info(
         {
           rowsCleared: result
         },
         "Cache cleanup completed"
       );
     } catch (error) {
-      logger7.error(
+      logger8.error(
         {
           error: error instanceof Error ? error.message : "Unknown error"
         },
@@ -9456,7 +10003,7 @@ var ContextCache = class {
 };
 
 // src/context/ContextResolver.ts
-var logger8 = getLogger("context-resolver");
+var logger9 = getLogger("context-resolver");
 var ContextResolver = class {
   constructor(tenantId, projectId, dbClient, credentialStoreRegistry) {
     __publicField(this, "fetcher");
@@ -9467,7 +10014,7 @@ var ContextResolver = class {
     this.projectId = projectId;
     this.fetcher = new ContextFetcher(tenantId, projectId, dbClient, credentialStoreRegistry);
     this.cache = new ContextCache(tenantId, projectId, dbClient);
-    logger8.info(
+    logger9.info(
       {
         tenantId: this.tenantId,
         hasCredentialSupport: !!credentialStoreRegistry
@@ -9480,7 +10027,7 @@ var ContextResolver = class {
    */
   async resolve(contextConfig2, options) {
     const startTime = Date.now();
-    logger8.info(
+    logger9.info(
       {
         contextConfigId: contextConfig2.id,
         triggerEvent: options.triggerEvent,
@@ -9520,7 +10067,7 @@ var ContextResolver = class {
               options.conversationId,
               contextConfig2.id
             );
-            logger8.info(
+            logger9.info(
               {
                 conversationId: options.conversationId,
                 contextConfigId: contextConfig2.id
@@ -9534,7 +10081,7 @@ var ContextResolver = class {
               value: options.headers,
               tenantId: this.tenantId
             });
-            logger8.info(
+            logger9.info(
               {
                 conversationId: options.conversationId,
                 contextConfigId: contextConfig2.id
@@ -9550,7 +10097,7 @@ var ContextResolver = class {
           const contextVariables = contextConfig2.contextVariables || {};
           const contextVariableEntries = Object.entries(contextVariables);
           if (contextVariableEntries.length === 0) {
-            logger8.info(
+            logger9.info(
               {
                 contextConfigId: contextConfig2.id
               },
@@ -9586,7 +10133,7 @@ var ContextResolver = class {
               result
             ).catch((error) => {
               const errorMessage = error instanceof Error ? error.message : "Unknown error";
-              logger8.error(
+              logger9.error(
                 {
                   contextConfigId: contextConfig2.id,
                   definitionId: definition.id,
@@ -9601,7 +10148,7 @@ var ContextResolver = class {
               });
               if (definition.defaultValue !== void 0) {
                 result.resolvedContext[templateKey] = definition.defaultValue;
-                logger8.info(
+                logger9.info(
                   {
                     contextConfigId: contextConfig2.id,
                     definitionId: definition.id,
@@ -9626,7 +10173,7 @@ var ContextResolver = class {
           } else {
             parentSpan.setStatus({ code: api.SpanStatusCode.OK });
           }
-          logger8.info(
+          logger9.info(
             {
               contextConfigId: contextConfig2.id,
               resolvedKeys: Object.keys(result.resolvedContext),
@@ -9642,7 +10189,7 @@ var ContextResolver = class {
         } catch (error) {
           const durationMs = Date.now() - startTime;
           setSpanWithError(parentSpan, error instanceof Error ? error : new Error(String(error)));
-          logger8.error(
+          logger9.error(
             {
               contextConfigId: contextConfig2.id,
               error: error instanceof Error ? error.message : String(error),
@@ -9670,7 +10217,7 @@ var ContextResolver = class {
     if (cachedEntry) {
       result.resolvedContext[templateKey] = cachedEntry.value;
       result.cacheHits.push(definition.id);
-      logger8.debug(
+      logger9.debug(
         {
           definitionId: definition.id,
           templateKey,
@@ -9681,7 +10228,7 @@ var ContextResolver = class {
       return;
     }
     result.cacheMisses.push(definition.id);
-    logger8.debug(
+    logger9.debug(
       {
         definitionId: definition.id,
         templateKey,
@@ -9738,7 +10285,7 @@ var ContextResolver = class {
       requestHash,
       tenantId: this.tenantId
     });
-    logger8.debug(
+    logger9.debug(
       {
         definitionId: definition.id,
         templateKey,
@@ -9773,7 +10320,7 @@ var ContextResolver = class {
    */
   async clearCache(tenantId, projectId, conversationId) {
     await this.cache.clearConversation(tenantId, projectId, conversationId);
-    logger8.info(
+    logger9.info(
       {
         conversationId
       },
@@ -9783,7 +10330,7 @@ var ContextResolver = class {
 };
 
 // src/middleware/contextValidation.ts
-var logger9 = getLogger("context-validation");
+var logger10 = getLogger("context-validation");
 var ajv = new Ajv__default.default({ allErrors: true, strict: false });
 var HTTP_REQUEST_PARTS = ["headers"];
 var MAX_SCHEMA_CACHE_SIZE = 1e3;
@@ -9846,7 +10393,7 @@ function validationHelper(jsonSchema) {
   return getCachedValidator(jsonSchema);
 }
 function validateAgainstJsonSchema(jsonSchema, context) {
-  logger9.debug({ jsonSchema, context }, "Validating context against JSON Schema");
+  logger10.debug({ jsonSchema, context }, "Validating context against JSON Schema");
   const validate = validationHelper(jsonSchema);
   return validate(context);
 }
@@ -9936,7 +10483,7 @@ async function validateHttpRequestHeaders(headersSchema, httpRequest) {
       validatedContext: filteredContext
     };
   } catch (error) {
-    logger9.error(
+    logger10.error(
       { error: error instanceof Error ? error.message : "Unknown error" },
       "Failed to validate headers schema"
     );
@@ -9989,7 +10536,7 @@ async function validateHeaders({
       scopes: { tenantId, projectId, graphId }
     });
     if (!agentGraph2?.contextConfigId) {
-      logger9.debug({ graphId }, "No context config found for graph, skipping validation");
+      logger10.debug({ graphId }, "No context config found for graph, skipping validation");
       return {
         valid: true,
         errors: [],
@@ -10001,7 +10548,7 @@ async function validateHeaders({
       id: agentGraph2.contextConfigId
     });
     if (!contextConfig2) {
-      logger9.warn({ contextConfigId: agentGraph2.contextConfigId }, "Context config not found");
+      logger10.warn({ contextConfigId: agentGraph2.contextConfigId }, "Context config not found");
       return {
         valid: false,
         errors: [
@@ -10013,7 +10560,7 @@ async function validateHeaders({
       };
     }
     if (!contextConfig2.headersSchema) {
-      logger9.debug(
+      logger10.debug(
         { contextConfigId: contextConfig2.id },
         "No headers schema defined, accepting any context"
       );
@@ -10025,7 +10572,7 @@ async function validateHeaders({
     }
     try {
       const schema = contextConfig2.headersSchema;
-      logger9.debug({ contextConfigId: contextConfig2.id }, "Using headers schema validation");
+      logger10.debug({ contextConfigId: contextConfig2.id }, "Using headers schema validation");
       const httpRequest = parsedRequest;
       const validationResult = await validateHttpRequestHeaders(schema, httpRequest);
       if (validationResult.valid) {
@@ -10048,7 +10595,7 @@ async function validateHeaders({
         return validationResult;
       }
     } catch (error) {
-      logger9.error(
+      logger10.error(
         {
           contextConfigId: contextConfig2.id,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -10066,7 +10613,7 @@ async function validateHeaders({
       };
     }
   } catch (error) {
-    logger9.error(
+    logger10.error(
       {
         tenantId,
         graphId,
@@ -10118,7 +10665,7 @@ function contextValidationMiddleware(dbClient) {
         credentialStores
       });
       if (!validationResult.valid) {
-        logger9.warn(
+        logger10.warn(
           {
             tenantId,
             graphId,
@@ -10133,7 +10680,7 @@ function contextValidationMiddleware(dbClient) {
         });
       }
       c.set("validatedContext", validationResult.validatedContext);
-      logger9.debug(
+      logger10.debug(
         {
           tenantId,
           graphId,
@@ -10143,7 +10690,7 @@ function contextValidationMiddleware(dbClient) {
       );
       return next();
     } catch (error) {
-      logger9.error(
+      logger10.error(
         {
           error: error instanceof Error ? error.message : "Unknown error"
         },
@@ -10158,7 +10705,7 @@ function contextValidationMiddleware(dbClient) {
 }
 
 // src/context/ContextFetcher.ts
-var logger10 = getLogger("context-fetcher");
+var logger11 = getLogger("context-fetcher");
 var checkGraphQLErrors = (data) => {
   if (data && typeof data === "object" && "errors" in data) {
     const errorObj = data;
@@ -10187,7 +10734,7 @@ var ContextFetcher = class {
       this.credentialStuffer = new CredentialStuffer(credentialStoreRegistry);
     }
     this.dbClient = dbClient;
-    logger10.info(
+    logger11.info(
       {
         tenantId: this.tenantId,
         defaultTimeout: this.defaultTimeout,
@@ -10201,7 +10748,7 @@ var ContextFetcher = class {
    */
   async fetch(definition, context) {
     const startTime = Date.now();
-    logger10.info(
+    logger11.info(
       {
         definitionId: definition.id,
         url: definition.fetchConfig.url
@@ -10215,7 +10762,7 @@ var ContextFetcher = class {
         definition.credentialReferenceId
       );
       const response = await this.performRequest(resolvedConfig);
-      logger10.info({ response }, "ContextFetcher Response");
+      logger11.info({ response }, "ContextFetcher Response");
       let transformedData = response.data;
       if (definition.fetchConfig.transform) {
         transformedData = this.transformResponse(response.data, definition.fetchConfig.transform);
@@ -10228,7 +10775,7 @@ var ContextFetcher = class {
         );
       }
       const durationMs = Date.now() - startTime;
-      logger10.info(
+      logger11.info(
         {
           definitionId: definition.id,
           source: response.source,
@@ -10240,7 +10787,7 @@ var ContextFetcher = class {
     } catch (error) {
       const durationMs = Date.now() - startTime;
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      logger10.error(
+      logger11.error(
         {
           definitionId: definition.id,
           error: errorMessage,
@@ -10257,7 +10804,7 @@ var ContextFetcher = class {
         scopes: { tenantId: this.tenantId, projectId: this.projectId },
         id: credentialReferenceId
       });
-      logger10.info({ credentialReference }, "Credential reference");
+      logger11.info({ credentialReference }, "Credential reference");
       if (!credentialReference || !this.credentialStuffer) {
         throw new Error(`Credential store not found for reference ID: ${credentialReferenceId}`);
       }
@@ -10275,7 +10822,7 @@ var ContextFetcher = class {
       );
       return credentialData;
     } catch (error) {
-      logger10.error(
+      logger11.error(
         {
           credentialReferenceId,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -10291,7 +10838,7 @@ var ContextFetcher = class {
   async resolveTemplateVariables(fetchConfig, context, credentialReferenceId) {
     const resolved = { ...fetchConfig };
     resolved.url = this.interpolateTemplate(fetchConfig.url, context);
-    logger10.info({ resolvedUrl: resolved.url }, "Resolved URL");
+    logger11.info({ resolvedUrl: resolved.url }, "Resolved URL");
     if (fetchConfig.headers) {
       resolved.headers = {};
       for (const [key, value] of Object.entries(fetchConfig.headers)) {
@@ -10310,7 +10857,7 @@ var ContextFetcher = class {
             ...resolved.headers,
             ...credentialHeaders
           };
-          logger10.info(
+          logger11.info(
             {
               credentialReferenceId
             },
@@ -10318,7 +10865,7 @@ var ContextFetcher = class {
           );
         }
       } catch (error) {
-        logger10.error(
+        logger11.error(
           {
             credentialReferenceId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -10340,7 +10887,7 @@ var ContextFetcher = class {
         preserveUnresolved: true
       });
     } catch (error) {
-      logger10.error(
+      logger11.error(
         {
           template,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -10372,7 +10919,7 @@ var ContextFetcher = class {
   async performRequest(config) {
     const startTime = Date.now();
     try {
-      logger10.debug(
+      logger11.debug(
         {
           url: config.url,
           method: config.method
@@ -10409,7 +10956,7 @@ var ContextFetcher = class {
     } catch (error) {
       const durationMs = Date.now() - startTime;
       const requestError = error instanceof Error ? error : new Error("Unknown error");
-      logger10.warn(
+      logger11.warn(
         {
           url: config.url,
           error: requestError.message,
@@ -10428,7 +10975,7 @@ var ContextFetcher = class {
       const result = jmespath__default.default.search(data, transform);
       return result;
     } catch (error) {
-      logger10.error(
+      logger11.error(
         {
           transform,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -10447,7 +10994,7 @@ var ContextFetcher = class {
       if (!isValid) {
         throw new Error("Data does not match JSON Schema");
       }
-      logger10.debug(
+      logger11.debug(
         {
           definitionId,
           dataType: typeof data,
@@ -10457,7 +11004,7 @@ var ContextFetcher = class {
       );
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown validation error";
-      logger10.error(
+      logger11.error(
         {
           definitionId,
           jsonSchema,
@@ -10498,7 +11045,7 @@ var ContextFetcher = class {
     };
   }
 };
-var logger11 = getLogger("context");
+var logger12 = getLogger("context");
 async function determineContextTrigger(tenantId, projectId, conversationId, dbClient) {
   const conversation = await getConversation(dbClient)({
     scopes: { tenantId, projectId },
@@ -10518,7 +11065,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);
-    logger11.info(
+    logger12.info(
       {
         conversationId,
         graphId,
@@ -10552,7 +11099,7 @@ async function handleContextResolution({
           scopes: { tenantId, projectId, graphId }
         });
         if (!agentGraph2?.contextConfigId) {
-          logger11.debug({ graphId }, "No context config found for graph");
+          logger12.debug({ graphId }, "No context config found for graph");
           return null;
         }
         await handleContextConfigChange(
@@ -10570,7 +11117,7 @@ async function handleContextResolution({
           id: agentGraph2.contextConfigId
         });
         if (!contextConfig2) {
-          logger11.warn(
+          logger12.warn(
             { contextConfigId: agentGraph2.contextConfigId },
             "Context config not found, proceeding without context resolution"
           );
@@ -10612,7 +11159,7 @@ async function handleContextResolution({
         } else {
           parentSpan.setStatus({ code: api.SpanStatusCode.OK });
         }
-        logger11.info(
+        logger12.info(
           {
             conversationId,
             graphId,
@@ -10634,7 +11181,7 @@ async function handleContextResolution({
           "context.error_message": errorMessage
         });
         setSpanWithError(parentSpan, error instanceof Error ? error : new Error(String(error)));
-        logger11.error(
+        logger12.error(
           {
             error: errorMessage,
             contextConfigId: agentGraph2?.contextConfigId,
@@ -10975,7 +11522,7 @@ var InMemoryCredentialStore = class {
     return this.credentials.delete(key);
   }
 };
-var logger12 = getLogger("nango-credential-store");
+var logger13 = getLogger("nango-credential-store");
 var CredentialKeySchema = zod.z.object({
   connectionId: zod.z.string().min(1, "connectionId must be a non-empty string"),
   providerConfigKey: zod.z.string().min(1, "providerConfigKey must be a non-empty string")
@@ -11115,7 +11662,7 @@ var NangoCredentialStore = class {
       if (error && typeof error === "object" && "status" in error && error.status === 404) {
         return null;
       }
-      logger12.error(
+      logger13.error(
         { error: error instanceof Error ? error.message : "Unknown error", uniqueKey },
         `Failed to fetch integration ${uniqueKey}`
       );
@@ -11141,7 +11688,7 @@ var NangoCredentialStore = class {
     });
     const result = JSON.stringify(essential);
     if (result.length > 1024) {
-      logger12.error(
+      logger13.error(
         {
           originalLength: tokenData.length,
           essentialLength: result.length,
@@ -11215,7 +11762,7 @@ var NangoCredentialStore = class {
         );
       }
     } catch (error) {
-      logger12.error(
+      logger13.error(
         {
           error: error instanceof Error ? error.message : "Unknown error",
           name
@@ -11250,7 +11797,7 @@ var NangoCredentialStore = class {
       };
       return credentialData;
     } catch (error) {
-      logger12.error(
+      logger13.error(
         {
           error: error instanceof Error ? error.message : "Unknown error",
           connectionId,
@@ -11271,7 +11818,7 @@ var NangoCredentialStore = class {
       try {
         parsedKey = JSON.parse(key);
       } catch (parseError) {
-        logger12.warn(
+        logger13.warn(
           {
             storeId: this.id,
             key: key.substring(0, 50),
@@ -11284,7 +11831,7 @@ var NangoCredentialStore = class {
       }
       const validationResult = CredentialKeySchema.safeParse(parsedKey);
       if (!validationResult.success) {
-        logger12.warn(
+        logger13.warn(
           {
             storeId: this.id,
             key: key.substring(0, 100),
@@ -11302,7 +11849,7 @@ var NangoCredentialStore = class {
       const credentialString = JSON.stringify(credentials);
       return credentialString;
     } catch (error) {
-      logger12.error(
+      logger13.error(
         {
           storeId: this.id,
           key: key.substring(0, 100),
@@ -11331,7 +11878,7 @@ var NangoCredentialStore = class {
       const credentials = await this.get(key);
       return credentials !== null;
     } catch (error) {
-      logger12.error(
+      logger13.error(
         {
           error: error instanceof Error ? error.message : "Unknown error",
           key
@@ -11350,7 +11897,7 @@ var NangoCredentialStore = class {
       try {
         parsedKey = JSON.parse(key);
       } catch (parseError) {
-        logger12.warn(
+        logger13.warn(
           {
             storeId: this.id,
             key: key.substring(0, 50),
@@ -11363,7 +11910,7 @@ var NangoCredentialStore = class {
       }
       const validationResult = CredentialKeySchema.safeParse(parsedKey);
       if (!validationResult.success) {
-        logger12.warn(
+        logger13.warn(
           {
             storeId: this.id,
             key: key.substring(0, 100),
@@ -11377,7 +11924,7 @@ var NangoCredentialStore = class {
       await this.nangoClient.deleteConnection(providerConfigKey, connectionId);
       return true;
     } catch (error) {
-      logger12.error(
+      logger13.error(
         {
           storeId: this.id,
           key: key.substring(0, 100),
@@ -11624,13 +12171,20 @@ exports.FIELD_TYPES = FIELD_TYPES;
 exports.FetchConfigSchema = FetchConfigSchema;
 exports.FetchDefinitionSchema = FetchDefinitionSchema;
 exports.FullGraphAgentInsertSchema = FullGraphAgentInsertSchema;
+exports.FullGraphDefinitionSchema = FullGraphDefinitionSchema;
 exports.FullProjectDefinitionSchema = FullProjectDefinitionSchema;
 exports.FunctionApiInsertSchema = FunctionApiInsertSchema;
 exports.FunctionApiSelectSchema = FunctionApiSelectSchema;
 exports.FunctionApiUpdateSchema = FunctionApiUpdateSchema;
 exports.FunctionInsertSchema = FunctionInsertSchema;
 exports.FunctionSelectSchema = FunctionSelectSchema;
+exports.FunctionToolApiInsertSchema = FunctionToolApiInsertSchema;
+exports.FunctionToolApiSelectSchema = FunctionToolApiSelectSchema;
+exports.FunctionToolApiUpdateSchema = FunctionToolApiUpdateSchema;
 exports.FunctionToolConfigSchema = FunctionToolConfigSchema;
+exports.FunctionToolInsertSchema = FunctionToolInsertSchema;
+exports.FunctionToolSelectSchema = FunctionToolSelectSchema;
+exports.FunctionToolUpdateSchema = FunctionToolUpdateSchema;
 exports.FunctionUpdateSchema = FunctionUpdateSchema;
 exports.GraphStopWhenSchema = GraphStopWhenSchema;
 exports.GraphWithinContextOfProjectSchema = GraphWithinContextOfProjectSchema;
@@ -11758,8 +12312,11 @@ exports.TransferDataSchema = TransferDataSchema;
 exports.UNKNOWN_VALUE = UNKNOWN_VALUE;
 exports.URL_SAFE_ID_PATTERN = URL_SAFE_ID_PATTERN;
 exports.VALID_RELATION_TYPES = VALID_RELATION_TYPES;
+exports.addFunctionToolToSubAgent = addFunctionToolToSubAgent;
 exports.addLedgerArtifacts = addLedgerArtifacts;
 exports.addToolToAgent = addToolToAgent;
+exports.agentFunctionToolRelations = agentFunctionToolRelations;
+exports.agentFunctionToolRelationsRelations = agentFunctionToolRelationsRelations;
 exports.agentGraph = agentGraph;
 exports.agentGraphRelations = agentGraphRelations;
 exports.agentToolRelationsRelations = agentToolRelationsRelations;
@@ -11813,6 +12370,7 @@ exports.createExternalAgent = createExternalAgent;
 exports.createExternalAgentRelation = createExternalAgentRelation;
 exports.createFullGraphServerSide = createFullGraphServerSide;
 exports.createFullProjectServerSide = createFullProjectServerSide;
+exports.createFunctionTool = createFunctionTool;
 exports.createInMemoryDatabaseClient = createInMemoryDatabaseClient;
 exports.createKeyChainStore = createKeyChainStore;
 exports.createMessage = createMessage;
@@ -11845,6 +12403,7 @@ exports.deleteExternalAgent = deleteExternalAgent;
 exports.deleteFullGraph = deleteFullGraph;
 exports.deleteFullProject = deleteFullProject;
 exports.deleteFunction = deleteFunction;
+exports.deleteFunctionTool = deleteFunctionTool;
 exports.deleteLedgerArtifactsByContext = deleteLedgerArtifactsByContext;
 exports.deleteLedgerArtifactsByTask = deleteLedgerArtifactsByTask;
 exports.deleteMessage = deleteMessage;
@@ -11865,6 +12424,8 @@ exports.extractPreviewFields = extractPreviewFields;
 exports.extractPublicId = extractPublicId;
 exports.fetchComponentRelationships = fetchComponentRelationships;
 exports.fetchDefinition = fetchDefinition;
+exports.functionTools = functionTools;
+exports.functionToolsRelations = functionToolsRelations;
 exports.functions = functions;
 exports.functionsRelations = functionsRelations;
 exports.generateAndCreateApiKey = generateAndCreateApiKey;
@@ -11911,6 +12472,8 @@ exports.getFullGraph = getFullGraph;
 exports.getFullGraphDefinition = getFullGraphDefinition;
 exports.getFullProject = getFullProject;
 exports.getFunction = getFunction;
+exports.getFunctionToolById = getFunctionToolById;
+exports.getFunctionToolsForSubAgent = getFunctionToolsForSubAgent;
 exports.getGraphAgentInfos = getGraphAgentInfos;
 exports.getLedgerArtifacts = getLedgerArtifacts;
 exports.getLedgerArtifactsByContext = getLedgerArtifactsByContext;
@@ -11967,6 +12530,7 @@ exports.listDataComponents = listDataComponents;
 exports.listDataComponentsPaginated = listDataComponentsPaginated;
 exports.listExternalAgents = listExternalAgents;
 exports.listExternalAgentsPaginated = listExternalAgentsPaginated;
+exports.listFunctionTools = listFunctionTools;
 exports.listFunctions = listFunctions;
 exports.listMessages = listMessages;
 exports.listProjects = listProjects;
@@ -12024,24 +12588,28 @@ exports.updateDataComponent = updateDataComponent;
 exports.updateExternalAgent = updateExternalAgent;
 exports.updateFullGraphServerSide = updateFullGraphServerSide;
 exports.updateFullProjectServerSide = updateFullProjectServerSide;
+exports.updateFunctionTool = updateFunctionTool;
 exports.updateMessage = updateMessage;
 exports.updateProject = updateProject;
 exports.updateSubAgent = updateSubAgent;
+exports.updateSubAgentFunctionToolRelation = updateSubAgentFunctionToolRelation;
 exports.updateTask = updateTask;
 exports.updateTool = updateTool;
 exports.upsertAgentArtifactComponentRelation = upsertAgentArtifactComponentRelation;
 exports.upsertAgentDataComponentRelation = upsertAgentDataComponentRelation;
 exports.upsertAgentGraph = upsertAgentGraph;
 exports.upsertAgentRelation = upsertAgentRelation;
-exports.upsertAgentToolRelation = upsertAgentToolRelation;
 exports.upsertArtifactComponent = upsertArtifactComponent;
 exports.upsertContextConfig = upsertContextConfig;
 exports.upsertCredentialReference = upsertCredentialReference;
 exports.upsertDataComponent = upsertDataComponent;
 exports.upsertExternalAgent = upsertExternalAgent;
 exports.upsertFunction = upsertFunction;
+exports.upsertFunctionTool = upsertFunctionTool;
 exports.upsertLedgerArtifact = upsertLedgerArtifact;
 exports.upsertSubAgent = upsertSubAgent;
+exports.upsertSubAgentFunctionToolRelation = upsertSubAgentFunctionToolRelation;
+exports.upsertSubAgentToolRelation = upsertSubAgentToolRelation;
 exports.upsertTool = upsertTool;
 exports.validateAgainstJsonSchema = validateAgainstJsonSchema;
 exports.validateAgentRelationships = validateAgentRelationships;