@inkeep/agents-core 0.2.1 → 0.3.0

package/dist/index.cjs

@@ -23,12 +23,22 @@ var ai = require('ai');
 var exitHook = require('exit-hook');
 var tsPattern = require('ts-pattern');
 var node = require('@nangohq/node');
+var fs = require('fs');
+var os = require('os');
+var path = require('path');
+var dotenv = require('dotenv');
+var dotenvExpand = require('dotenv-expand');
+var findUp = require('find-up');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var jmespath__default = /*#__PURE__*/_interopDefault(jmespath);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var os__default = /*#__PURE__*/_interopDefault(os);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var dotenv__default = /*#__PURE__*/_interopDefault(dotenv);
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -122,6 +132,7 @@ __export(schema_exports, {
   agentArtifactComponents: () => agentArtifactComponents,
   agentArtifactComponentsRelations: () => agentArtifactComponentsRelations,
   agentDataComponents: () => agentDataComponents,
+  agentDataComponentsRelations: () => agentDataComponentsRelations,
   agentGraph: () => agentGraph,
   agentGraphRelations: () => agentGraphRelations,
   agentRelations: () => agentRelations,
@@ -143,10 +154,12 @@ __export(schema_exports, {
   credentialReferences: () => credentialReferences,
   credentialReferencesRelations: () => credentialReferencesRelations,
   dataComponents: () => dataComponents,
+  dataComponentsRelations: () => dataComponentsRelations,
   externalAgents: () => externalAgents,
   externalAgentsRelations: () => externalAgentsRelations,
   ledgerArtifacts: () => ledgerArtifacts,
   ledgerArtifactsContextIdIdx: () => ledgerArtifactsContextIdIdx,
+  ledgerArtifactsRelations: () => ledgerArtifactsRelations,
   ledgerArtifactsTaskContextNameUnique: () => ledgerArtifactsTaskContextNameUnique,
   ledgerArtifactsTaskIdIdx: () => ledgerArtifactsTaskIdIdx,
   messages: () => messages,
@@ -177,11 +190,44 @@ var projects = sqliteCore.sqliteTable(
   },
   (table) => [sqliteCore.primaryKey({ columns: [table.tenantId, table.id] })]
 );
+var agentGraph = sqliteCore.sqliteTable(
+  "agent_graph",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    name: sqliteCore.text("name").notNull(),
+    description: sqliteCore.text("description"),
+    defaultAgentId: sqliteCore.text("default_agent_id"),
+    // Reference to shared context configuration for all agents in this graph
+    contextConfigId: sqliteCore.text("context_config_id"),
+    // add fk relationship
+    // Graph-level model settingsuration that can be inherited by agents
+    models: sqliteCore.text("models", { mode: "json" }).$type(),
+    // Status updates configuration for intelligent progress summaries
+    statusUpdates: sqliteCore.text("status_updates", { mode: "json" }).$type(),
+    // Graph-level prompt that can be used as additional context for agents
+    graphPrompt: sqliteCore.text("graph_prompt"),
+    // Graph-level stopWhen configuration that can be inherited by agents
+    stopWhen: sqliteCore.text("stop_when", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "agent_graph_project_fk"
+    }).onDelete("cascade")
+  ]
+);
 var contextConfigs = sqliteCore.sqliteTable(
   "context_configs",
   {
     tenantId: sqliteCore.text("tenant_id").notNull(),
     projectId: sqliteCore.text("project_id").notNull(),
+    // Add graph level scoping
     id: sqliteCore.text("id").notNull(),
     name: sqliteCore.text("name").notNull(),
     description: sqliteCore.text("description").notNull(),
@@ -246,6 +292,7 @@ var agents = sqliteCore.sqliteTable(
   {
     tenantId: sqliteCore.text("tenant_id").notNull(),
     projectId: sqliteCore.text("project_id").notNull(),
+    graphId: sqliteCore.text("graph_id").notNull(),
     id: sqliteCore.text("id").notNull(),
     name: sqliteCore.text("name").notNull(),
     description: sqliteCore.text("description").notNull(),
@@ -260,11 +307,11 @@ var agents = sqliteCore.sqliteTable(
     updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId],
-      foreignColumns: [projects.tenantId, projects.id],
-      name: "agents_project_fk"
+      columns: [table.tenantId, table.projectId, table.graphId],
+      foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
+      name: "agents_graph_fk"
     }).onDelete("cascade")
   ]
 );
@@ -273,8 +320,8 @@ var agentRelations = sqliteCore.sqliteTable(
   {
     tenantId: sqliteCore.text("tenant_id").notNull(),
     projectId: sqliteCore.text("project_id").notNull(),
-    id: sqliteCore.text("id").notNull(),
     graphId: sqliteCore.text("graph_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
     sourceAgentId: sqliteCore.text("source_agent_id").notNull(),
     // For internal relationships
     targetAgentId: sqliteCore.text("target_agent_id"),
@@ -286,11 +333,11 @@ var agentRelations = sqliteCore.sqliteTable(
     updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId],
-      foreignColumns: [projects.tenantId, projects.id],
-      name: "agent_relations_project_fk"
+      columns: [table.tenantId, table.projectId, table.graphId],
+      foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
+      name: "agent_relations_graph_fk"
     }).onDelete("cascade")
   ]
 );
@@ -299,6 +346,7 @@ var externalAgents = sqliteCore.sqliteTable(
   {
     tenantId: sqliteCore.text("tenant_id").notNull(),
     projectId: sqliteCore.text("project_id").notNull(),
+    graphId: sqliteCore.text("graph_id").notNull(),
     id: sqliteCore.text("id").notNull(),
     name: sqliteCore.text("name").notNull(),
     description: sqliteCore.text("description").notNull(),
@@ -310,11 +358,11 @@ var externalAgents = sqliteCore.sqliteTable(
     updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId],
-      foreignColumns: [projects.tenantId, projects.id],
-      name: "external_agents_project_fk"
+      columns: [table.tenantId, table.projectId, table.graphId],
+      foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
+      name: "external_agents_graph_fk"
     }).onDelete("cascade"),
     sqliteCore.foreignKey({
       columns: [table.tenantId, table.projectId, table.credentialReferenceId],
@@ -327,37 +375,6 @@ var externalAgents = sqliteCore.sqliteTable(
     }).onDelete("set null")
   ]
 );
-var agentGraph = sqliteCore.sqliteTable(
-  "agent_graph",
-  {
-    tenantId: sqliteCore.text("tenant_id").notNull(),
-    projectId: sqliteCore.text("project_id").notNull(),
-    id: sqliteCore.text("id").notNull(),
-    name: sqliteCore.text("name").notNull(),
-    description: sqliteCore.text("description"),
-    defaultAgentId: sqliteCore.text("default_agent_id").notNull(),
-    // Reference to shared context configuration for all agents in this graph
-    contextConfigId: sqliteCore.text("context_config_id"),
-    // Graph-level model settingsuration that can be inherited by agents
-    models: sqliteCore.text("models", { mode: "json" }).$type(),
-    // Status updates configuration for intelligent progress summaries
-    statusUpdates: sqliteCore.text("status_updates", { mode: "json" }).$type(),
-    // Graph-level prompt that can be used as additional context for agents
-    graphPrompt: sqliteCore.text("graph_prompt"),
-    // Graph-level stopWhen configuration that can be inherited by agents
-    stopWhen: sqliteCore.text("stop_when", { mode: "json" }).$type(),
-    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
-    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
-  },
-  (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId],
-      foreignColumns: [projects.tenantId, projects.id],
-      name: "agent_graph_project_fk"
-    }).onDelete("cascade")
-  ]
-);
 var tasks = sqliteCore.sqliteTable(
   "tasks",
   {
@@ -428,23 +445,18 @@ var agentDataComponents = sqliteCore.sqliteTable(
   {
     tenantId: sqliteCore.text("tenant_id").notNull(),
     projectId: sqliteCore.text("project_id").notNull(),
-    id: sqliteCore.text("id").notNull(),
+    graphId: sqliteCore.text("graph_id").notNull(),
     agentId: sqliteCore.text("agent_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
     dataComponentId: sqliteCore.text("data_component_id").notNull(),
     createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
   },
   (table) => [
     sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    // Foreign key constraint to projects table
-    sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId],
-      foreignColumns: [projects.tenantId, projects.id],
-      name: "agent_data_components_project_fk"
-    }).onDelete("cascade"),
-    // Foreign key constraint to agents table
+    // Foreign key constraint to agents table (ensures graph and project exist via cascade)
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.agentId],
-      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      columns: [table.tenantId, table.projectId, table.graphId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.graphId, agents.id],
       name: "agent_data_components_agent_fk"
     }).onDelete("cascade"),
     // Foreign key constraint to data_components table
@@ -482,23 +494,20 @@ var agentArtifactComponents = sqliteCore.sqliteTable(
   {
     tenantId: sqliteCore.text("tenant_id").notNull(),
     projectId: sqliteCore.text("project_id").notNull(),
-    id: sqliteCore.text("id").notNull(),
+    graphId: sqliteCore.text("graph_id").notNull(),
     agentId: sqliteCore.text("agent_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
     artifactComponentId: sqliteCore.text("artifact_component_id").notNull(),
     createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    // Foreign key constraint to projects table
-    sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId],
-      foreignColumns: [projects.tenantId, projects.id],
-      name: "agent_artifact_components_project_fk"
-    }).onDelete("cascade"),
-    // Foreign key constraint to agents table
+    sqliteCore.primaryKey({
+      columns: [table.tenantId, table.projectId, table.graphId, table.agentId, table.id]
+    }),
+    // Foreign key constraint to agents table (ensures graph and project exist via cascade)
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.agentId],
-      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      columns: [table.tenantId, table.projectId, table.graphId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.graphId, agents.id],
       name: "agent_artifact_components_agent_fk"
     }).onDelete("cascade"),
     // Foreign key constraint to artifact_components table
@@ -552,25 +561,20 @@ var agentToolRelations = sqliteCore.sqliteTable(
   {
     tenantId: sqliteCore.text("tenant_id").notNull(),
     projectId: sqliteCore.text("project_id").notNull(),
-    id: sqliteCore.text("id").notNull(),
+    graphId: sqliteCore.text("graph_id").notNull(),
     agentId: sqliteCore.text("agent_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
     toolId: sqliteCore.text("tool_id").notNull(),
     selectedTools: sqliteCore.blob("selected_tools", { mode: "json" }).$type(),
     createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
     updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    // Foreign key constraint to projects table
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
+    // Foreign key constraint to agents table (which includes project and graph scope)
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId],
-      foreignColumns: [projects.tenantId, projects.id],
-      name: "agent_tool_relations_project_fk"
-    }).onDelete("cascade"),
-    // Foreign key constraint to agents table
-    sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.agentId],
-      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      columns: [table.tenantId, table.projectId, table.graphId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.graphId, agents.id],
       name: "agent_tool_relations_agent_fk"
     }).onDelete("cascade"),
     // Foreign key constraint to tools table
@@ -777,7 +781,9 @@ var tasksRelations = drizzleOrm.relations(tasks, ({ one, many }) => ({
     references: [agents.id]
   }),
   // A task can have many messages associated with it
-  messages: many(messages)
+  messages: many(messages),
+  // A task can have many ledger artifacts
+  ledgerArtifacts: many(ledgerArtifacts)
 }));
 var projectsRelations = drizzleOrm.relations(projects, ({ many }) => ({
   // A project can have many agents
@@ -793,7 +799,15 @@ var projectsRelations = drizzleOrm.relations(projects, ({ many }) => ({
   // A project can have many conversations
   conversations: many(conversations),
   // A project can have many tasks
-  tasks: many(tasks)
+  tasks: many(tasks),
+  // A project can have many data components
+  dataComponents: many(dataComponents),
+  // A project can have many artifact components
+  artifactComponents: many(artifactComponents),
+  // A project can have many ledger artifacts
+  ledgerArtifacts: many(ledgerArtifacts),
+  // A project can have many credential references
+  credentialReferences: many(credentialReferences)
 }));
 var taskRelationsRelations = drizzleOrm.relations(taskRelations, ({ one }) => ({
   // Each relation has one parent task
@@ -855,7 +869,11 @@ var agentsRelations = drizzleOrm.relations(agents, ({ many, one }) => ({
   associatedMessages: many(messages, {
     relationName: "associatedAgent"
   }),
-  toolRelations: many(agentToolRelations)
+  toolRelations: many(agentToolRelations),
+  // Data component relations
+  dataComponentRelations: many(agentDataComponents),
+  // Artifact component relations
+  artifactComponentRelations: many(agentArtifactComponents)
 }));
 var agentGraphRelations = drizzleOrm.relations(agentGraph, ({ one }) => ({
   // An agent graph belongs to one project
@@ -863,7 +881,7 @@ var agentGraphRelations = drizzleOrm.relations(agentGraph, ({ one }) => ({
     fields: [agentGraph.tenantId, agentGraph.projectId],
     references: [projects.tenantId, projects.id]
   }),
-  // An agent graph belongs to one default agent
+  // An agent graph may have one default agent (optional)
   defaultAgent: one(agents, {
     fields: [agentGraph.defaultAgentId],
     references: [agents.id]
@@ -1011,6 +1029,39 @@ var agentArtifactComponentsRelations = drizzleOrm.relations(agentArtifactCompone
     references: [artifactComponents.id]
   })
 }));
+var dataComponentsRelations = drizzleOrm.relations(dataComponents, ({ many, one }) => ({
+  // A data component belongs to one project
+  project: one(projects, {
+    fields: [dataComponents.tenantId, dataComponents.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  // A data component can be associated with many agents
+  agentRelations: many(agentDataComponents)
+}));
+var agentDataComponentsRelations = drizzleOrm.relations(agentDataComponents, ({ one }) => ({
+  // An agent-data component relation belongs to one agent
+  agent: one(agents, {
+    fields: [agentDataComponents.agentId],
+    references: [agents.id]
+  }),
+  // An agent-data component relation belongs to one data component
+  dataComponent: one(dataComponents, {
+    fields: [agentDataComponents.dataComponentId],
+    references: [dataComponents.id]
+  })
+}));
+var ledgerArtifactsRelations = drizzleOrm.relations(ledgerArtifacts, ({ one }) => ({
+  // A ledger artifact belongs to one project
+  project: one(projects, {
+    fields: [ledgerArtifacts.tenantId, ledgerArtifacts.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  // A ledger artifact may be associated with one task
+  task: one(tasks, {
+    fields: [ledgerArtifacts.taskId],
+    references: [tasks.id]
+  })
+}));
 var agentRelationsRelations = drizzleOrm.relations(agentRelations, ({ one }) => ({
   // An agent relation belongs to one graph
   graph: one(agentGraph, {
@@ -1092,15 +1143,18 @@ var ProjectModelSchema = zodOpenapi.z.object({
 var createApiSchema = (schema) => schema.omit({ tenantId: true, projectId: true });
 var createApiInsertSchema = (schema) => schema.omit({ tenantId: true, projectId: true });
 var createApiUpdateSchema = (schema) => schema.omit({ tenantId: true, projectId: true }).partial();
+var createGraphScopedApiSchema = (schema) => schema.omit({ tenantId: true, projectId: true, graphId: true });
+var createGraphScopedApiInsertSchema = (schema) => schema.omit({ tenantId: true, projectId: true, graphId: true });
+var createGraphScopedApiUpdateSchema = (schema) => schema.omit({ tenantId: true, projectId: true, graphId: true }).partial();
 var AgentSelectSchema = drizzleZod.createSelectSchema(agents);
 var AgentInsertSchema = drizzleZod.createInsertSchema(agents).extend({
   id: resourceIdSchema,
   models: ModelSchema.optional()
 });
 var AgentUpdateSchema = AgentInsertSchema.partial();
-var AgentApiSelectSchema = createApiSchema(AgentSelectSchema);
-var AgentApiInsertSchema = createApiInsertSchema(AgentInsertSchema);
-var AgentApiUpdateSchema = createApiUpdateSchema(AgentUpdateSchema);
+var AgentApiSelectSchema = createGraphScopedApiSchema(AgentSelectSchema);
+var AgentApiInsertSchema = createGraphScopedApiInsertSchema(AgentInsertSchema);
+var AgentApiUpdateSchema = createGraphScopedApiUpdateSchema(AgentUpdateSchema);
 var AgentRelationSelectSchema = drizzleZod.createSelectSchema(agentRelations);
 var AgentRelationInsertSchema = drizzleZod.createInsertSchema(agentRelations).extend({
   id: resourceIdSchema,
@@ -1110,8 +1164,10 @@ var AgentRelationInsertSchema = drizzleZod.createInsertSchema(agentRelations).ex
   externalAgentId: resourceIdSchema.optional()
 });
 var AgentRelationUpdateSchema = AgentRelationInsertSchema.partial();
-var AgentRelationApiSelectSchema = createApiSchema(AgentRelationSelectSchema);
-var AgentRelationApiInsertSchema = createApiInsertSchema(AgentRelationInsertSchema).extend({
+var AgentRelationApiSelectSchema = createGraphScopedApiSchema(AgentRelationSelectSchema);
+var AgentRelationApiInsertSchema = createGraphScopedApiInsertSchema(
+  AgentRelationInsertSchema
+).extend({
   relationType: zodOpenapi.z.enum(VALID_RELATION_TYPES)
 }).refine(
   (data) => {
@@ -1124,7 +1180,9 @@ var AgentRelationApiInsertSchema = createApiInsertSchema(AgentRelationInsertSche
     path: ["targetAgentId", "externalAgentId"]
   }
 );
-var AgentRelationApiUpdateSchema = createApiUpdateSchema(AgentRelationUpdateSchema).extend({
+var AgentRelationApiUpdateSchema = createGraphScopedApiUpdateSchema(
+  AgentRelationUpdateSchema
+).extend({
   relationType: zodOpenapi.z.enum(VALID_RELATION_TYPES).optional()
 }).refine(
   (data) => {
@@ -1161,7 +1219,7 @@ var AgentGraphInsertSchema = drizzleZod.createInsertSchema(agentGraph).extend({
 var AgentGraphUpdateSchema = AgentGraphInsertSchema.partial();
 var AgentGraphApiSelectSchema = createApiSchema(AgentGraphSelectSchema);
 var AgentGraphApiInsertSchema = createApiInsertSchema(AgentGraphInsertSchema).extend({
-  id: resourceIdSchema.optional()
+  id: resourceIdSchema
 });
 var AgentGraphApiUpdateSchema = createApiUpdateSchema(AgentGraphUpdateSchema);
 var TaskSelectSchema = drizzleZod.createSelectSchema(tasks);
@@ -1260,11 +1318,16 @@ var DataComponentApiUpdateSchema = createApiUpdateSchema(DataComponentUpdateSche
 var AgentDataComponentSelectSchema = drizzleZod.createSelectSchema(agentDataComponents);
 var AgentDataComponentInsertSchema = drizzleZod.createInsertSchema(agentDataComponents);
 var AgentDataComponentUpdateSchema = AgentDataComponentInsertSchema.partial();
-var AgentDataComponentApiSelectSchema = createApiSchema(AgentDataComponentSelectSchema);
-var AgentDataComponentApiInsertSchema = createApiInsertSchema(
-  AgentDataComponentInsertSchema
+var AgentDataComponentApiSelectSchema = createGraphScopedApiSchema(
+  AgentDataComponentSelectSchema
 );
-var AgentDataComponentApiUpdateSchema = createApiUpdateSchema(
+var AgentDataComponentApiInsertSchema = AgentDataComponentInsertSchema.omit({
+  tenantId: true,
+  projectId: true,
+  id: true,
+  createdAt: true
+});
+var AgentDataComponentApiUpdateSchema = createGraphScopedApiUpdateSchema(
   AgentDataComponentUpdateSchema
 );
 var ArtifactComponentSelectSchema = drizzleZod.createSelectSchema(artifactComponents);
@@ -1293,7 +1356,7 @@ var AgentArtifactComponentInsertSchema = drizzleZod.createInsertSchema(
   artifactComponentId: resourceIdSchema
 });
 var AgentArtifactComponentUpdateSchema = AgentArtifactComponentInsertSchema.partial();
-var AgentArtifactComponentApiSelectSchema = createApiSchema(
+var AgentArtifactComponentApiSelectSchema = createGraphScopedApiSchema(
   AgentArtifactComponentSelectSchema
 );
 var AgentArtifactComponentApiInsertSchema = AgentArtifactComponentInsertSchema.omit({
@@ -1302,7 +1365,7 @@ var AgentArtifactComponentApiInsertSchema = AgentArtifactComponentInsertSchema.o
   id: true,
   createdAt: true
 });
-var AgentArtifactComponentApiUpdateSchema = createApiUpdateSchema(
+var AgentArtifactComponentApiUpdateSchema = createGraphScopedApiUpdateSchema(
   AgentArtifactComponentUpdateSchema
 );
 var ExternalAgentSelectSchema = drizzleZod.createSelectSchema(externalAgents).extend({
@@ -1313,9 +1376,9 @@ var ExternalAgentInsertSchema = drizzleZod.createInsertSchema(externalAgents).ex
   id: resourceIdSchema
 });
 var ExternalAgentUpdateSchema = ExternalAgentInsertSchema.partial();
-var ExternalAgentApiSelectSchema = createApiSchema(ExternalAgentSelectSchema);
-var ExternalAgentApiInsertSchema = createApiInsertSchema(ExternalAgentInsertSchema);
-var ExternalAgentApiUpdateSchema = createApiUpdateSchema(ExternalAgentUpdateSchema);
+var ExternalAgentApiSelectSchema = createGraphScopedApiSchema(ExternalAgentSelectSchema);
+var ExternalAgentApiInsertSchema = createGraphScopedApiInsertSchema(ExternalAgentInsertSchema);
+var ExternalAgentApiUpdateSchema = createGraphScopedApiUpdateSchema(ExternalAgentUpdateSchema);
 var AllAgentSchema = zodOpenapi.z.discriminatedUnion("type", [
   AgentApiSelectSchema.extend({ type: zodOpenapi.z.literal("internal") }),
   ExternalAgentApiSelectSchema.extend({ type: zodOpenapi.z.literal("external") })
@@ -1371,10 +1434,8 @@ var CredentialReferenceSelectSchema = zodOpenapi.z.object({
   createdAt: zodOpenapi.z.string(),
   updatedAt: zodOpenapi.z.string()
 });
-var CredentialReferenceInsertSchema = zodOpenapi.z.object({
+var CredentialReferenceInsertSchema = drizzleZod.createInsertSchema(credentialReferences).extend({
   id: resourceIdSchema,
-  tenantId: zodOpenapi.z.string(),
-  projectId: zodOpenapi.z.string(),
   type: zodOpenapi.z.string(),
   credentialStoreId: resourceIdSchema,
   retrievalParams: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).nullish()
@@ -1470,11 +1531,13 @@ var AgentToolRelationInsertSchema = drizzleZod.createInsertSchema(agentToolRelat
   selectedTools: zodOpenapi.z.array(zodOpenapi.z.string()).nullish()
 });
 var AgentToolRelationUpdateSchema = AgentToolRelationInsertSchema.partial();
-var AgentToolRelationApiSelectSchema = createApiSchema(AgentToolRelationSelectSchema);
-var AgentToolRelationApiInsertSchema = createApiInsertSchema(
+var AgentToolRelationApiSelectSchema = createGraphScopedApiSchema(
+  AgentToolRelationSelectSchema
+);
+var AgentToolRelationApiInsertSchema = createGraphScopedApiInsertSchema(
   AgentToolRelationInsertSchema
 );
-var AgentToolRelationApiUpdateSchema = createApiUpdateSchema(
+var AgentToolRelationApiUpdateSchema = createGraphScopedApiUpdateSchema(
   AgentToolRelationUpdateSchema
 );
 var LedgerArtifactSelectSchema = drizzleZod.createSelectSchema(ledgerArtifacts);
@@ -1500,6 +1563,7 @@ var StatusUpdateSchema = zodOpenapi.z.object({
   statusComponents: zodOpenapi.z.array(StatusComponentSchema).optional()
 });
 var FullGraphAgentInsertSchema = AgentApiInsertSchema.extend({
+  type: zodOpenapi.z.literal("internal"),
   tools: zodOpenapi.z.array(zodOpenapi.z.string()),
   selectedTools: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.array(zodOpenapi.z.string())).optional(),
   dataComponents: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
@@ -1509,10 +1573,9 @@ var FullGraphAgentInsertSchema = AgentApiInsertSchema.extend({
 });
 var FullGraphDefinitionSchema = AgentGraphApiInsertSchema.extend({
   agents: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.union([FullGraphAgentInsertSchema, ExternalAgentApiInsertSchema])),
-  tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema).optional(),
-  credentialReferences: zodOpenapi.z.record(zodOpenapi.z.string(), CredentialReferenceApiInsertSchema).optional(),
-  dataComponents: zodOpenapi.z.record(zodOpenapi.z.string(), DataComponentApiInsertSchema).optional(),
-  artifactComponents: zodOpenapi.z.record(zodOpenapi.z.string(), ArtifactComponentApiInsertSchema).optional(),
+  // Removed project-scoped resources - these are now managed at project level:
+  // tools, credentialReferences, dataComponents, artifactComponents
+  // Agent relationships to these resources are maintained via agent.tools, agent.dataComponents, etc.
   contextConfig: zodOpenapi.z.optional(ContextConfigApiInsertSchema),
   statusUpdates: zodOpenapi.z.optional(StatusUpdateSchema),
   models: ModelSchema.optional(),
@@ -1520,7 +1583,13 @@ var FullGraphDefinitionSchema = AgentGraphApiInsertSchema.extend({
   graphPrompt: zodOpenapi.z.string().max(5e3, "Graph prompt cannot exceed 5000 characters").optional()
 });
 var GraphWithinContextOfProjectSchema = AgentGraphApiInsertSchema.extend({
-  agents: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.union([FullGraphAgentInsertSchema, ExternalAgentApiInsertSchema])),
+  agents: zodOpenapi.z.record(
+    zodOpenapi.z.string(),
+    zodOpenapi.z.discriminatedUnion("type", [
+      FullGraphAgentInsertSchema,
+      ExternalAgentApiInsertSchema.extend({ type: zodOpenapi.z.literal("external") })
+    ])
+  ),
   models: ModelSchema.optional(),
   stopWhen: GraphStopWhenSchema.optional(),
   graphPrompt: zodOpenapi.z.string().max(5e3, "Graph prompt cannot exceed 5000 characters").optional()
@@ -1603,6 +1672,35 @@ var TenantProjectParamsSchema = zodOpenapi.z.object({
     example: "project_456"
   })
 }).openapi("TenantProjectParams");
+var TenantProjectGraphParamsSchema = zodOpenapi.z.object({
+  tenantId: zodOpenapi.z.string().openapi({
+    description: "Tenant identifier",
+    example: "tenant_123"
+  }),
+  projectId: zodOpenapi.z.string().openapi({
+    description: "Project identifier",
+    example: "project_456"
+  }),
+  graphId: zodOpenapi.z.string().openapi({
+    description: "Graph identifier",
+    example: "graph_789"
+  })
+}).openapi("TenantProjectGraphParams");
+var TenantProjectGraphIdParamsSchema = zodOpenapi.z.object({
+  tenantId: zodOpenapi.z.string().openapi({
+    description: "Tenant identifier",
+    example: "tenant_123"
+  }),
+  projectId: zodOpenapi.z.string().openapi({
+    description: "Project identifier",
+    example: "project_456"
+  }),
+  graphId: zodOpenapi.z.string().openapi({
+    description: "Graph identifier",
+    example: "graph_789"
+  }),
+  id: resourceIdSchema
+}).openapi("TenantProjectGraphIdParams");
 var TenantProjectIdParamsSchema = zodOpenapi.z.object({
   tenantId: zodOpenapi.z.string().openapi({
     description: "Tenant identifier",
@@ -1939,8 +2037,8 @@ var _TemplateEngine = class _TemplateEngine {
    * Process variable substitutions {{variable.path}} using JMESPath
    */
   static processVariables(template, context, options) {
-    return template.replace(/\{\{([^}]+)\}\}/g, (match2, path) => {
-      const trimmedPath = path.trim();
+    return template.replace(/\{\{([^}]+)\}\}/g, (match2, path2) => {
+      const trimmedPath = path2.trim();
       try {
         if (trimmedPath.startsWith("$")) {
           return _TemplateEngine.processBuiltinVariable(trimmedPath);
@@ -2319,6 +2417,7 @@ var getAgentRelationById = (db) => async (params) => {
     where: drizzleOrm.and(
       drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId),
       drizzleOrm.eq(agentRelations.id, params.relationId)
     )
   });
@@ -2329,7 +2428,8 @@ var listAgentRelations = (db) => async (params) => {
   const offset = (page - 1) * limit;
   const whereClause = drizzleOrm.and(
     drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
-    drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId)
+    drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
+    drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId)
   );
   const [data, totalResult] = await Promise.all([
     db.select().from(agentRelations).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(agentRelations.createdAt)),
@@ -2344,8 +2444,8 @@ var getAgentRelations = (db) => async (params) => {
     where: drizzleOrm.and(
       drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentRelations.graphId, params.graphId),
-      drizzleOrm.eq(agentRelations.sourceAgentId, params.agentId)
+      drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(agentRelations.sourceAgentId, params.scopes.agentId)
     )
   });
 };
@@ -2354,7 +2454,7 @@ var getAgentRelationsByGraph = (db) => async (params) => {
     where: drizzleOrm.and(
       drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentRelations.graphId, params.graphId)
+      drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId)
     )
   });
 };
@@ -2365,6 +2465,7 @@ var getAgentRelationsBySource = (db) => async (params) => {
   const whereClause = drizzleOrm.and(
     drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
     drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
+    drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId),
     drizzleOrm.eq(agentRelations.sourceAgentId, params.sourceAgentId)
   );
   const [data, totalResult] = await Promise.all([
@@ -2385,6 +2486,7 @@ var getAgentRelationsByTarget = (db) => async (params) => {
   const whereClause = drizzleOrm.and(
     drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
     drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
+    drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId),
     drizzleOrm.eq(agentRelations.targetAgentId, params.targetAgentId)
   );
   const [data, totalResult] = await Promise.all([
@@ -2405,6 +2507,7 @@ var getExternalAgentRelations = (db) => async (params) => {
   const whereClause = drizzleOrm.and(
     drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
     drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
+    drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId),
     drizzleOrm.eq(agentRelations.externalAgentId, params.externalAgentId)
   );
   const [data, totalResult] = await Promise.all([
@@ -2428,11 +2531,12 @@ var getRelatedAgentsForGraph = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentRelations.graphId, params.graphId),
+      drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId),
       drizzleOrm.eq(agentRelations.sourceAgentId, params.agentId),
       drizzleOrm.isNotNull(agentRelations.targetAgentId),
       drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agents.projectId, params.scopes.projectId)
+      drizzleOrm.eq(agents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(agents.graphId, params.scopes.graphId)
     )
   );
   const externalRelations = await db.select({
@@ -2448,11 +2552,12 @@ var getRelatedAgentsForGraph = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentRelations.graphId, params.graphId),
+      drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId),
       drizzleOrm.eq(agentRelations.sourceAgentId, params.agentId),
       drizzleOrm.isNotNull(agentRelations.externalAgentId),
       drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId)
+      drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId)
     )
   );
   return {
@@ -2478,7 +2583,7 @@ var getAgentRelationByParams = (db) => async (params) => {
   const whereConditions = [
     drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
     drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
-    drizzleOrm.eq(agentRelations.graphId, params.graphId),
+    drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId),
     drizzleOrm.eq(agentRelations.sourceAgentId, params.sourceAgentId),
     drizzleOrm.eq(agentRelations.relationType, params.relationType)
   ];
@@ -2494,8 +2599,7 @@ var getAgentRelationByParams = (db) => async (params) => {
 };
 var upsertAgentRelation = (db) => async (params) => {
   const existing = await getAgentRelationByParams(db)({
-    scopes: { tenantId: params.tenantId, projectId: params.projectId },
-    graphId: params.graphId,
+    scopes: { tenantId: params.tenantId, projectId: params.projectId, graphId: params.graphId },
     sourceAgentId: params.sourceAgentId,
     targetAgentId: params.targetAgentId,
     externalAgentId: params.externalAgentId,
@@ -2521,6 +2625,7 @@ var updateAgentRelation = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId),
       drizzleOrm.eq(agentRelations.id, params.relationId)
     )
   ).returning();
@@ -2531,6 +2636,7 @@ var deleteAgentRelation = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId),
       drizzleOrm.eq(agentRelations.id, params.relationId)
     )
   );
@@ -2540,7 +2646,7 @@ var deleteAgentRelationsByGraph = (db) => async (params) => {
   const result = await db.delete(agentRelations).where(
     drizzleOrm.and(
       drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentRelations.graphId, params.graphId)
+      drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId)
     )
   );
   return (result.rowsAffected || 0) > 0;
@@ -2551,6 +2657,7 @@ var createAgentToolRelation = (db) => async (params) => {
     id: finalRelationId,
     tenantId: params.scopes.tenantId,
     projectId: params.scopes.projectId,
+    graphId: params.scopes.graphId,
     agentId: params.data.agentId,
     toolId: params.data.toolId,
     selectedTools: params.data.selectedTools
@@ -2566,6 +2673,7 @@ var updateAgentToolRelation = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
       drizzleOrm.eq(agentToolRelations.id, params.relationId)
     )
   ).returning();
@@ -2576,6 +2684,7 @@ var deleteAgentToolRelation = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
       drizzleOrm.eq(agentToolRelations.id, params.relationId)
     )
   );
@@ -2585,7 +2694,9 @@ var deleteAgentToolRelationByAgent = (db) => async (params) => {
   const result = await db.delete(agentToolRelations).where(
     drizzleOrm.and(
       drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentToolRelations.agentId, params.agentId)
+      drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(agentToolRelations.agentId, params.scopes.agentId)
     )
   );
   return (result.rowsAffected || 0) > 0;
@@ -2595,6 +2706,7 @@ var getAgentToolRelationById = (db) => async (params) => {
     where: drizzleOrm.and(
       drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
       drizzleOrm.eq(agentToolRelations.id, params.relationId)
     )
   });
@@ -2608,14 +2720,14 @@ var getAgentToolRelationByAgent = (db) => async (params) => {
       drizzleOrm.and(
         drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(agentToolRelations.agentId, params.agentId)
+        drizzleOrm.eq(agentToolRelations.agentId, params.scopes.agentId)
       )
     ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(agentToolRelations.createdAt)),
     db.select({ count: drizzleOrm.count() }).from(agentToolRelations).where(
       drizzleOrm.and(
         drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(agentToolRelations.agentId, params.agentId)
+        drizzleOrm.eq(agentToolRelations.agentId, params.scopes.agentId)
       )
     )
   ]);
@@ -2635,6 +2747,7 @@ var getAgentToolRelationByTool = (db) => async (params) => {
       drizzleOrm.and(
         drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
+        drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
         drizzleOrm.eq(agentToolRelations.toolId, params.toolId)
       )
     ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(agentToolRelations.createdAt)),
@@ -2642,6 +2755,7 @@ var getAgentToolRelationByTool = (db) => async (params) => {
       drizzleOrm.and(
         drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
+        drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
         drizzleOrm.eq(agentToolRelations.toolId, params.toolId)
       )
     )
@@ -2661,13 +2775,15 @@ var listAgentToolRelations = (db) => async (params) => {
     db.select().from(agentToolRelations).where(
       drizzleOrm.and(
         drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId)
+        drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
+        drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId)
       )
     ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(agentToolRelations.createdAt)),
     db.select({ count: drizzleOrm.count() }).from(agentToolRelations).where(
       drizzleOrm.and(
         drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId)
+        drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
+        drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId)
       )
     )
   ]);
@@ -2678,26 +2794,6 @@ var listAgentToolRelations = (db) => async (params) => {
     pagination: { page, limit, total, pages }
   };
 };
-var listAgentToolRelationsByAgent = (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(agentToolRelations.tenantId, params.scopes.tenantId),
-    drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-    drizzleOrm.eq(agentToolRelations.agentId, params.agentId)
-  );
-  const [data, totalResult] = await Promise.all([
-    db.select().from(agentToolRelations).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(agentToolRelations.createdAt)),
-    db.select({ count: drizzleOrm.count() }).from(agentToolRelations).where(whereClause)
-  ]);
-  const total = totalResult[0]?.count || 0;
-  const pages = Math.ceil(total / limit);
-  return {
-    data,
-    pagination: { page, limit, total, pages }
-  };
-};
 var getToolsForAgent = (db) => async (params) => {
   const page = params.pagination?.page || 1;
   const limit = Math.min(params.pagination?.limit || 10, 100);
@@ -2728,14 +2824,16 @@ var getToolsForAgent = (db) => async (params) => {
       drizzleOrm.and(
         drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(agentToolRelations.agentId, params.agentId)
+        drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
+        drizzleOrm.eq(agentToolRelations.agentId, params.scopes.agentId)
       )
     ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(agentToolRelations.createdAt)),
     db.select({ count: drizzleOrm.count() }).from(agentToolRelations).where(
       drizzleOrm.and(
         drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(agentToolRelations.agentId, params.agentId)
+        drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
+        drizzleOrm.eq(agentToolRelations.agentId, params.scopes.agentId)
       )
     )
   ]);
@@ -2764,6 +2862,9 @@ var getAgentsForTool = (db) => async (params) => {
         name: agents.name,
         description: agents.description,
         prompt: agents.prompt,
+        conversationHistoryConfig: agents.conversationHistoryConfig,
+        models: agents.models,
+        stopWhen: agents.stopWhen,
         createdAt: agents.createdAt,
         updatedAt: agents.updatedAt
       }
@@ -2771,6 +2872,7 @@ var getAgentsForTool = (db) => async (params) => {
       drizzleOrm.and(
         drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
+        drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
         drizzleOrm.eq(agentToolRelations.toolId, params.toolId)
       )
     ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(agentToolRelations.createdAt)),
@@ -2778,6 +2880,7 @@ var getAgentsForTool = (db) => async (params) => {
       drizzleOrm.and(
         drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
+        drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
         drizzleOrm.eq(agentToolRelations.toolId, params.toolId)
       )
     )
@@ -2794,7 +2897,8 @@ var validateInternalAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agents.id, params.agentId)
+      drizzleOrm.eq(agents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(agents.id, params.scopes.agentId)
     )
   ).limit(1);
   return result.length > 0;
@@ -2804,7 +2908,8 @@ var validateExternalAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(externalAgents.id, params.agentId)
+      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(externalAgents.id, params.scopes.agentId)
     )
   ).limit(1);
   return result.length > 0;
@@ -2814,6 +2919,7 @@ var getAgentById = (db) => async (params) => {
     where: drizzleOrm.and(
       drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(agents.graphId, params.scopes.graphId),
       drizzleOrm.eq(agents.id, params.agentId)
     )
   });
@@ -2823,7 +2929,8 @@ var listAgents = (db) => async (params) => {
   return await db.query.agents.findMany({
     where: drizzleOrm.and(
       drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agents.projectId, params.scopes.projectId)
+      drizzleOrm.eq(agents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(agents.graphId, params.scopes.graphId)
     )
   });
 };
@@ -2833,7 +2940,8 @@ var listAgentsPaginated = (db) => async (params) => {
   const offset = (page - 1) * limit;
   const whereClause = drizzleOrm.and(
     drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
-    drizzleOrm.eq(agents.projectId, params.scopes.projectId)
+    drizzleOrm.eq(agents.projectId, params.scopes.projectId),
+    drizzleOrm.eq(agents.graphId, params.scopes.graphId)
   );
   const [data, totalResult] = await Promise.all([
     db.select().from(agents).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(agents.createdAt)),
@@ -2865,13 +2973,18 @@ var updateAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(agents.graphId, params.scopes.graphId),
       drizzleOrm.eq(agents.id, params.agentId)
     )
   ).returning();
   return agent[0] ?? null;
 };
 var upsertAgent = (db) => async (params) => {
-  const scopes = { tenantId: params.data.tenantId, projectId: params.data.projectId };
+  const scopes = {
+    tenantId: params.data.tenantId,
+    projectId: params.data.projectId,
+    graphId: params.data.graphId
+  };
   const existing = await getAgentById(db)({
     scopes,
     agentId: params.data.id
@@ -2902,6 +3015,7 @@ var deleteAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(agents.graphId, params.scopes.graphId),
       drizzleOrm.eq(agents.id, params.agentId)
     )
   );
@@ -2919,36 +3033,11 @@ var getAgentsByIds = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(agents.graphId, params.scopes.graphId),
       drizzleOrm.inArray(agents.id, params.agentIds)
     )
   );
 };
-var getAgentInGraphContext = (db) => async (params) => {
-  return await db.select({
-    id: agents.id,
-    name: agents.name,
-    description: agents.description,
-    prompt: agents.prompt,
-    tenantId: agents.tenantId,
-    graphId: agentRelations.graphId,
-    sourceAgentId: agentRelations.sourceAgentId
-  }).from(agents).innerJoin(
-    agentRelations,
-    drizzleOrm.and(
-      drizzleOrm.eq(agents.tenantId, agentRelations.tenantId),
-      drizzleOrm.eq(agents.projectId, agentRelations.projectId),
-      drizzleOrm.eq(agents.id, agentRelations.sourceAgentId),
-      drizzleOrm.eq(agentRelations.graphId, params.graphId)
-    )
-  ).where(
-    drizzleOrm.and(
-      drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agents.id, params.agentId),
-      drizzleOrm.eq(agentRelations.graphId, params.graphId)
-    )
-  );
-};
 var getContextConfigById = (db) => async (params) => {
   return await db.query.contextConfigs.findFirst({
     where: drizzleOrm.and(
@@ -3103,6 +3192,8 @@ var getExternalAgent = (db) => async (params) => {
   const result = await db.query.externalAgents.findFirst({
     where: drizzleOrm.and(
       drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId),
       drizzleOrm.eq(externalAgents.id, params.agentId)
     )
   });
@@ -3112,6 +3203,8 @@ var getExternalAgentByUrl = (db) => async (params) => {
   const result = await db.query.externalAgents.findFirst({
     where: drizzleOrm.and(
       drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId),
       drizzleOrm.eq(externalAgents.baseUrl, params.baseUrl)
     )
   });
@@ -3119,7 +3212,11 @@ var getExternalAgentByUrl = (db) => async (params) => {
 };
 var listExternalAgents = (db) => async (params) => {
   return await db.query.externalAgents.findMany({
-    where: drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
+    where: drizzleOrm.and(
+      drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId)
+    ),
     orderBy: [drizzleOrm.asc(externalAgents.name)]
   });
 };
@@ -3128,8 +3225,20 @@ var listExternalAgentsPaginated = (db) => async (params) => {
   const limit = Math.min(params.pagination?.limit || 10, 100);
   const offset = (page - 1) * limit;
   const [data, totalResult] = await Promise.all([
-    db.select().from(externalAgents).where(drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId)).limit(limit).offset(offset).orderBy(drizzleOrm.desc(externalAgents.createdAt)),
-    db.select({ count: drizzleOrm.count() }).from(externalAgents).where(drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId))
+    db.select().from(externalAgents).where(
+      drizzleOrm.and(
+        drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
+        drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
+        drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId)
+      )
+    ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(externalAgents.createdAt)),
+    db.select({ count: drizzleOrm.count() }).from(externalAgents).where(
+      drizzleOrm.and(
+        drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
+        drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
+        drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId)
+      )
+    )
   ]);
   const total = typeof totalResult[0]?.count === "string" ? parseInt(totalResult[0].count, 10) : totalResult[0]?.count || 0;
   const pages = Math.ceil(total / limit);
@@ -3155,13 +3264,19 @@ var updateExternalAgent = (db) => async (params) => {
   const result = await db.update(externalAgents).set(updateData).where(
     drizzleOrm.and(
       drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId),
       drizzleOrm.eq(externalAgents.id, params.agentId)
     )
   ).returning();
   return result[0] || null;
 };
 var upsertExternalAgent = (db) => async (params) => {
-  const scopes = { tenantId: params.data.tenantId, projectId: params.data.projectId };
+  const scopes = {
+    tenantId: params.data.tenantId,
+    projectId: params.data.projectId,
+    graphId: params.data.graphId
+  };
   const existing = await getExternalAgent(db)({
     scopes,
     agentId: params.data.id
@@ -3191,6 +3306,8 @@ var deleteExternalAgent = (db) => async (params) => {
     const result = await db.delete(externalAgents).where(
       drizzleOrm.and(
         drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
+        drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
+        drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId),
         drizzleOrm.eq(externalAgents.id, params.agentId)
       )
     ).returning();
@@ -3209,27 +3326,24 @@ var externalAgentUrlExists = (db) => async (params) => {
   return agent !== null;
 };
 var countExternalAgents = (db) => async (params) => {
-  const result = await db.select({ count: drizzleOrm.count() }).from(externalAgents).where(drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId));
+  const result = await db.select({ count: drizzleOrm.count() }).from(externalAgents).where(
+    drizzleOrm.and(
+      drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId)
+    )
+  );
   const countValue = result[0]?.count;
   return typeof countValue === "string" ? parseInt(countValue, 10) : countValue || 0;
 };
 
 // src/data-access/agentGraphs.ts
-var getAgentGraph = (db) => async (params) => {
-  return await db.query.agentGraph.findFirst({
-    where: drizzleOrm.and(
-      drizzleOrm.eq(agentGraph.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentGraph.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentGraph.id, params.graphId)
-    )
-  });
-};
 var getAgentGraphById = (db) => async (params) => {
   const result = await db.query.agentGraph.findFirst({
     where: drizzleOrm.and(
       drizzleOrm.eq(agentGraph.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentGraph.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentGraph.id, params.graphId)
+      drizzleOrm.eq(agentGraph.id, params.scopes.graphId)
     )
   });
   return result ?? null;
@@ -3239,7 +3353,7 @@ var getAgentGraphWithDefaultAgent = (db) => async (params) => {
     where: drizzleOrm.and(
       drizzleOrm.eq(agentGraph.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentGraph.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentGraph.id, params.graphId)
+      drizzleOrm.eq(agentGraph.id, params.scopes.graphId)
     ),
     with: {
       defaultAgent: true
@@ -3332,7 +3446,7 @@ var updateAgentGraph = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(agentGraph.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentGraph.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentGraph.id, params.graphId)
+      drizzleOrm.eq(agentGraph.id, params.scopes.graphId)
     )
   ).returning();
   return graph[0] ?? null;
@@ -3342,7 +3456,7 @@ var deleteAgentGraph = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(agentGraph.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentGraph.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentGraph.id, params.graphId)
+      drizzleOrm.eq(agentGraph.id, params.scopes.graphId)
     )
   ).returning();
   return result.length > 0;
@@ -3369,17 +3483,14 @@ var getGraphAgentInfos = (db) => async ({
   agentId
 }) => {
   const { tenantId, projectId } = scopes;
-  const graph = await getAgentGraph(db)({
-    scopes: { tenantId, projectId },
-    graphId
+  const graph = await getAgentGraphById(db)({
+    scopes: { tenantId, projectId, graphId }
   });
   if (!graph) {
     throw new Error(`Agent graph with ID ${graphId} not found for tenant ${tenantId}`);
   }
   const relations2 = await getAgentRelations(db)({
-    scopes: { tenantId, projectId },
-    graphId,
-    agentId
+    scopes: { tenantId, projectId, graphId, agentId }
   });
   const targetAgentIds = relations2.map((relation) => relation.targetAgentId).filter((id) => id !== null);
   if (targetAgentIds.length === 0) {
@@ -3388,7 +3499,7 @@ var getGraphAgentInfos = (db) => async ({
   const agentInfos = await Promise.all(
     targetAgentIds.map(async (targetAgentId) => {
       const agent = await getAgentById(db)({
-        scopes: { tenantId, projectId },
+        scopes: { tenantId, projectId, graphId },
         agentId: targetAgentId
       });
       if (agent !== void 0) {
@@ -3400,55 +3511,35 @@ var getGraphAgentInfos = (db) => async ({
   return agentInfos.filter((agent) => agent !== null);
 };
 var getFullGraphDefinition = (db) => async ({
-  scopes: { tenantId, projectId },
-  graphId
+  scopes: { tenantId, projectId, graphId }
 }) => {
   const graph = await getAgentGraphById(db)({
-    scopes: { tenantId, projectId },
-    graphId
+    scopes: { tenantId, projectId, graphId }
   });
   if (!graph) {
     return null;
   }
   const graphRelations = await getAgentRelationsByGraph(db)({
-    scopes: { tenantId, projectId },
-    graphId
+    scopes: { tenantId, projectId, graphId }
+  });
+  const graphAgents = await db.query.agents.findMany({
+    where: drizzleOrm.and(
+      drizzleOrm.eq(agents.tenantId, tenantId),
+      drizzleOrm.eq(agents.projectId, projectId),
+      drizzleOrm.eq(agents.graphId, graphId)
+    )
   });
-  const internalAgentIds = /* @__PURE__ */ new Set();
   const externalAgentIds = /* @__PURE__ */ new Set();
-  internalAgentIds.add(graph.defaultAgentId);
   for (const relation of graphRelations) {
-    if (relation.sourceAgentId) {
-      internalAgentIds.add(relation.sourceAgentId);
-    }
-    if (relation.targetAgentId) {
-      internalAgentIds.add(relation.targetAgentId);
-    }
     if (relation.externalAgentId) {
       externalAgentIds.add(relation.externalAgentId);
     }
   }
-  const agentsWithTools = await db.selectDistinct({ agentId: agentToolRelations.agentId }).from(agentToolRelations).innerJoin(tools, drizzleOrm.eq(agentToolRelations.toolId, tools.id)).where(
-    drizzleOrm.and(
-      drizzleOrm.eq(agentToolRelations.tenantId, tenantId),
-      drizzleOrm.eq(agentToolRelations.projectId, projectId),
-      // We need to find tools that belong to this graph
-      // Tools created as part of a graph have IDs that include the graph ID
-      drizzleOrm.like(tools.id, `%${graphId}%`)
-    )
-  );
-  for (const agentTool of agentsWithTools) {
-    internalAgentIds.add(agentTool.agentId);
-  }
-  const graphAgents = await Promise.all(
-    Array.from(internalAgentIds).map(async (agentId) => {
-      const agent = await getAgentById(db)({
-        scopes: { tenantId, projectId },
-        agentId
-      });
+  const processedAgents = await Promise.all(
+    graphAgents.map(async (agent) => {
       if (!agent) return null;
       const agentRelationsList = graphRelations.filter(
-        (relation) => relation.sourceAgentId === agentId
+        (relation) => relation.sourceAgentId === agent.id
       );
       const canTransferTo = agentRelationsList.filter((rel) => rel.relationType === "transfer" || rel.relationType === "transfer_to").map((rel) => rel.targetAgentId).filter((id) => id !== null);
       const canDelegateTo = agentRelationsList.filter((rel) => rel.relationType === "delegate" || rel.relationType === "delegate_to").map((rel) => rel.targetAgentId || rel.externalAgentId).filter((id) => id !== null);
@@ -3465,19 +3556,19 @@ var getFullGraphDefinition = (db) => async ({
         lastToolsSync: tools.lastToolsSync,
         selectedTools: agentToolRelations.selectedTools
       }).from(agentToolRelations).innerJoin(tools, drizzleOrm.eq(agentToolRelations.toolId, tools.id)).where(
-        drizzleOrm.and(drizzleOrm.eq(agentToolRelations.tenantId, tenantId), drizzleOrm.eq(agentToolRelations.agentId, agentId))
+        drizzleOrm.and(drizzleOrm.eq(agentToolRelations.tenantId, tenantId), drizzleOrm.eq(agentToolRelations.agentId, agent.id))
       );
       const agentDataComponentRelations = await db.query.agentDataComponents.findMany({
         where: drizzleOrm.and(
           drizzleOrm.eq(agentDataComponents.tenantId, tenantId),
-          drizzleOrm.eq(agentDataComponents.agentId, agentId)
+          drizzleOrm.eq(agentDataComponents.agentId, agent.id)
         )
       });
       const agentDataComponentIds = agentDataComponentRelations.map((rel) => rel.dataComponentId);
       const agentArtifactComponentRelations = await db.query.agentArtifactComponents.findMany({
         where: drizzleOrm.and(
           drizzleOrm.eq(agentArtifactComponents.tenantId, tenantId),
-          drizzleOrm.eq(agentArtifactComponents.agentId, agentId)
+          drizzleOrm.eq(agentArtifactComponents.agentId, agent.id)
         )
       });
       const agentArtifactComponentIds = agentArtifactComponentRelations.map(
@@ -3520,7 +3611,7 @@ var getFullGraphDefinition = (db) => async ({
   const externalAgents2 = await Promise.all(
     Array.from(externalAgentIds).map(async (agentId) => {
       const agent = await getExternalAgent(db)({
-        scopes: { tenantId, projectId },
+        scopes: { tenantId, projectId, graphId },
         agentId
       });
       if (!agent) return null;
@@ -3532,7 +3623,7 @@ var getFullGraphDefinition = (db) => async ({
       };
     })
   );
-  const validAgents = [...graphAgents, ...externalAgents2].filter(
+  const validAgents = [...processedAgents, ...externalAgents2].filter(
     (agent) => agent !== null
   );
   const agentsObject = {};
@@ -3578,6 +3669,7 @@ var getFullGraphDefinition = (db) => async ({
   }
   let dataComponentsObject = {};
   try {
+    const internalAgentIds = graphAgents.map((agent) => agent.id);
     const agentIds = Array.from(internalAgentIds);
     dataComponentsObject = await fetchComponentRelationships(db)(
       { tenantId, projectId },
@@ -3600,6 +3692,7 @@ var getFullGraphDefinition = (db) => async ({
   }
   let artifactComponentsObject = {};
   try {
+    const internalAgentIds = graphAgents.map((agent) => agent.id);
     const agentIds = Array.from(internalAgentIds);
     artifactComponentsObject = await fetchComponentRelationships(db)(
       { tenantId, projectId },
@@ -3706,16 +3799,14 @@ var getFullGraphDefinition = (db) => async ({
   return result;
 };
 var upsertAgentGraph = (db) => async (params) => {
-  const scopes = { tenantId: params.data.tenantId, projectId: params.data.projectId };
   const graphId = params.data.id || nanoid.nanoid();
+  const scopes = { tenantId: params.data.tenantId, projectId: params.data.projectId, graphId };
   const existing = await getAgentGraphById(db)({
-    scopes,
-    graphId
+    scopes
   });
   if (existing) {
     return await updateAgentGraph(db)({
       scopes,
-      graphId,
       data: {
         name: params.data.name,
         defaultAgentId: params.data.defaultAgentId,
@@ -4061,7 +4152,8 @@ var getArtifactComponentsForAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(artifactComponents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(artifactComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentArtifactComponents.agentId, params.agentId)
+      drizzleOrm.eq(agentArtifactComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(agentArtifactComponents.agentId, params.scopes.agentId)
     )
   ).orderBy(drizzleOrm.desc(artifactComponents.createdAt));
 };
@@ -4070,7 +4162,8 @@ var associateArtifactComponentWithAgent = (db) => async (params) => {
     id: nanoid.nanoid(),
     tenantId: params.scopes.tenantId,
     projectId: params.scopes.projectId,
-    agentId: params.agentId,
+    graphId: params.scopes.graphId,
+    agentId: params.scopes.agentId,
     artifactComponentId: params.artifactComponentId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   }).returning();
@@ -4082,7 +4175,8 @@ var removeArtifactComponentFromAgent = (db) => async (params) => {
       drizzleOrm.and(
         drizzleOrm.eq(agentArtifactComponents.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(agentArtifactComponents.projectId, params.scopes.projectId),
-        drizzleOrm.eq(agentArtifactComponents.agentId, params.agentId),
+        drizzleOrm.eq(agentArtifactComponents.graphId, params.scopes.graphId),
+        drizzleOrm.eq(agentArtifactComponents.agentId, params.scopes.agentId),
         drizzleOrm.eq(agentArtifactComponents.artifactComponentId, params.artifactComponentId)
       )
     ).returning();
@@ -4096,13 +4190,15 @@ var deleteAgentArtifactComponentRelationByAgent = (db) => async (params) => {
   const result = await db.delete(agentArtifactComponents).where(
     drizzleOrm.and(
       drizzleOrm.eq(agentArtifactComponents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentArtifactComponents.agentId, params.agentId)
+      drizzleOrm.eq(agentArtifactComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(agentArtifactComponents.agentId, params.scopes.agentId)
     )
   );
   return (result.rowsAffected || 0) > 0;
 };
 var getAgentsUsingArtifactComponent = (db) => async (params) => {
   return await db.select({
+    graphId: agentArtifactComponents.graphId,
     agentId: agentArtifactComponents.agentId,
     createdAt: agentArtifactComponents.createdAt
   }).from(agentArtifactComponents).where(
@@ -4118,7 +4214,8 @@ var isArtifactComponentAssociatedWithAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(agentArtifactComponents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentArtifactComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentArtifactComponents.agentId, params.agentId),
+      drizzleOrm.eq(agentArtifactComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(agentArtifactComponents.agentId, params.scopes.agentId),
       drizzleOrm.eq(agentArtifactComponents.artifactComponentId, params.artifactComponentId)
     )
   ).limit(1);
@@ -4129,7 +4226,7 @@ var graphHasArtifactComponents = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(agentArtifactComponents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentArtifactComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentRelations.graphId, params.graphId)
+      drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId)
     )
   ).limit(1);
   const total = result[0]?.count || 0;
@@ -4151,7 +4248,8 @@ var countArtifactComponentsForAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(agentArtifactComponents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentArtifactComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentArtifactComponents.agentId, params.agentId)
+      drizzleOrm.eq(agentArtifactComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(agentArtifactComponents.agentId, params.scopes.agentId)
     )
   );
   const total = result[0]?.count || 0;
@@ -4771,7 +4869,8 @@ var getDataComponentsForAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(dataComponents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(dataComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentDataComponents.agentId, params.agentId)
+      drizzleOrm.eq(agentDataComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(agentDataComponents.agentId, params.scopes.agentId)
     )
   ).orderBy(drizzleOrm.desc(dataComponents.createdAt));
 };
@@ -4780,7 +4879,8 @@ var associateDataComponentWithAgent = (db) => async (params) => {
     id: nanoid.nanoid(),
     tenantId: params.scopes.tenantId,
     projectId: params.scopes.projectId,
-    agentId: params.agentId,
+    graphId: params.scopes.graphId,
+    agentId: params.scopes.agentId,
     dataComponentId: params.dataComponentId
   }).returning();
   return association[0];
@@ -4790,7 +4890,8 @@ var removeDataComponentFromAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(agentDataComponents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentDataComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentDataComponents.agentId, params.agentId),
+      drizzleOrm.eq(agentDataComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(agentDataComponents.agentId, params.scopes.agentId),
       drizzleOrm.eq(agentDataComponents.dataComponentId, params.dataComponentId)
     )
   ).returning();
@@ -4800,7 +4901,8 @@ var deleteAgentDataComponentRelationByAgent = (db) => async (params) => {
   const result = await db.delete(agentDataComponents).where(
     drizzleOrm.and(
       drizzleOrm.eq(agentDataComponents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentDataComponents.agentId, params.agentId)
+      drizzleOrm.eq(agentDataComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(agentDataComponents.agentId, params.scopes.agentId)
     )
   );
   return (result.rowsAffected || 0) > 0;
@@ -4822,7 +4924,8 @@ var isDataComponentAssociatedWithAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(agentDataComponents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentDataComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentDataComponents.agentId, params.agentId),
+      drizzleOrm.eq(agentDataComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(agentDataComponents.agentId, params.scopes.agentId),
       drizzleOrm.eq(agentDataComponents.dataComponentId, params.dataComponentId)
     )
   ).limit(1);
@@ -4876,9 +4979,11 @@ function isExternalAgent(agent) {
 function validateAndTypeGraphData(data) {
   return FullGraphDefinitionSchema.parse(data);
 }
-function validateToolReferences(graphData) {
+function validateToolReferences(graphData, availableToolIds) {
+  if (!availableToolIds) {
+    return;
+  }
   const errors = [];
-  const availableToolIds = new Set(Object.keys(graphData.tools || {}));
   for (const [agentId, agentData] of Object.entries(graphData.agents)) {
     if (isInternalAgent(agentData) && agentData.tools && Array.isArray(agentData.tools)) {
       for (const toolId of agentData.tools) {
@@ -4893,9 +4998,11 @@ function validateToolReferences(graphData) {
 ${errors.join("\n")}`);
   }
 }
-function validateDataComponentReferences(graphData) {
+function validateDataComponentReferences(graphData, availableDataComponentIds) {
+  if (!availableDataComponentIds) {
+    return;
+  }
   const errors = [];
-  const availableDataComponentIds = new Set(Object.keys(graphData.dataComponents || {}));
   for (const [agentId, agentData] of Object.entries(graphData.agents)) {
     if (isInternalAgent(agentData) && agentData.dataComponents) {
       for (const dataComponentId of agentData.dataComponents) {
@@ -4912,9 +5019,11 @@ function validateDataComponentReferences(graphData) {
 ${errors.join("\n")}`);
   }
 }
-function validateArtifactComponentReferences(graphData) {
+function validateArtifactComponentReferences(graphData, availableArtifactComponentIds) {
+  if (!availableArtifactComponentIds) {
+    return;
+  }
   const errors = [];
-  const availableArtifactComponentIds = new Set(Object.keys(graphData.artifactComponents || {}));
   for (const [agentId, agentData] of Object.entries(graphData.agents)) {
     if (isInternalAgent(agentData) && agentData.artifactComponents) {
       for (const artifactComponentId of agentData.artifactComponents) {
@@ -4961,13 +5070,15 @@ function validateAgentRelationships(graphData) {
 ${errors.join("\n")}`);
   }
 }
-function validateGraphStructure(graphData) {
-  if (!graphData.agents[graphData.defaultAgentId]) {
+function validateGraphStructure(graphData, projectResources) {
+  if (graphData.defaultAgentId && !graphData.agents[graphData.defaultAgentId]) {
     throw new Error(`Default agent '${graphData.defaultAgentId}' does not exist in agents`);
   }
-  validateToolReferences(graphData);
-  validateDataComponentReferences(graphData);
-  validateArtifactComponentReferences(graphData);
+  if (projectResources) {
+    validateToolReferences(graphData, projectResources.toolIds);
+    validateDataComponentReferences(graphData, projectResources.dataComponentIds);
+    validateArtifactComponentReferences(graphData, projectResources.artifactComponentIds);
+  }
   validateAgentRelationships(graphData);
 }
 var dbResultToMcpTool = (dbResult) => {
@@ -5088,6 +5199,7 @@ var addToolToAgent = (db) => async (params) => {
     id,
     tenantId: params.scopes.tenantId,
     projectId: params.scopes.projectId,
+    graphId: params.scopes.graphId,
     agentId: params.agentId,
     toolId: params.toolId,
     selectedTools: params.selectedTools,
@@ -5101,6 +5213,7 @@ var removeToolFromAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
       drizzleOrm.eq(agentToolRelations.agentId, params.agentId),
       drizzleOrm.eq(agentToolRelations.toolId, params.toolId)
     )
@@ -5112,6 +5225,7 @@ var upsertAgentToolRelation = (db) => async (params) => {
     where: drizzleOrm.and(
       drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
       drizzleOrm.eq(agentToolRelations.agentId, params.agentId),
       drizzleOrm.eq(agentToolRelations.toolId, params.toolId)
     )
@@ -5168,13 +5282,17 @@ var getHealthyToolsForAgent = (db) => async (params) => {
   }).from(tools).innerJoin(
     agentToolRelations,
     drizzleOrm.and(
-      drizzleOrm.eq(tools.id, agentToolRelations.toolId),
-      drizzleOrm.eq(agentToolRelations.agentId, params.agentId),
-      drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId)
-    )
-  ).where(drizzleOrm.and(drizzleOrm.eq(tools.tenantId, params.scopes.tenantId), drizzleOrm.eq(tools.status, "healthy")));
-  return healthyTools.map((row) => row.tool);
-};
+      drizzleOrm.eq(tools.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(tools.projectId, params.scopes.projectId),
+      drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(agentToolRelations.agentId, params.scopes.agentId),
+      drizzleOrm.eq(tools.id, agentToolRelations.toolId)
+    )
+  ).where(drizzleOrm.eq(tools.status, "healthy"));
+  return healthyTools.map((row) => row.tool);
+};
 
 // src/data-access/graphFull.ts
 var defaultLogger = {
@@ -5267,59 +5385,37 @@ var createFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
   validateGraphStructure(typed);
   await applyExecutionLimitsInheritance(db, logger11, { tenantId, projectId }, typed);
   try {
-    if (typed.credentialReferences && Object.keys(typed.credentialReferences).length > 0) {
-      logger11.info(
-        { credentialReferencesCount: Object.keys(typed.credentialReferences).length },
-        "Processing credential references"
-      );
-      const credentialRefPromises = Object.entries(typed.credentialReferences).map(
-        async ([_credId, credData]) => {
-          try {
-            logger11.info({ credId: credData.id }, "Processing credential reference");
-            await upsertCredentialReference(db)({
-              data: {
-                ...credData,
-                tenantId,
-                projectId
-              }
-            });
-            logger11.info({ credId: credData.id }, "Credential reference processed successfully");
-          } catch (error) {
-            logger11.error(
-              { credId: credData.id, error },
-              "Failed to create/update credential reference"
-            );
-            throw error;
-          }
-        }
-      );
-      await Promise.all(credentialRefPromises);
-      logger11.info(
-        { credentialReferencesCount: Object.keys(typed.credentialReferences).length },
-        "All credential references created/updated successfully"
-      );
-    }
-    const toolPromises = Object.entries(typed.tools || {}).map(async ([toolId, toolData]) => {
-      try {
-        logger11.info({ toolId }, "Processing tool");
-        await upsertTool(db)({
-          data: {
-            tenantId,
-            projectId,
-            ...toolData
-          }
-        });
-        logger11.info({ toolId }, "Tool processed successfully");
-      } catch (error) {
-        logger11.error({ toolId, error }, "Failed to create/update tool");
-        throw error;
-      }
-    });
-    await Promise.all(toolPromises);
     logger11.info(
-      { toolCount: Object.keys(typed.tools || {}).length },
-      "All tools created/updated successfully"
+      {},
+      "CredentialReferences are project-scoped - skipping credential reference creation in graph"
     );
+    logger11.info({}, "Tools are project-scoped - skipping tool creation in graph");
+    let finalGraphId;
+    try {
+      const graphId = typed.id || nanoid.nanoid();
+      logger11.info({ graphId }, "Creating agent graph metadata");
+      const agentGraph2 = await upsertAgentGraph(db)({
+        data: {
+          id: graphId,
+          tenantId,
+          projectId,
+          name: typed.name,
+          defaultAgentId: typed.defaultAgentId,
+          description: typed.description,
+          contextConfigId: void 0,
+          // Will be updated later if context config exists
+          models: typed.models,
+          statusUpdates: typed.statusUpdates,
+          graphPrompt: typed.graphPrompt,
+          stopWhen: typed.stopWhen
+        }
+      });
+      finalGraphId = agentGraph2.id;
+      logger11.info({ graphId: finalGraphId }, "Agent graph metadata created successfully");
+    } catch (error) {
+      logger11.error({ graphId: typed.id, error }, "Failed to create/update graph metadata");
+      throw error;
+    }
     let contextConfigId;
     if (typed.contextConfig) {
       try {
@@ -5341,66 +5437,14 @@ var createFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
         throw error;
       }
     }
-    if (typed.dataComponents && Object.keys(typed.dataComponents).length > 0) {
-      const dataComponentPromises = Object.entries(typed.dataComponents).map(
-        async ([dataComponentId, dataComponentData]) => {
-          try {
-            logger11.info({ dataComponentId }, "Processing data component");
-            await upsertDataComponent(db)({
-              data: {
-                id: dataComponentId,
-                tenantId,
-                projectId,
-                name: dataComponentData.name,
-                description: dataComponentData.description || "",
-                props: dataComponentData.props || {}
-              }
-            });
-            logger11.info({ dataComponentId }, "Data component processed successfully");
-          } catch (error) {
-            logger11.error({ dataComponentId, error }, "Failed to create/update dataComponent");
-            throw error;
-          }
-        }
-      );
-      await Promise.all(dataComponentPromises);
-      logger11.info(
-        { dataComponentCount: Object.keys(typed.dataComponents).length },
-        "All dataComponents created/updated successfully"
-      );
-    }
-    if (typed.artifactComponents && Object.keys(typed.artifactComponents).length > 0) {
-      const artifactComponentPromises = Object.entries(typed.artifactComponents).map(
-        async ([artifactComponentId, artifactComponentData]) => {
-          try {
-            logger11.info({ artifactComponentId }, "Processing artifact component");
-            await upsertArtifactComponent(db)({
-              data: {
-                id: artifactComponentId,
-                tenantId,
-                projectId,
-                name: artifactComponentData.name,
-                description: artifactComponentData.description || "",
-                summaryProps: artifactComponentData.summaryProps || {},
-                fullProps: artifactComponentData.fullProps || {}
-              }
-            });
-            logger11.info({ artifactComponentId }, "Artifact component processed successfully");
-          } catch (error) {
-            logger11.error(
-              { artifactComponentId, error },
-              "Failed to create/update artifactComponent"
-            );
-            throw error;
-          }
-        }
-      );
-      await Promise.all(artifactComponentPromises);
-      logger11.info(
-        { artifactComponentCount: Object.keys(typed.artifactComponents).length },
-        "All artifactComponents created/updated successfully"
-      );
-    }
+    logger11.info(
+      {},
+      "DataComponents are project-scoped - skipping dataComponent creation in graph"
+    );
+    logger11.info(
+      {},
+      "ArtifactComponents are project-scoped - skipping artifactComponent creation in graph"
+    );
     const internalAgentPromises = Object.entries(typed.agents).filter(([_, agentData]) => isInternalAgent(agentData)).map(async ([agentId, agentData]) => {
       const internalAgent = agentData;
       try {
@@ -5410,6 +5454,7 @@ var createFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
             id: agentId,
             tenantId,
             projectId,
+            graphId: finalGraphId,
             name: internalAgent.name || "",
             description: internalAgent.description || "",
             prompt: internalAgent.prompt || "",
@@ -5438,6 +5483,7 @@ var createFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
             id: agentId,
             tenantId,
             projectId,
+            graphId: finalGraphId,
             name: externalAgent.name,
             description: externalAgent.description || "",
             baseUrl: externalAgent.baseUrl,
@@ -5456,29 +5502,24 @@ var createFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
       ([_, agentData]) => isExternalAgent(agentData)
     ).length;
     logger11.info({ externalAgentCount }, "All external agents created/updated successfully");
-    let finalGraphId;
-    try {
-      logger11.info({ graphId: typed.id }, "Processing agent graph metadata");
-      const agentGraph2 = await upsertAgentGraph(db)({
-        data: {
-          id: typed.id || nanoid.nanoid(),
-          tenantId,
-          projectId,
-          name: typed.name,
-          defaultAgentId: typed.defaultAgentId,
-          description: typed.description,
-          contextConfigId,
-          models: typed.models,
-          statusUpdates: typed.statusUpdates,
-          graphPrompt: typed.graphPrompt,
-          stopWhen: typed.stopWhen
-        }
-      });
-      finalGraphId = agentGraph2.id;
-      logger11.info({ graphId: finalGraphId }, "Agent graph metadata processed successfully");
-    } catch (error) {
-      logger11.error({ graphId: typed.id, error }, "Failed to create/update graph metadata");
-      throw error;
+    if (contextConfigId) {
+      try {
+        logger11.info(
+          { graphId: finalGraphId, contextConfigId },
+          "Updating graph with context config"
+        );
+        await updateAgentGraph(db)({
+          scopes: { tenantId, projectId, graphId: finalGraphId },
+          data: { contextConfigId }
+        });
+        logger11.info({ graphId: finalGraphId }, "Graph updated with context config");
+      } catch (error) {
+        logger11.error(
+          { graphId: finalGraphId, error },
+          "Failed to update graph with context config"
+        );
+        throw error;
+      }
     }
     const agentToolPromises = [];
     for (const [agentId, agentData] of Object.entries(typed.agents)) {
@@ -5490,7 +5531,7 @@ var createFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
                 const selectedTools = agentData.selectedTools?.[toolId];
                 logger11.info({ agentId, toolId }, "Processing agent-tool relation");
                 await upsertAgentToolRelation(db)({
-                  scopes: { tenantId, projectId },
+                  scopes: { tenantId, projectId, graphId: finalGraphId },
                   agentId,
                   toolId,
                   selectedTools
@@ -5521,8 +5562,7 @@ var createFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
                   "Processing agent-data component relation"
                 );
                 await upsertAgentDataComponentRelation(db)({
-                  scopes: { tenantId, projectId },
-                  agentId,
+                  scopes: { tenantId, projectId, graphId: finalGraphId, agentId },
                   dataComponentId
                 });
                 logger11.info(
@@ -5554,8 +5594,7 @@ var createFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
                   "Processing agent-artifact component relation"
                 );
                 await upsertAgentArtifactComponentRelation(db)({
-                  scopes: { tenantId, projectId },
-                  agentId,
+                  scopes: { tenantId, projectId, graphId: finalGraphId, agentId },
                   artifactComponentId
                 });
                 logger11.info(
@@ -5651,8 +5690,7 @@ var createFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
       "All agent relations created"
     );
     const createdGraph = await getFullGraphDefinition(db)({
-      scopes: { tenantId, projectId },
-      graphId: finalGraphId
+      scopes: { tenantId, projectId, graphId: finalGraphId }
     });
     if (!createdGraph) {
       throw new Error("Failed to retrieve created graph");
@@ -5675,8 +5713,7 @@ var updateFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
     {
       tenantId,
       graphId: typedGraphDefinition.id,
-      agentCount: Object.keys(typedGraphDefinition.agents).length,
-      toolCount: Object.keys(typedGraphDefinition.tools || {}).length
+      agentCount: Object.keys(typedGraphDefinition.agents).length
     },
     "Updating full graph in database"
   );
@@ -5689,8 +5726,7 @@ var updateFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
   );
   try {
     const existingGraph = await getAgentGraphById(db)({
-      scopes: { tenantId, projectId },
-      graphId: typedGraphDefinition.id
+      scopes: { tenantId, projectId, graphId: typedGraphDefinition.id }
     });
     if (!existingGraph) {
       logger11.info(
@@ -5700,65 +5736,40 @@ var updateFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
       return createFullGraphServerSide(db)(scopes, graphData);
     }
     const existingGraphModels = existingGraph.models;
-    if (typedGraphDefinition.credentialReferences && Object.keys(typedGraphDefinition.credentialReferences).length > 0) {
-      logger11.info(
-        {
-          credentialReferencesCount: Object.keys(typedGraphDefinition.credentialReferences).length
-        },
-        "Processing credential references"
-      );
-      const credentialRefPromises = Object.entries(typedGraphDefinition.credentialReferences).map(
-        async ([_credId, credData]) => {
-          try {
-            logger11.info({ credId: credData.id }, "Processing credential reference");
-            await upsertCredentialReference(db)({
-              data: {
-                ...credData,
-                tenantId,
-                projectId
-              }
-            });
-            logger11.info({ credId: credData.id }, "Credential reference processed successfully");
-          } catch (error) {
-            logger11.error(
-              { credId: credData.id, error },
-              "Failed to create/update credential reference"
-            );
-            throw error;
-          }
+    logger11.info(
+      {},
+      "CredentialReferences are project-scoped - skipping credential reference update in graph"
+    );
+    logger11.info({}, "Tools are project-scoped - skipping tool creation in graph update");
+    let finalGraphId;
+    try {
+      const graphId = typedGraphDefinition.id || nanoid.nanoid();
+      logger11.info({ graphId }, "Getting/creating agent graph metadata");
+      const agentGraph2 = await upsertAgentGraph(db)({
+        data: {
+          id: graphId,
+          tenantId,
+          projectId,
+          name: typedGraphDefinition.name,
+          defaultAgentId: typedGraphDefinition.defaultAgentId,
+          description: typedGraphDefinition.description,
+          contextConfigId: void 0,
+          // Will be updated later if context config exists
+          models: typedGraphDefinition.models,
+          statusUpdates: typedGraphDefinition.statusUpdates,
+          graphPrompt: typedGraphDefinition.graphPrompt,
+          stopWhen: typedGraphDefinition.stopWhen
         }
+      });
+      finalGraphId = agentGraph2.id;
+      logger11.info({ graphId: finalGraphId }, "Agent graph metadata ready");
+    } catch (error) {
+      logger11.error(
+        { graphId: typedGraphDefinition.id, error },
+        "Failed to get/update graph metadata"
       );
-      await Promise.all(credentialRefPromises);
-      logger11.info(
-        {
-          credentialReferencesCount: Object.keys(typedGraphDefinition.credentialReferences).length
-        },
-        "All credential references created/updated successfully"
-      );
+      throw error;
     }
-    const toolPromises = Object.entries(typedGraphDefinition.tools || {}).map(
-      async ([toolId, toolData]) => {
-        try {
-          logger11.info({ toolId }, "Processing tool");
-          await upsertTool(db)({
-            data: {
-              tenantId,
-              projectId,
-              ...toolData
-            }
-          });
-          logger11.info({ toolId }, "Tool processed successfully");
-        } catch (error) {
-          logger11.error({ toolId, error }, "Failed to create/update tool");
-          throw error;
-        }
-      }
-    );
-    await Promise.all(toolPromises);
-    logger11.info(
-      { toolCount: Object.keys(typedGraphDefinition.tools || {}).length },
-      "All tools created/updated successfully"
-    );
     let contextConfigId;
     if (typedGraphDefinition.contextConfig) {
       try {
@@ -5783,66 +5794,11 @@ var updateFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
         throw error;
       }
     }
-    if (typedGraphDefinition.dataComponents && Object.keys(typedGraphDefinition.dataComponents).length > 0) {
-      const dataComponentPromises = Object.entries(typedGraphDefinition.dataComponents).map(
-        async ([dataComponentId, dataComponentData]) => {
-          try {
-            logger11.info({ dataComponentId }, "Processing data component");
-            await upsertDataComponent(db)({
-              data: {
-                id: dataComponentId,
-                tenantId,
-                projectId,
-                name: dataComponentData.name,
-                description: dataComponentData.description || "",
-                props: dataComponentData.props || {}
-              }
-            });
-            logger11.info({ dataComponentId }, "Data component processed successfully");
-          } catch (error) {
-            logger11.error({ dataComponentId, error }, "Failed to create/update dataComponent");
-            throw error;
-          }
-        }
-      );
-      await Promise.all(dataComponentPromises);
-      logger11.info(
-        { dataComponentCount: Object.keys(typedGraphDefinition.dataComponents).length },
-        "All dataComponents created/updated successfully"
-      );
-    }
-    if (typedGraphDefinition.artifactComponents && Object.keys(typedGraphDefinition.artifactComponents).length > 0) {
-      const artifactComponentPromises = Object.entries(
-        typedGraphDefinition.artifactComponents
-      ).map(async ([artifactComponentId, artifactComponentData]) => {
-        try {
-          logger11.info({ artifactComponentId }, "Processing artifact component");
-          await upsertArtifactComponent(db)({
-            data: {
-              id: artifactComponentId,
-              tenantId,
-              projectId,
-              name: artifactComponentData.name,
-              description: artifactComponentData.description || "",
-              summaryProps: artifactComponentData.summaryProps || {},
-              fullProps: artifactComponentData.fullProps || {}
-            }
-          });
-          logger11.info({ artifactComponentId }, "Artifact component processed successfully");
-        } catch (error) {
-          logger11.error(
-            { artifactComponentId, error },
-            "Failed to create/update artifactComponent"
-          );
-          throw error;
-        }
-      });
-      await Promise.all(artifactComponentPromises);
-      logger11.info(
-        { artifactComponentCount: Object.keys(typedGraphDefinition.artifactComponents).length },
-        "All artifactComponents created/updated successfully"
-      );
-    }
+    logger11.info({}, "DataComponents are project-scoped - skipping dataComponent update in graph");
+    logger11.info(
+      {},
+      "ArtifactComponents are project-scoped - skipping artifactComponent update in graph"
+    );
     const internalAgentPromises = Object.entries(typedGraphDefinition.agents).filter(([_, agentData]) => isInternalAgent(agentData)).map(async ([agentId, agentData]) => {
       const internalAgent = agentData;
       let existingAgent = null;
@@ -5891,6 +5847,7 @@ var updateFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
             id: agentId,
             tenantId,
             projectId,
+            graphId: finalGraphId,
             name: internalAgent.name || "",
             description: internalAgent.description || "",
             prompt: internalAgent.prompt || "",
@@ -5919,6 +5876,7 @@ var updateFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
             id: agentId,
             tenantId,
             projectId,
+            graphId: finalGraphId,
             name: externalAgent.name,
             description: externalAgent.description || "",
             baseUrl: externalAgent.baseUrl,
@@ -5938,8 +5896,7 @@ var updateFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
     ).length;
     logger11.info({ externalAgentCount }, "All external agents created/updated successfully");
     await updateAgentGraph(db)({
-      scopes: { tenantId, projectId },
-      graphId: typedGraphDefinition.id,
+      scopes: { tenantId, projectId, graphId: typedGraphDefinition.id },
       data: {
         name: typedGraphDefinition.name,
         defaultAgentId: typedGraphDefinition.defaultAgentId,
@@ -5954,8 +5911,7 @@ var updateFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
     logger11.info({ graphId: typedGraphDefinition.id }, "Graph metadata updated");
     for (const agentId of Object.keys(typedGraphDefinition.agents)) {
       await deleteAgentToolRelationByAgent(db)({
-        scopes: { tenantId, projectId },
-        agentId
+        scopes: { tenantId, projectId, graphId: finalGraphId, agentId }
       });
     }
     const agentToolPromises = [];
@@ -5967,7 +5923,7 @@ var updateFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
               try {
                 const selectedTools = agentData.selectedTools?.[toolId];
                 await createAgentToolRelation(db)({
-                  scopes: { tenantId, projectId },
+                  scopes: { tenantId, projectId, graphId: finalGraphId },
                   data: {
                     agentId,
                     toolId,
@@ -5990,8 +5946,7 @@ var updateFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
     );
     for (const agentId of Object.keys(typedGraphDefinition.agents)) {
       await deleteAgentDataComponentRelationByAgent(db)({
-        scopes: { tenantId, projectId },
-        agentId
+        scopes: { tenantId, projectId, graphId: finalGraphId, agentId }
       });
     }
     const agentDataComponentPromises = [];
@@ -6002,8 +5957,7 @@ var updateFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
             (async () => {
               try {
                 await associateDataComponentWithAgent(db)({
-                  scopes: { tenantId, projectId },
-                  agentId,
+                  scopes: { tenantId, projectId, graphId: finalGraphId, agentId },
                   dataComponentId
                 });
                 logger11.info({ agentId, dataComponentId }, "Agent-dataComponent relation created");
@@ -6025,8 +5979,7 @@ var updateFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
     );
     for (const agentId of Object.keys(typedGraphDefinition.agents)) {
       await deleteAgentArtifactComponentRelationByAgent(db)({
-        scopes: { tenantId, projectId },
-        agentId
+        scopes: { tenantId, projectId, graphId: finalGraphId, agentId }
       });
     }
     const agentArtifactComponentPromises = [];
@@ -6037,8 +5990,7 @@ var updateFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
             (async () => {
               try {
                 await associateArtifactComponentWithAgent(db)({
-                  scopes: { tenantId, projectId },
-                  agentId,
+                  scopes: { tenantId, projectId, graphId: finalGraphId, agentId },
                   artifactComponentId
                 });
                 logger11.info(
@@ -6062,8 +6014,7 @@ var updateFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
       "All agent-artifactComponent relations updated"
     );
     await deleteAgentRelationsByGraph(db)({
-      scopes: { tenantId, projectId },
-      graphId: typedGraphDefinition.id
+      scopes: { tenantId, projectId, graphId: typedGraphDefinition.id }
     });
     const agentRelationPromises = [];
     for (const [agentId, agentData] of Object.entries(typedGraphDefinition.agents)) {
@@ -6139,8 +6090,7 @@ var updateFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
       "All agent relations updated"
     );
     const updatedGraph = await getFullGraphDefinition(db)({
-      scopes: { tenantId, projectId },
-      graphId: typedGraphDefinition.id
+      scopes: { tenantId, projectId, graphId: typedGraphDefinition.id }
     });
     if (!updatedGraph) {
       throw new Error("Failed to retrieve updated graph");
@@ -6153,22 +6103,21 @@ var updateFullGraphServerSide = (db, logger11 = defaultLogger) => async (scopes,
   }
 };
 var getFullGraph = (db, logger11 = defaultLogger) => async (params) => {
-  const { scopes, graphId } = params;
+  const { scopes } = params;
   const { tenantId, projectId } = scopes;
-  logger11.info({ tenantId, graphId }, "Retrieving full graph definition");
+  logger11.info({ tenantId, graphId: scopes.graphId }, "Retrieving full graph definition");
   try {
     const graph = await getFullGraphDefinition(db)({
-      scopes: { tenantId, projectId },
-      graphId
+      scopes: { tenantId, projectId, graphId: scopes.graphId }
     });
     if (!graph) {
-      logger11.info({ tenantId, graphId }, "Graph not found");
+      logger11.info({ tenantId, graphId: scopes.graphId }, "Graph not found");
       return null;
     }
     logger11.info(
       {
         tenantId,
-        graphId,
+        graphId: scopes.graphId,
         agentCount: Object.keys(graph.agents).length
       },
       "Full graph retrieved successfully"
@@ -6178,7 +6127,7 @@ var getFullGraph = (db, logger11 = defaultLogger) => async (params) => {
     logger11.error(
       {
         tenantId,
-        graphId,
+        graphId: scopes.graphId,
         error: error instanceof Error ? error.message : "Unknown error"
       },
       "Failed to retrieve full graph"
@@ -6187,29 +6136,25 @@ var getFullGraph = (db, logger11 = defaultLogger) => async (params) => {
   }
 };
 var deleteFullGraph = (db, logger11 = defaultLogger) => async (params) => {
-  const { scopes, graphId } = params;
-  const { tenantId, projectId } = scopes;
+  const { tenantId, projectId, graphId } = params.scopes;
   logger11.info({ tenantId, graphId }, "Deleting full graph and related entities");
   try {
     const graph = await getFullGraphDefinition(db)({
-      scopes: { tenantId, projectId },
-      graphId
+      scopes: { tenantId, projectId, graphId }
     });
     if (!graph) {
       logger11.info({ tenantId, graphId }, "Graph not found for deletion");
       return false;
     }
     await deleteAgentRelationsByGraph(db)({
-      scopes: { tenantId, projectId },
-      graphId
+      scopes: { tenantId, projectId, graphId }
     });
     logger11.info({ tenantId, graphId }, "Agent relations deleted");
     const agentIds = Object.keys(graph.agents);
     if (agentIds.length > 0) {
       for (const agentId of agentIds) {
         await deleteAgentToolRelationByAgent(db)({
-          scopes: { tenantId, projectId },
-          agentId
+          scopes: { tenantId, projectId, graphId, agentId }
         });
       }
       logger11.info(
@@ -6218,8 +6163,7 @@ var deleteFullGraph = (db, logger11 = defaultLogger) => async (params) => {
       );
     }
     await deleteAgentGraph(db)({
-      scopes: { tenantId, projectId },
-      graphId
+      scopes: { tenantId, projectId, graphId }
     });
     logger11.info({ tenantId, graphId }, "Graph metadata deleted");
     logger11.info({ tenantId, graphId }, "Full graph deleted successfully");
@@ -6928,8 +6872,7 @@ var createFullProjectServerSide = (db, logger11 = defaultLogger2) => async (scop
       db,
       logger11
     )({
-      scopes: { tenantId, projectId: typed.id },
-      projectId: typed.id
+      scopes: { tenantId, projectId: typed.id }
     });
   } catch (error) {
     logger11.error(
@@ -7235,8 +7178,7 @@ var updateFullProjectServerSide = (db, logger11 = defaultLogger2) => async (scop
       db,
       logger11
     )({
-      scopes: { tenantId, projectId: typed.id },
-      projectId: typed.id
+      scopes: { tenantId, projectId: typed.id }
     });
   } catch (error) {
     logger11.error(
@@ -7251,8 +7193,8 @@ var updateFullProjectServerSide = (db, logger11 = defaultLogger2) => async (scop
   }
 };
 var getFullProject = (db, logger11 = defaultLogger2) => async (params) => {
-  const { scopes, projectId } = params;
-  const { tenantId } = scopes;
+  const { scopes } = params;
+  const { tenantId, projectId } = scopes;
   logger11.info({ tenantId, projectId }, "Retrieving full project definition");
   try {
     const project = await getProject(db)({
@@ -7406,18 +7348,10 @@ var getFullProject = (db, logger11 = defaultLogger2) => async (params) => {
             "Retrieving full graph definition"
           );
           const fullGraph = await getFullGraph(db)({
-            scopes: { tenantId, projectId },
-            graphId: graph.id
+            scopes: { tenantId, projectId, graphId: graph.id }
           });
           if (fullGraph) {
-            const {
-              tools: _tools,
-              dataComponents: _dataComponents,
-              artifactComponents: _artifactComponents,
-              contextConfig: _contextConfig,
-              credentialReferences: _credentialReferences,
-              ...graphWithoutProjectResources
-            } = fullGraph;
+            const { contextConfig: _contextConfig, ...graphWithoutProjectResources } = fullGraph;
             graphs[graph.id] = graphWithoutProjectResources;
             logger11.info(
               { tenantId, projectId, graphId: graph.id },
@@ -7472,16 +7406,15 @@ var getFullProject = (db, logger11 = defaultLogger2) => async (params) => {
   }
 };
 var deleteFullProject = (db, logger11 = defaultLogger2) => async (params) => {
-  const { scopes, projectId } = params;
-  const { tenantId } = scopes;
+  const { scopes } = params;
+  const { tenantId, projectId } = scopes;
   logger11.info({ tenantId, projectId }, "Deleting full project and related entities");
   try {
     const project = await getFullProject(
       db,
       logger11
     )({
-      scopes: { tenantId, projectId },
-      projectId
+      scopes: { tenantId, projectId }
     });
     if (!project) {
       logger11.info({ tenantId, projectId }, "Project not found for deletion");
@@ -7503,8 +7436,7 @@ var deleteFullProject = (db, logger11 = defaultLogger2) => async (params) => {
             db,
             logger11
           )({
-            scopes: { tenantId, projectId },
-            graphId
+            scopes: { tenantId, projectId, graphId }
           });
           logger11.info(
             { tenantId, projectId, graphId },
@@ -8919,8 +8851,7 @@ async function validateRequestContext({
 }) {
   try {
     const agentGraph2 = await getAgentGraphWithDefaultAgent(dbClient)({
-      scopes: { tenantId, projectId },
-      graphId
+      scopes: { tenantId, projectId, graphId }
     });
     if (!agentGraph2?.contextConfigId) {
       logger7.debug({ graphId }, "No context config found for graph, skipping validation");
@@ -9060,13 +8991,11 @@ function contextValidationMiddleware(dbClient) {
           },
           "Request context validation failed"
         );
-        return c.json(
-          {
-            error: "Invalid request context",
-            details: validationResult.errors
-          },
-          400
-        );
+        const errorMessage = `Invalid request context: ${validationResult.errors.map((e) => `${e.field}: ${e.message}`).join(", ")}`;
+        throw createApiError({
+          code: "bad_request",
+          message: errorMessage
+        });
       }
       c.set("validatedContext", validationResult.validatedContext);
       logger7.debug(
@@ -9085,13 +9014,10 @@ function contextValidationMiddleware(dbClient) {
         },
         "Context validation middleware error"
       );
-      return c.json(
-        {
-          error: "Context validation failed",
-          message: "Internal validation error"
-        },
-        500
-      );
+      throw createApiError({
+        code: "internal_server_error",
+        message: "Context validation failed"
+      });
     }
   };
 }
@@ -9467,7 +9393,15 @@ async function handleContextConfigChange(tenantId, projectId, conversationId, gr
     );
   }
 }
-async function handleContextResolution(tenantId, projectId, conversationId, graphId, requestContext, dbClient, credentialStores) {
+async function handleContextResolution({
+  tenantId,
+  projectId,
+  graphId,
+  conversationId,
+  requestContext,
+  dbClient,
+  credentialStores
+}) {
   return tracer.startActiveSpan(
     "context.handle_context_resolution",
     {
@@ -9480,8 +9414,7 @@ async function handleContextResolution(tenantId, projectId, conversationId, grap
       let trigger;
       try {
         agentGraph2 = await getAgentGraphWithDefaultAgent(dbClient)({
-          scopes: { tenantId, projectId },
-          graphId
+          scopes: { tenantId, projectId, graphId }
         });
         if (!agentGraph2?.contextConfigId) {
           logger9.debug({ graphId }, "No context config found for graph");
@@ -10190,6 +10123,53 @@ function createDefaultCredentialStores() {
   stores.push(createKeyChainStore("keychain-default"));
   return stores;
 }
+var loadEnvironmentFiles = () => {
+  const environmentFiles = [];
+  const currentEnv = path__default.default.resolve(process.cwd(), ".env");
+  if (fs__default.default.existsSync(currentEnv)) {
+    environmentFiles.push(currentEnv);
+  }
+  const rootEnv = findUp.findUpSync(".env", { cwd: path__default.default.dirname(process.cwd()) });
+  if (rootEnv) {
+    if (rootEnv !== currentEnv) {
+      environmentFiles.push(rootEnv);
+    }
+  }
+  const userConfigPath = path__default.default.join(os__default.default.homedir(), ".inkeep", "config");
+  if (fs__default.default.existsSync(userConfigPath)) {
+    dotenv__default.default.config({ path: userConfigPath, override: true, quiet: true });
+  }
+  if (environmentFiles.length > 0) {
+    dotenv__default.default.config({
+      path: environmentFiles,
+      override: false,
+      quiet: true
+    });
+    dotenvExpand.expand({ processEnv: process.env });
+  }
+};
+loadEnvironmentFiles();
+var envSchema = zod.z.object({
+  ENVIRONMENT: zod.z.enum(["development", "production", "pentest", "test"]).optional(),
+  DB_FILE_NAME: zod.z.string(),
+  OTEL_TRACES_FORCE_FLUSH_ENABLED: zod.z.coerce.boolean().optional()
+});
+var parseEnv = () => {
+  try {
+    const parsedEnv = envSchema.parse(process.env);
+    return parsedEnv;
+  } catch (error) {
+    if (error instanceof zod.z.ZodError) {
+      const missingVars = error.issues.map((issue) => issue.path.join("."));
+      throw new Error(
+        `\u274C Invalid environment variables: ${missingVars.join(", ")}
+${error.message}`
+      );
+    }
+    throw error;
+  }
+};
+parseEnv();
 
 // src/validation/id-validation.ts
 function isValidResourceId(id) {
@@ -10381,6 +10361,8 @@ exports.TaskUpdateSchema = TaskUpdateSchema;
 exports.TemplateEngine = TemplateEngine;
 exports.TenantIdParamsSchema = TenantIdParamsSchema;
 exports.TenantParamsSchema = TenantParamsSchema;
+exports.TenantProjectGraphIdParamsSchema = TenantProjectGraphIdParamsSchema;
+exports.TenantProjectGraphParamsSchema = TenantProjectGraphParamsSchema;
 exports.TenantProjectIdParamsSchema = TenantProjectIdParamsSchema;
 exports.TenantProjectParamsSchema = TenantProjectParamsSchema;
 exports.ToolApiInsertSchema = ToolApiInsertSchema;
@@ -10397,6 +10379,7 @@ exports.addToolToAgent = addToolToAgent;
 exports.agentArtifactComponents = agentArtifactComponents;
 exports.agentArtifactComponentsRelations = agentArtifactComponentsRelations;
 exports.agentDataComponents = agentDataComponents;
+exports.agentDataComponentsRelations = agentDataComponentsRelations;
 exports.agentGraph = agentGraph;
 exports.agentGraphRelations = agentGraphRelations;
 exports.agentRelations = agentRelations;
@@ -10467,6 +10450,7 @@ exports.createValidatedDataAccess = createValidatedDataAccess;
 exports.credentialReferences = credentialReferences;
 exports.credentialReferencesRelations = credentialReferencesRelations;
 exports.dataComponents = dataComponents;
+exports.dataComponentsRelations = dataComponentsRelations;
 exports.dbResultToMcpTool = dbResultToMcpTool;
 exports.deleteAgent = deleteAgent;
 exports.deleteAgentArtifactComponentRelationByAgent = deleteAgentArtifactComponentRelationByAgent;
@@ -10507,10 +10491,8 @@ exports.generateApiKey = generateApiKey;
 exports.generateIdFromName = generateIdFromName;
 exports.getActiveAgentForConversation = getActiveAgentForConversation;
 exports.getAgentById = getAgentById;
-exports.getAgentGraph = getAgentGraph;
 exports.getAgentGraphById = getAgentGraphById;
 exports.getAgentGraphWithDefaultAgent = getAgentGraphWithDefaultAgent;
-exports.getAgentInGraphContext = getAgentInGraphContext;
 exports.getAgentRelationById = getAgentRelationById;
 exports.getAgentRelationByParams = getAgentRelationByParams;
 exports.getAgentRelations = getAgentRelations;
@@ -10585,13 +10567,13 @@ exports.isValidHttpRequest = isValidHttpRequest;
 exports.isValidResourceId = isValidResourceId;
 exports.ledgerArtifacts = ledgerArtifacts;
 exports.ledgerArtifactsContextIdIdx = ledgerArtifactsContextIdIdx;
+exports.ledgerArtifactsRelations = ledgerArtifactsRelations;
 exports.ledgerArtifactsTaskContextNameUnique = ledgerArtifactsTaskContextNameUnique;
 exports.ledgerArtifactsTaskIdIdx = ledgerArtifactsTaskIdIdx;
 exports.listAgentGraphs = listAgentGraphs;
 exports.listAgentGraphsPaginated = listAgentGraphsPaginated;
 exports.listAgentRelations = listAgentRelations;
 exports.listAgentToolRelations = listAgentToolRelations;
-exports.listAgentToolRelationsByAgent = listAgentToolRelationsByAgent;
 exports.listAgents = listAgents;
 exports.listAgentsPaginated = listAgentsPaginated;
 exports.listApiKeys = listApiKeys;
@@ -10613,6 +10595,7 @@ exports.listProjectsPaginated = listProjectsPaginated;
 exports.listTaskIdsByContextId = listTaskIdsByContextId;
 exports.listTools = listTools;
 exports.listToolsByStatus = listToolsByStatus;
+exports.loadEnvironmentFiles = loadEnvironmentFiles;
 exports.loggerFactory = loggerFactory;
 exports.maskApiKey = maskApiKey;
 exports.messages = messages;