@inkeep/agents-core 0.0.0-dev-20251009194333 → 0.0.0-dev-20251009215610

package/dist/validation/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var zod = require('zod');
 var zodOpenapi = require('@hono/zod-openapi');
 var drizzleZod = require('drizzle-zod');
 var drizzleOrm = require('drizzle-orm');
@@ -10,7 +11,44 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
 
-// src/validation/schemas.ts
+// src/validation/event-schemas.ts
+var TransferDataSchema = zod.z.object({
+  fromSubAgent: zod.z.string().describe("ID of the sub-agent transferring control"),
+  targetSubAgent: zod.z.string().describe("ID of the sub-agent receiving control"),
+  reason: zod.z.string().optional().describe("Reason for the transfer"),
+  context: zod.z.any().optional().describe("Additional context data")
+});
+var DelegationSentDataSchema = zod.z.object({
+  delegationId: zod.z.string().describe("Unique identifier for this delegation"),
+  fromSubAgent: zod.z.string().describe("ID of the delegating sub-agent"),
+  targetSubAgent: zod.z.string().describe("ID of the sub-agent receiving the delegation"),
+  taskDescription: zod.z.string().describe("Description of the delegated task"),
+  context: zod.z.any().optional().describe("Additional context data")
+});
+var DelegationReturnedDataSchema = zod.z.object({
+  delegationId: zod.z.string().describe("Unique identifier matching the original delegation"),
+  fromSubAgent: zod.z.string().describe("ID of the sub-agent that completed the task"),
+  targetSubAgent: zod.z.string().describe("ID of the sub-agent receiving the result"),
+  result: zod.z.any().optional().describe("Result data from the delegated task")
+});
+var DataOperationDetailsSchema = zod.z.object({
+  timestamp: zod.z.number().describe("Unix timestamp in milliseconds"),
+  subAgentId: zod.z.string().describe("ID of the sub-agent that generated this data"),
+  data: zod.z.any().describe("The actual data payload")
+});
+var DataOperationEventSchema = zod.z.object({
+  type: zod.z.string().describe("Event type identifier"),
+  label: zod.z.string().describe("Human-readable label for the event"),
+  details: DataOperationDetailsSchema
+});
+var A2AMessageMetadataSchema = zod.z.object({
+  fromSubAgentId: zod.z.string().optional().describe("ID of the sending sub-agent"),
+  toSubAgentId: zod.z.string().optional().describe("ID of the receiving sub-agent"),
+  fromExternalAgentId: zod.z.string().optional().describe("ID of the sending external agent"),
+  toExternalAgentId: zod.z.string().optional().describe("ID of the receiving external agent"),
+  taskId: zod.z.string().optional().describe("Associated task ID"),
+  a2aTaskId: zod.z.string().optional().describe("A2A-specific task ID")
+});
 var tenantScoped = {
   tenantId: sqliteCore.text("tenant_id").notNull(),
   id: sqliteCore.text("id").notNull()
@@ -23,9 +61,9 @@ var graphScoped = {
   ...projectScoped,
   graphId: sqliteCore.text("graph_id").notNull()
 };
-var agentScoped = {
+var subAgentScoped = {
   ...graphScoped,
-  agentId: sqliteCore.text("agent_id").notNull()
+  subAgentId: sqliteCore.text("sub_agent_id").notNull()
 };
 var uiProperties = {
   name: sqliteCore.text("name").notNull(),
@@ -56,7 +94,7 @@ var agentGraph = sqliteCore.sqliteTable(
     ...projectScoped,
     name: sqliteCore.text("name").notNull(),
     description: sqliteCore.text("description"),
-    defaultAgentId: sqliteCore.text("default_agent_id"),
+    defaultSubAgentId: sqliteCore.text("default_sub_agent_id"),
     // Reference to shared context configuration for all agents in this graph
     contextConfigId: sqliteCore.text("context_config_id"),
     // add fk relationship
@@ -135,8 +173,8 @@ var contextCache = sqliteCore.sqliteTable(
     )
   ]
 );
-var agents = sqliteCore.sqliteTable(
-  "agents",
+var subAgents = sqliteCore.sqliteTable(
+  "sub_agents",
   {
     ...graphScoped,
     ...uiProperties,
@@ -158,17 +196,16 @@ var agents = sqliteCore.sqliteTable(
     }).onDelete("cascade")
   ]
 );
-var agentRelations = sqliteCore.sqliteTable(
-  "agent_relations",
+var subAgentRelations = sqliteCore.sqliteTable(
+  "sub_agent_relations",
   {
     ...graphScoped,
-    sourceAgentId: sqliteCore.text("source_agent_id").notNull(),
+    sourceSubAgentId: sqliteCore.text("source_sub_agent_id").notNull(),
     // For internal relationships
-    targetAgentId: sqliteCore.text("target_agent_id"),
+    targetSubAgentId: sqliteCore.text("target_sub_agent_id"),
     // For external relationships
-    externalAgentId: sqliteCore.text("external_agent_id"),
+    externalSubAgentId: sqliteCore.text("external_sub_agent_id"),
     relationType: sqliteCore.text("relation_type"),
-    // 'transfer' | 'delegate'
     ...timestamps
   },
   (table) => [
@@ -176,7 +213,7 @@ var agentRelations = sqliteCore.sqliteTable(
     sqliteCore.foreignKey({
       columns: [table.tenantId, table.projectId, table.graphId],
       foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
-      name: "agent_relations_graph_fk"
+      name: "sub_agent_relations_graph_fk"
     }).onDelete("cascade")
   ]
 );
@@ -212,7 +249,7 @@ var externalAgents = sqliteCore.sqliteTable(
 var tasks = sqliteCore.sqliteTable(
   "tasks",
   {
-    ...agentScoped,
+    ...subAgentScoped,
     contextId: sqliteCore.text("context_id").notNull(),
     status: sqliteCore.text("status").notNull(),
     metadata: sqliteCore.blob("metadata", { mode: "json" }).$type(),
@@ -221,9 +258,9 @@ var tasks = sqliteCore.sqliteTable(
   (table) => [
     sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId, table.agentId],
-      foreignColumns: [agents.tenantId, agents.projectId, agents.graphId, agents.id],
-      name: "tasks_agent_fk"
+      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.graphId, subAgents.id],
+      name: "tasks_sub_agent_fk"
     }).onDelete("cascade")
   ]
 );
@@ -263,10 +300,10 @@ var dataComponents = sqliteCore.sqliteTable(
     }).onDelete("cascade")
   ]
 );
-var agentDataComponents = sqliteCore.sqliteTable(
-  "agent_data_components",
+var subAgentDataComponents = sqliteCore.sqliteTable(
+  "sub_agent_data_components",
   {
-    ...agentScoped,
+    ...subAgentScoped,
     dataComponentId: sqliteCore.text("data_component_id").notNull(),
     createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
   },
@@ -274,15 +311,15 @@ var agentDataComponents = sqliteCore.sqliteTable(
     sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
     // Foreign key constraint to agents table (ensures graph and project exist via cascade)
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId, table.agentId],
-      foreignColumns: [agents.tenantId, agents.projectId, agents.graphId, agents.id],
-      name: "agent_data_components_agent_fk"
+      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.graphId, subAgents.id],
+      name: "sub_agent_data_components_sub_agent_fk"
     }).onDelete("cascade"),
     // Foreign key constraint to data_components table
     sqliteCore.foreignKey({
       columns: [table.tenantId, table.projectId, table.dataComponentId],
       foreignColumns: [dataComponents.tenantId, dataComponents.projectId, dataComponents.id],
-      name: "agent_data_components_data_component_fk"
+      name: "sub_agent_data_components_data_component_fk"
     }).onDelete("cascade")
   ]
 );
@@ -303,22 +340,22 @@ var artifactComponents = sqliteCore.sqliteTable(
     }).onDelete("cascade")
   ]
 );
-var agentArtifactComponents = sqliteCore.sqliteTable(
-  "agent_artifact_components",
+var subAgentArtifactComponents = sqliteCore.sqliteTable(
+  "sub_agent_artifact_components",
   {
-    ...agentScoped,
+    ...subAgentScoped,
     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.graphId, table.agentId, table.id]
+      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId, table.id]
     }),
     // Foreign key constraint to agents table (ensures graph and project exist via cascade)
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId, table.agentId],
-      foreignColumns: [agents.tenantId, agents.projectId, agents.graphId, agents.id],
-      name: "agent_artifact_components_agent_fk"
+      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.graphId, subAgents.id],
+      name: "sub_agent_artifact_components_sub_agent_fk"
     }).onDelete("cascade"),
     // Foreign key constraint to artifact_components table
     sqliteCore.foreignKey({
@@ -328,7 +365,7 @@ var agentArtifactComponents = sqliteCore.sqliteTable(
         artifactComponents.projectId,
         artifactComponents.id
       ],
-      name: "agent_artifact_components_artifact_component_fk"
+      name: "sub_agent_artifact_components_artifact_component_fk"
     }).onDelete("cascade")
   ]
 );
@@ -384,10 +421,10 @@ var functions = sqliteCore.sqliteTable(
     }).onDelete("cascade")
   ]
 );
-var agentToolRelations = sqliteCore.sqliteTable(
-  "agent_tool_relations",
+var subAgentToolRelations = sqliteCore.sqliteTable(
+  "sub_agent_tool_relations",
   {
-    ...agentScoped,
+    ...subAgentScoped,
     toolId: sqliteCore.text("tool_id").notNull(),
     selectedTools: sqliteCore.blob("selected_tools", { mode: "json" }).$type(),
     headers: sqliteCore.blob("headers", { mode: "json" }).$type(),
@@ -397,15 +434,15 @@ var agentToolRelations = sqliteCore.sqliteTable(
     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, table.graphId, table.agentId],
-      foreignColumns: [agents.tenantId, agents.projectId, agents.graphId, agents.id],
-      name: "agent_tool_relations_agent_fk"
+      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.graphId, subAgents.id],
+      name: "sub_agent_tool_relations_agent_fk"
     }).onDelete("cascade"),
     // Foreign key constraint to tools table
     sqliteCore.foreignKey({
       columns: [table.tenantId, table.projectId, table.toolId],
       foreignColumns: [tools.tenantId, tools.projectId, tools.id],
-      name: "agent_tool_relations_tool_fk"
+      name: "sub_agent_tool_relations_tool_fk"
     }).onDelete("cascade")
   ]
 );
@@ -414,7 +451,7 @@ var conversations = sqliteCore.sqliteTable(
   {
     ...projectScoped,
     userId: sqliteCore.text("user_id"),
-    activeAgentId: sqliteCore.text("active_agent_id").notNull(),
+    activeSubAgentId: sqliteCore.text("active_sub_agent_id").notNull(),
     title: sqliteCore.text("title"),
     lastContextResolution: sqliteCore.text("last_context_resolution"),
     metadata: sqliteCore.blob("metadata", { mode: "json" }).$type(),
@@ -438,15 +475,15 @@ var messages = sqliteCore.sqliteTable(
     role: sqliteCore.text("role").notNull(),
     // 'user' | 'agent' | 'system'
     // Agent sender/recipient tracking (nullable - only populated when relevant)
-    fromAgentId: sqliteCore.text("from_agent_id"),
+    fromSubAgentId: sqliteCore.text("from_sub_agent_id"),
     // Populated when message is from an agent
-    toAgentId: sqliteCore.text("to_agent_id"),
+    toSubAgentId: sqliteCore.text("to_sub_agent_id"),
     // Populated when message is directed to a specific agent (e.g., transfers/delegations)
     // External agent sender tracking
-    fromExternalAgentId: sqliteCore.text("from_external_agent_id"),
+    fromExternalAgentId: sqliteCore.text("from_external_sub_agent_id"),
     // Populated when message is directed from an external agent
     // External agent recipient tracking
-    toExternalAgentId: sqliteCore.text("to_external_agent_id"),
+    toExternalAgentId: sqliteCore.text("to_external_sub_agent_id"),
     // Populated when message is directed to an external agent
     // Message content stored as JSON to support both formats
     content: sqliteCore.blob("content", { mode: "json" }).$type().notNull(),
@@ -455,8 +492,6 @@ var messages = sqliteCore.sqliteTable(
     // 'user-facing' | 'internal' | 'system' | 'external'
     messageType: sqliteCore.text("message_type").notNull().default("chat"),
     // 'chat' | 'a2a-request' | 'a2a-response' | 'task-update' | 'tool-call'
-    // Legacy agent association (consider deprecating in favor of fromAgentId/toAgentId)
-    agentId: sqliteCore.text("agent_id"),
     taskId: sqliteCore.text("task_id"),
     parentMessageId: sqliteCore.text("parent_message_id"),
     // Remove self-reference constraint here
@@ -583,10 +618,9 @@ drizzleOrm.relations(tasks, ({ one, many }) => ({
   childRelations: many(taskRelations, {
     relationName: "parentTask"
   }),
-  // A task belongs to one agent
-  agent: one(agents, {
-    fields: [tasks.agentId],
-    references: [agents.id]
+  subAgent: one(subAgents, {
+    fields: [tasks.subAgentId],
+    references: [subAgents.id]
   }),
   // A task can have many messages associated with it
   messages: many(messages),
@@ -594,7 +628,7 @@ drizzleOrm.relations(tasks, ({ one, many }) => ({
   ledgerArtifacts: many(ledgerArtifacts)
 }));
 drizzleOrm.relations(projects, ({ many }) => ({
-  agents: many(agents),
+  subAgents: many(subAgents),
   agentGraphs: many(agentGraph),
   tools: many(tools),
   contextConfigs: many(contextConfigs),
@@ -632,17 +666,17 @@ drizzleOrm.relations(contextCache, ({ one }) => ({
     references: [contextConfigs.id]
   })
 }));
-drizzleOrm.relations(agents, ({ many, one }) => ({
+drizzleOrm.relations(subAgents, ({ many, one }) => ({
   project: one(projects, {
-    fields: [agents.tenantId, agents.projectId],
+    fields: [subAgents.tenantId, subAgents.projectId],
     references: [projects.tenantId, projects.id]
   }),
   tasks: many(tasks),
   defaultForGraphs: many(agentGraph),
-  sourceRelations: many(agentRelations, {
+  sourceRelations: many(subAgentRelations, {
     relationName: "sourceRelations"
   }),
-  targetRelations: many(agentRelations, {
+  targetRelations: many(subAgentRelations, {
     relationName: "targetRelations"
   }),
   sentMessages: many(messages, {
@@ -654,18 +688,18 @@ drizzleOrm.relations(agents, ({ many, one }) => ({
   associatedMessages: many(messages, {
     relationName: "associatedAgent"
   }),
-  toolRelations: many(agentToolRelations),
-  dataComponentRelations: many(agentDataComponents),
-  artifactComponentRelations: many(agentArtifactComponents)
+  toolRelations: many(subAgentToolRelations),
+  dataComponentRelations: many(subAgentDataComponents),
+  artifactComponentRelations: many(subAgentArtifactComponents)
 }));
 drizzleOrm.relations(agentGraph, ({ one }) => ({
   project: one(projects, {
     fields: [agentGraph.tenantId, agentGraph.projectId],
     references: [projects.tenantId, projects.id]
   }),
-  defaultAgent: one(agents, {
-    fields: [agentGraph.defaultAgentId],
-    references: [agents.id]
+  defaultSubAgent: one(subAgents, {
+    fields: [agentGraph.defaultSubAgentId],
+    references: [subAgents.id]
   }),
   contextConfig: one(contextConfigs, {
     fields: [agentGraph.contextConfigId],
@@ -677,7 +711,7 @@ drizzleOrm.relations(externalAgents, ({ one, many }) => ({
     fields: [externalAgents.tenantId, externalAgents.projectId],
     references: [projects.tenantId, projects.id]
   }),
-  agentRelations: many(agentRelations),
+  subAgentRelations: many(subAgentRelations),
   credentialReference: one(credentialReferences, {
     fields: [externalAgents.credentialReferenceId],
     references: [credentialReferences.id]
@@ -693,13 +727,13 @@ drizzleOrm.relations(apiKeys, ({ one }) => ({
     references: [agentGraph.id]
   })
 }));
-drizzleOrm.relations(agentToolRelations, ({ one }) => ({
-  agent: one(agents, {
-    fields: [agentToolRelations.agentId],
-    references: [agents.id]
+drizzleOrm.relations(subAgentToolRelations, ({ one }) => ({
+  subAgent: one(subAgents, {
+    fields: [subAgentToolRelations.subAgentId],
+    references: [subAgents.id]
   }),
   tool: one(tools, {
-    fields: [agentToolRelations.toolId],
+    fields: [subAgentToolRelations.toolId],
     references: [tools.id]
   })
 }));
@@ -711,7 +745,7 @@ drizzleOrm.relations(tools, ({ one, many }) => ({
     fields: [tools.tenantId, tools.projectId],
     references: [projects.tenantId, projects.id]
   }),
-  agentRelations: many(agentToolRelations),
+  subAgentRelations: many(subAgentToolRelations),
   credentialReference: one(credentialReferences, {
     fields: [tools.credentialReferenceId],
     references: [credentialReferences.id]
@@ -727,9 +761,9 @@ drizzleOrm.relations(conversations, ({ one, many }) => ({
     references: [projects.tenantId, projects.id]
   }),
   messages: many(messages),
-  activeAgent: one(agents, {
-    fields: [conversations.activeAgentId],
-    references: [agents.id]
+  activeSubAgent: one(subAgents, {
+    fields: [conversations.activeSubAgentId],
+    references: [subAgents.id]
   })
 }));
 drizzleOrm.relations(messages, ({ one, many }) => ({
@@ -737,20 +771,14 @@ drizzleOrm.relations(messages, ({ one, many }) => ({
     fields: [messages.conversationId],
     references: [conversations.id]
   }),
-  // Legacy agent association (consider deprecating)
-  agent: one(agents, {
-    fields: [messages.agentId],
-    references: [agents.id],
-    relationName: "associatedAgent"
-  }),
-  fromAgent: one(agents, {
-    fields: [messages.fromAgentId],
-    references: [agents.id],
+  fromSubAgent: one(subAgents, {
+    fields: [messages.fromSubAgentId],
+    references: [subAgents.id],
     relationName: "sentMessages"
   }),
-  toAgent: one(agents, {
-    fields: [messages.toAgentId],
-    references: [agents.id],
+  toSubAgent: one(subAgents, {
+    fields: [messages.toSubAgentId],
+    references: [subAgents.id],
     relationName: "receivedMessages"
   }),
   fromExternalAgent: one(externalAgents, {
@@ -776,33 +804,40 @@ drizzleOrm.relations(messages, ({ one, many }) => ({
     relationName: "parentChild"
   })
 }));
-drizzleOrm.relations(artifactComponents, ({ many }) => ({
-  agentRelations: many(agentArtifactComponents)
-}));
-drizzleOrm.relations(agentArtifactComponents, ({ one }) => ({
-  agent: one(agents, {
-    fields: [agentArtifactComponents.agentId],
-    references: [agents.id]
+drizzleOrm.relations(artifactComponents, ({ many, one }) => ({
+  project: one(projects, {
+    fields: [artifactComponents.tenantId, artifactComponents.projectId],
+    references: [projects.tenantId, projects.id]
   }),
-  artifactComponent: one(artifactComponents, {
-    fields: [agentArtifactComponents.artifactComponentId],
-    references: [artifactComponents.id]
-  })
+  subAgentRelations: many(subAgentArtifactComponents)
 }));
+drizzleOrm.relations(
+  subAgentArtifactComponents,
+  ({ one }) => ({
+    subAgent: one(subAgents, {
+      fields: [subAgentArtifactComponents.subAgentId],
+      references: [subAgents.id]
+    }),
+    artifactComponent: one(artifactComponents, {
+      fields: [subAgentArtifactComponents.artifactComponentId],
+      references: [artifactComponents.id]
+    })
+  })
+);
 drizzleOrm.relations(dataComponents, ({ many, one }) => ({
   project: one(projects, {
     fields: [dataComponents.tenantId, dataComponents.projectId],
     references: [projects.tenantId, projects.id]
   }),
-  agentRelations: many(agentDataComponents)
+  subAgentRelations: many(subAgentDataComponents)
 }));
-drizzleOrm.relations(agentDataComponents, ({ one }) => ({
-  agent: one(agents, {
-    fields: [agentDataComponents.agentId],
-    references: [agents.id]
+drizzleOrm.relations(subAgentDataComponents, ({ one }) => ({
+  subAgent: one(subAgents, {
+    fields: [subAgentDataComponents.subAgentId],
+    references: [subAgents.id]
   }),
   dataComponent: one(dataComponents, {
-    fields: [agentDataComponents.dataComponentId],
+    fields: [subAgentDataComponents.dataComponentId],
     references: [dataComponents.id]
   })
 }));
@@ -819,23 +854,23 @@ drizzleOrm.relations(ledgerArtifacts, ({ one }) => ({
 drizzleOrm.relations(functions, ({ many }) => ({
   tools: many(tools)
 }));
-drizzleOrm.relations(agentRelations, ({ one }) => ({
+drizzleOrm.relations(subAgentRelations, ({ one }) => ({
   graph: one(agentGraph, {
-    fields: [agentRelations.graphId],
+    fields: [subAgentRelations.graphId],
     references: [agentGraph.id]
   }),
-  sourceAgent: one(agents, {
-    fields: [agentRelations.sourceAgentId],
-    references: [agents.id],
+  sourceSubAgent: one(subAgents, {
+    fields: [subAgentRelations.sourceSubAgentId],
+    references: [subAgents.id],
     relationName: "sourceRelations"
   }),
-  targetAgent: one(agents, {
-    fields: [agentRelations.targetAgentId],
-    references: [agents.id],
+  targetSubAgent: one(subAgents, {
+    fields: [subAgentRelations.targetSubAgentId],
+    references: [subAgents.id],
     relationName: "targetRelations"
   }),
   externalAgent: one(externalAgents, {
-    fields: [agentRelations.externalAgentId],
+    fields: [subAgentRelations.externalSubAgentId],
     references: [externalAgents.id]
   })
 }));
@@ -906,22 +941,22 @@ var createApiUpdateSchema = (schema) => schema.omit({ tenantId: true, projectId:
 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({
+var SubAgentSelectSchema = drizzleZod.createSelectSchema(subAgents);
+var SubAgentInsertSchema = drizzleZod.createInsertSchema(subAgents).extend({
   id: resourceIdSchema,
   models: ModelSchema.optional()
 });
-var AgentUpdateSchema = AgentInsertSchema.partial();
-var AgentApiSelectSchema = createGraphScopedApiSchema(AgentSelectSchema);
-var AgentApiInsertSchema = createGraphScopedApiInsertSchema(AgentInsertSchema);
-var AgentApiUpdateSchema = createGraphScopedApiUpdateSchema(AgentUpdateSchema);
-var AgentRelationSelectSchema = drizzleZod.createSelectSchema(agentRelations);
-var AgentRelationInsertSchema = drizzleZod.createInsertSchema(agentRelations).extend({
+var SubAgentUpdateSchema = SubAgentInsertSchema.partial();
+var SubAgentApiSelectSchema = createGraphScopedApiSchema(SubAgentSelectSchema);
+var SubAgentApiInsertSchema = createGraphScopedApiInsertSchema(SubAgentInsertSchema);
+var SubAgentApiUpdateSchema = createGraphScopedApiUpdateSchema(SubAgentUpdateSchema);
+var AgentRelationSelectSchema = drizzleZod.createSelectSchema(subAgentRelations);
+var AgentRelationInsertSchema = drizzleZod.createInsertSchema(subAgentRelations).extend({
   id: resourceIdSchema,
   graphId: resourceIdSchema,
-  sourceAgentId: resourceIdSchema,
-  targetAgentId: resourceIdSchema.optional(),
-  externalAgentId: resourceIdSchema.optional()
+  sourceSubAgentId: resourceIdSchema,
+  targetSubAgentId: resourceIdSchema.optional(),
+  externalSubAgentId: resourceIdSchema.optional()
 });
 var AgentRelationUpdateSchema = AgentRelationInsertSchema.partial();
 var AgentRelationApiSelectSchema = createGraphScopedApiSchema(AgentRelationSelectSchema);
@@ -931,13 +966,13 @@ var AgentRelationApiInsertSchema = createGraphScopedApiInsertSchema(
   relationType: zodOpenapi.z.enum(VALID_RELATION_TYPES)
 }).refine(
   (data) => {
-    const hasTarget = data.targetAgentId != null;
-    const hasExternal = data.externalAgentId != null;
+    const hasTarget = data.targetSubAgentId != null;
+    const hasExternal = data.externalSubAgentId != null;
     return hasTarget !== hasExternal;
   },
   {
-    message: "Must specify exactly one of targetAgentId or externalAgentId",
-    path: ["targetAgentId", "externalAgentId"]
+    message: "Must specify exactly one of targetSubAgentId or externalSubAgentId",
+    path: ["targetSubAgentId", "externalSubAgentId"]
   }
 );
 var AgentRelationApiUpdateSchema = createGraphScopedApiUpdateSchema(
@@ -946,28 +981,28 @@ var AgentRelationApiUpdateSchema = createGraphScopedApiUpdateSchema(
   relationType: zodOpenapi.z.enum(VALID_RELATION_TYPES).optional()
 }).refine(
   (data) => {
-    const hasTarget = data.targetAgentId != null;
-    const hasExternal = data.externalAgentId != null;
+    const hasTarget = data.targetSubAgentId != null;
+    const hasExternal = data.externalSubAgentId != null;
     if (!hasTarget && !hasExternal) {
       return true;
     }
     return hasTarget !== hasExternal;
   },
   {
-    message: "Must specify exactly one of targetAgentId or externalAgentId when updating agent relationships",
-    path: ["targetAgentId", "externalAgentId"]
+    message: "Must specify exactly one of targetSubAgentId or externalSubAgentId when updating agent relationships",
+    path: ["targetSubAgentId", "externalSubAgentId"]
   }
 );
 var AgentRelationQuerySchema = zodOpenapi.z.object({
-  sourceAgentId: zodOpenapi.z.string().optional(),
-  targetAgentId: zodOpenapi.z.string().optional(),
-  externalAgentId: zodOpenapi.z.string().optional()
+  sourceSubAgentId: zodOpenapi.z.string().optional(),
+  targetSubAgentId: zodOpenapi.z.string().optional(),
+  externalSubAgentId: zodOpenapi.z.string().optional()
 });
-var ExternalAgentRelationInsertSchema = drizzleZod.createInsertSchema(agentRelations).extend({
+var ExternalAgentRelationInsertSchema = drizzleZod.createInsertSchema(subAgentRelations).extend({
   id: resourceIdSchema,
   graphId: resourceIdSchema,
-  sourceAgentId: resourceIdSchema,
-  externalAgentId: resourceIdSchema
+  sourceSubAgentId: resourceIdSchema,
+  externalSubAgentId: resourceIdSchema
 });
 var ExternalAgentRelationApiInsertSchema = createApiInsertSchema(
   ExternalAgentRelationInsertSchema
@@ -1101,8 +1136,8 @@ var DataComponentUpdateSchema = DataComponentInsertSchema.partial();
 var DataComponentApiSelectSchema = createApiSchema(DataComponentSelectSchema);
 var DataComponentApiInsertSchema = createApiInsertSchema(DataComponentInsertSchema);
 var DataComponentApiUpdateSchema = createApiUpdateSchema(DataComponentUpdateSchema);
-var AgentDataComponentSelectSchema = drizzleZod.createSelectSchema(agentDataComponents);
-var AgentDataComponentInsertSchema = drizzleZod.createInsertSchema(agentDataComponents);
+var AgentDataComponentSelectSchema = drizzleZod.createSelectSchema(subAgentDataComponents);
+var AgentDataComponentInsertSchema = drizzleZod.createInsertSchema(subAgentDataComponents);
 var AgentDataComponentUpdateSchema = AgentDataComponentInsertSchema.partial();
 var AgentDataComponentApiSelectSchema = createGraphScopedApiSchema(
   AgentDataComponentSelectSchema
@@ -1131,12 +1166,12 @@ var ArtifactComponentApiInsertSchema = ArtifactComponentInsertSchema.omit({
 var ArtifactComponentApiUpdateSchema = createApiUpdateSchema(
   ArtifactComponentUpdateSchema
 );
-var AgentArtifactComponentSelectSchema = drizzleZod.createSelectSchema(agentArtifactComponents);
+var AgentArtifactComponentSelectSchema = drizzleZod.createSelectSchema(subAgentArtifactComponents);
 var AgentArtifactComponentInsertSchema = drizzleZod.createInsertSchema(
-  agentArtifactComponents
+  subAgentArtifactComponents
 ).extend({
   id: resourceIdSchema,
-  agentId: resourceIdSchema,
+  subAgentId: resourceIdSchema,
   artifactComponentId: resourceIdSchema
 });
 var AgentArtifactComponentUpdateSchema = AgentArtifactComponentInsertSchema.partial();
@@ -1164,7 +1199,7 @@ var ExternalAgentApiSelectSchema = createGraphScopedApiSchema(ExternalAgentSelec
 var ExternalAgentApiInsertSchema = createGraphScopedApiInsertSchema(ExternalAgentInsertSchema);
 var ExternalAgentApiUpdateSchema = createGraphScopedApiUpdateSchema(ExternalAgentUpdateSchema);
 var AllAgentSchema = zodOpenapi.z.discriminatedUnion("type", [
-  AgentApiSelectSchema.extend({ type: zodOpenapi.z.literal("internal") }),
+  SubAgentApiSelectSchema.extend({ type: zodOpenapi.z.literal("internal") }),
   ExternalAgentApiSelectSchema.extend({ type: zodOpenapi.z.literal("external") })
 ]);
 var ApiKeySelectSchema = drizzleZod.createSelectSchema(apiKeys);
@@ -1319,10 +1354,10 @@ var ContextConfigApiInsertSchema = createApiInsertSchema(ContextConfigInsertSche
 var ContextConfigApiUpdateSchema = createApiUpdateSchema(ContextConfigUpdateSchema).omit({
   graphId: true
 });
-var AgentToolRelationSelectSchema = drizzleZod.createSelectSchema(agentToolRelations);
-var AgentToolRelationInsertSchema = drizzleZod.createInsertSchema(agentToolRelations).extend({
+var AgentToolRelationSelectSchema = drizzleZod.createSelectSchema(subAgentToolRelations);
+var AgentToolRelationInsertSchema = drizzleZod.createInsertSchema(subAgentToolRelations).extend({
   id: resourceIdSchema,
-  agentId: resourceIdSchema,
+  subAgentId: resourceIdSchema,
   toolId: resourceIdSchema,
   selectedTools: zodOpenapi.z.array(zodOpenapi.z.string()).nullish(),
   headers: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).nullish()
@@ -1365,7 +1400,7 @@ var CanUseItemSchema = zodOpenapi.z.object({
   toolSelection: zodOpenapi.z.array(zodOpenapi.z.string()).nullish(),
   headers: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).nullish()
 });
-var FullGraphAgentInsertSchema = AgentApiInsertSchema.extend({
+var FullGraphAgentInsertSchema = SubAgentApiInsertSchema.extend({
   type: zodOpenapi.z.literal("internal"),
   canUse: zodOpenapi.z.array(CanUseItemSchema),
   // All tools (both MCP and function tools)
@@ -1374,27 +1409,17 @@ var FullGraphAgentInsertSchema = AgentApiInsertSchema.extend({
   canTransferTo: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
   canDelegateTo: zodOpenapi.z.array(zodOpenapi.z.string()).optional()
 });
-var FullGraphDefinitionSchema = AgentGraphApiInsertSchema.extend({
-  agents: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.union([FullGraphAgentInsertSchema, ExternalAgentApiInsertSchema])),
-  // Lookup maps for UI to resolve canUse items
-  tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema).optional(),
-  // Get tool name/description from toolId
-  functions: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionApiInsertSchema).optional(),
-  // Get function code for function tools
-  contextConfig: zodOpenapi.z.optional(ContextConfigApiInsertSchema),
-  statusUpdates: zodOpenapi.z.optional(StatusUpdateSchema),
-  models: ModelSchema.optional(),
-  stopWhen: GraphStopWhenSchema.optional(),
-  graphPrompt: zodOpenapi.z.string().max(5e3, "Graph prompt cannot exceed 5000 characters").optional()
-});
 var GraphWithinContextOfProjectSchema = AgentGraphApiInsertSchema.extend({
-  agents: zodOpenapi.z.record(
+  subAgents: zodOpenapi.z.record(
     zodOpenapi.z.string(),
     zodOpenapi.z.discriminatedUnion("type", [
       FullGraphAgentInsertSchema,
       ExternalAgentApiInsertSchema.extend({ type: zodOpenapi.z.literal("external") })
     ])
   ),
+  tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema).optional(),
+  // Get tool name/description from toolId
+  functions: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionApiInsertSchema).optional(),
   contextConfig: zodOpenapi.z.optional(ContextConfigApiInsertSchema),
   statusUpdates: zodOpenapi.z.optional(StatusUpdateSchema),
   models: ModelSchema.optional(),
@@ -1466,72 +1491,46 @@ var HeadersScopeSchema = zodOpenapi.z.object({
     example: "graph_789"
   })
 });
+var TenantId = zodOpenapi.z.string().openapi({
+  description: "Tenant identifier",
+  example: "tenant_123"
+});
+var ProjectId = zodOpenapi.z.string().openapi({
+  description: "Project identifier",
+  example: "project_456"
+});
+var GraphId = zodOpenapi.z.string().openapi({
+  description: "Graph identifier",
+  example: "graph_789"
+});
+var SubAgentId = zodOpenapi.z.string().openapi({
+  description: "Sub-agent identifier",
+  example: "sub_agent_123"
+});
 var TenantParamsSchema = zodOpenapi.z.object({
-  tenantId: zodOpenapi.z.string().openapi({
-    description: "Tenant identifier",
-    example: "tenant_123"
-  })
+  tenantId: TenantId
 }).openapi("TenantParams");
-var TenantProjectParamsSchema = 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"
-  })
-}).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"
-  }),
+var TenantIdParamsSchema = TenantParamsSchema.extend({
   id: resourceIdSchema
-}).openapi("TenantProjectGraphIdParams");
-var TenantProjectIdParamsSchema = 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"
-  }),
+}).openapi("TenantIdParams");
+var TenantProjectParamsSchema = TenantParamsSchema.extend({
+  projectId: ProjectId
+}).openapi("TenantProjectParams");
+var TenantProjectIdParamsSchema = TenantProjectParamsSchema.extend({
   id: resourceIdSchema
 }).openapi("TenantProjectIdParams");
-var TenantIdParamsSchema = zodOpenapi.z.object({
-  tenantId: zodOpenapi.z.string().openapi({
-    description: "Tenant identifier",
-    example: "tenant_123"
-  }),
+var TenantProjectGraphParamsSchema = TenantProjectParamsSchema.extend({
+  graphId: GraphId
+}).openapi("TenantProjectGraphParams");
+var TenantProjectGraphIdParamsSchema = TenantProjectGraphParamsSchema.extend({
   id: resourceIdSchema
-}).openapi("TenantIdParams");
-var IdParamsSchema = zodOpenapi.z.object({
+}).openapi("TenantProjectGraphIdParams");
+var TenantProjectGraphSubAgentParamsSchema = TenantProjectGraphParamsSchema.extend({
+  subAgentId: SubAgentId
+}).openapi("TenantProjectGraphSubAgentParams");
+var TenantProjectGraphSubAgentIdParamsSchema = TenantProjectGraphSubAgentParamsSchema.extend({
   id: resourceIdSchema
-}).openapi("IdParams");
+}).openapi("TenantProjectGraphSubAgentIdParams");
 var PaginationQueryParamsSchema = zodOpenapi.z.object({
   page: zodOpenapi.z.coerce.number().min(1).default(1),
   limit: zodOpenapi.z.coerce.number().min(1).max(100).default(10)
@@ -1545,18 +1544,18 @@ function isExternalAgent(agent) {
   return "baseUrl" in agent;
 }
 function validateAndTypeGraphData(data) {
-  return FullGraphDefinitionSchema.parse(data);
+  return GraphWithinContextOfProjectSchema.parse(data);
 }
 function validateToolReferences(graphData, availableToolIds) {
   if (!availableToolIds) {
     return;
   }
   const errors = [];
-  for (const [agentId, agentData] of Object.entries(graphData.agents)) {
+  for (const [subAgentId, agentData] of Object.entries(graphData.subAgents)) {
     if (isInternalAgent(agentData) && agentData.canUse && Array.isArray(agentData.canUse)) {
       for (const canUseItem of agentData.canUse) {
         if (!availableToolIds.has(canUseItem.toolId)) {
-          errors.push(`Agent '${agentId}' references non-existent tool '${canUseItem.toolId}'`);
+          errors.push(`Agent '${subAgentId}' references non-existent tool '${canUseItem.toolId}'`);
         }
       }
     }
@@ -1571,12 +1570,12 @@ function validateDataComponentReferences(graphData, availableDataComponentIds) {
     return;
   }
   const errors = [];
-  for (const [agentId, agentData] of Object.entries(graphData.agents)) {
+  for (const [subAgentId, agentData] of Object.entries(graphData.subAgents)) {
     if (isInternalAgent(agentData) && agentData.dataComponents) {
       for (const dataComponentId of agentData.dataComponents) {
         if (!availableDataComponentIds.has(dataComponentId)) {
           errors.push(
-            `Agent '${agentId}' references non-existent dataComponent '${dataComponentId}'`
+            `Agent '${subAgentId}' references non-existent dataComponent '${dataComponentId}'`
           );
         }
       }
@@ -1592,12 +1591,12 @@ function validateArtifactComponentReferences(graphData, availableArtifactCompone
     return;
   }
   const errors = [];
-  for (const [agentId, agentData] of Object.entries(graphData.agents)) {
+  for (const [subAgentId, agentData] of Object.entries(graphData.subAgents)) {
     if (isInternalAgent(agentData) && agentData.artifactComponents) {
       for (const artifactComponentId of agentData.artifactComponents) {
         if (!availableArtifactComponentIds.has(artifactComponentId)) {
           errors.push(
-            `Agent '${agentId}' references non-existent artifactComponent '${artifactComponentId}'`
+            `Agent '${subAgentId}' references non-existent artifactComponent '${artifactComponentId}'`
           );
         }
       }
@@ -1610,14 +1609,14 @@ ${errors.join("\n")}`);
 }
 function validateAgentRelationships(graphData) {
   const errors = [];
-  const availableAgentIds = new Set(Object.keys(graphData.agents));
-  for (const [agentId, agentData] of Object.entries(graphData.agents)) {
+  const availableAgentIds = new Set(Object.keys(graphData.subAgents));
+  for (const [subAgentId, agentData] of Object.entries(graphData.subAgents)) {
     if (isInternalAgent(agentData)) {
       if (agentData.canTransferTo && Array.isArray(agentData.canTransferTo)) {
         for (const targetId of agentData.canTransferTo) {
           if (!availableAgentIds.has(targetId)) {
             errors.push(
-              `Agent '${agentId}' has transfer target '${targetId}' that doesn't exist in graph`
+              `Agent '${subAgentId}' has transfer target '${targetId}' that doesn't exist in graph`
             );
           }
         }
@@ -1626,7 +1625,7 @@ function validateAgentRelationships(graphData) {
         for (const targetId of agentData.canDelegateTo) {
           if (!availableAgentIds.has(targetId)) {
             errors.push(
-              `Agent '${agentId}' has delegation target '${targetId}' that doesn't exist in graph`
+              `Agent '${subAgentId}' has delegation target '${targetId}' that doesn't exist in graph`
             );
           }
         }
@@ -1639,8 +1638,8 @@ ${errors.join("\n")}`);
   }
 }
 function validateGraphStructure(graphData, projectResources) {
-  if (graphData.defaultAgentId && !graphData.agents[graphData.defaultAgentId]) {
-    throw new Error(`Default agent '${graphData.defaultAgentId}' does not exist in agents`);
+  if (graphData.defaultSubAgentId && !graphData.subAgents[graphData.defaultSubAgentId]) {
+    throw new Error(`Default agent '${graphData.defaultSubAgentId}' does not exist in agents`);
   }
   if (projectResources) {
     validateToolReferences(graphData, projectResources.toolIds);
@@ -1770,9 +1769,7 @@ function validatePropsAsJsonSchema(props) {
   }
 }
 
-exports.AgentApiInsertSchema = AgentApiInsertSchema;
-exports.AgentApiSelectSchema = AgentApiSelectSchema;
-exports.AgentApiUpdateSchema = AgentApiUpdateSchema;
+exports.A2AMessageMetadataSchema = A2AMessageMetadataSchema;
 exports.AgentArtifactComponentApiInsertSchema = AgentArtifactComponentApiInsertSchema;
 exports.AgentArtifactComponentApiSelectSchema = AgentArtifactComponentApiSelectSchema;
 exports.AgentArtifactComponentApiUpdateSchema = AgentArtifactComponentApiUpdateSchema;
@@ -1791,7 +1788,6 @@ exports.AgentGraphApiUpdateSchema = AgentGraphApiUpdateSchema;
 exports.AgentGraphInsertSchema = AgentGraphInsertSchema;
 exports.AgentGraphSelectSchema = AgentGraphSelectSchema;
 exports.AgentGraphUpdateSchema = AgentGraphUpdateSchema;
-exports.AgentInsertSchema = AgentInsertSchema;
 exports.AgentRelationApiInsertSchema = AgentRelationApiInsertSchema;
 exports.AgentRelationApiSelectSchema = AgentRelationApiSelectSchema;
 exports.AgentRelationApiUpdateSchema = AgentRelationApiUpdateSchema;
@@ -1799,7 +1795,6 @@ exports.AgentRelationInsertSchema = AgentRelationInsertSchema;
 exports.AgentRelationQuerySchema = AgentRelationQuerySchema;
 exports.AgentRelationSelectSchema = AgentRelationSelectSchema;
 exports.AgentRelationUpdateSchema = AgentRelationUpdateSchema;
-exports.AgentSelectSchema = AgentSelectSchema;
 exports.AgentStopWhenSchema = AgentStopWhenSchema;
 exports.AgentToolRelationApiInsertSchema = AgentToolRelationApiInsertSchema;
 exports.AgentToolRelationApiSelectSchema = AgentToolRelationApiSelectSchema;
@@ -1807,7 +1802,6 @@ exports.AgentToolRelationApiUpdateSchema = AgentToolRelationApiUpdateSchema;
 exports.AgentToolRelationInsertSchema = AgentToolRelationInsertSchema;
 exports.AgentToolRelationSelectSchema = AgentToolRelationSelectSchema;
 exports.AgentToolRelationUpdateSchema = AgentToolRelationUpdateSchema;
-exports.AgentUpdateSchema = AgentUpdateSchema;
 exports.AllAgentSchema = AllAgentSchema;
 exports.ApiKeyApiCreationResponseSchema = ApiKeyApiCreationResponseSchema;
 exports.ApiKeyApiInsertSchema = ApiKeyApiInsertSchema;
@@ -1854,6 +1848,10 @@ exports.DataComponentBaseSchema = DataComponentBaseSchema;
 exports.DataComponentInsertSchema = DataComponentInsertSchema;
 exports.DataComponentSelectSchema = DataComponentSelectSchema;
 exports.DataComponentUpdateSchema = DataComponentUpdateSchema;
+exports.DataOperationDetailsSchema = DataOperationDetailsSchema;
+exports.DataOperationEventSchema = DataOperationEventSchema;
+exports.DelegationReturnedDataSchema = DelegationReturnedDataSchema;
+exports.DelegationSentDataSchema = DelegationSentDataSchema;
 exports.ErrorResponseSchema = ErrorResponseSchema;
 exports.ExistsResponseSchema = ExistsResponseSchema;
 exports.ExternalAgentApiInsertSchema = ExternalAgentApiInsertSchema;
@@ -1867,7 +1865,6 @@ exports.ExternalAgentUpdateSchema = ExternalAgentUpdateSchema;
 exports.FetchConfigSchema = FetchConfigSchema;
 exports.FetchDefinitionSchema = FetchDefinitionSchema;
 exports.FullGraphAgentInsertSchema = FullGraphAgentInsertSchema;
-exports.FullGraphDefinitionSchema = FullGraphDefinitionSchema;
 exports.FullProjectDefinitionSchema = FullProjectDefinitionSchema;
 exports.FunctionApiInsertSchema = FunctionApiInsertSchema;
 exports.FunctionApiSelectSchema = FunctionApiSelectSchema;
@@ -1879,7 +1876,6 @@ exports.FunctionUpdateSchema = FunctionUpdateSchema;
 exports.GraphStopWhenSchema = GraphStopWhenSchema;
 exports.GraphWithinContextOfProjectSchema = GraphWithinContextOfProjectSchema;
 exports.HeadersScopeSchema = HeadersScopeSchema;
-exports.IdParamsSchema = IdParamsSchema;
 exports.LedgerArtifactApiInsertSchema = LedgerArtifactApiInsertSchema;
 exports.LedgerArtifactApiSelectSchema = LedgerArtifactApiSelectSchema;
 exports.LedgerArtifactApiUpdateSchema = LedgerArtifactApiUpdateSchema;
@@ -1916,6 +1912,12 @@ exports.SingleResponseSchema = SingleResponseSchema;
 exports.StatusComponentSchema = StatusComponentSchema;
 exports.StatusUpdateSchema = StatusUpdateSchema;
 exports.StopWhenSchema = StopWhenSchema;
+exports.SubAgentApiInsertSchema = SubAgentApiInsertSchema;
+exports.SubAgentApiSelectSchema = SubAgentApiSelectSchema;
+exports.SubAgentApiUpdateSchema = SubAgentApiUpdateSchema;
+exports.SubAgentInsertSchema = SubAgentInsertSchema;
+exports.SubAgentSelectSchema = SubAgentSelectSchema;
+exports.SubAgentUpdateSchema = SubAgentUpdateSchema;
 exports.TaskApiInsertSchema = TaskApiInsertSchema;
 exports.TaskApiSelectSchema = TaskApiSelectSchema;
 exports.TaskApiUpdateSchema = TaskApiUpdateSchema;
@@ -1932,6 +1934,8 @@ exports.TenantIdParamsSchema = TenantIdParamsSchema;
 exports.TenantParamsSchema = TenantParamsSchema;
 exports.TenantProjectGraphIdParamsSchema = TenantProjectGraphIdParamsSchema;
 exports.TenantProjectGraphParamsSchema = TenantProjectGraphParamsSchema;
+exports.TenantProjectGraphSubAgentIdParamsSchema = TenantProjectGraphSubAgentIdParamsSchema;
+exports.TenantProjectGraphSubAgentParamsSchema = TenantProjectGraphSubAgentParamsSchema;
 exports.TenantProjectIdParamsSchema = TenantProjectIdParamsSchema;
 exports.TenantProjectParamsSchema = TenantProjectParamsSchema;
 exports.ToolApiInsertSchema = ToolApiInsertSchema;
@@ -1941,6 +1945,7 @@ exports.ToolInsertSchema = ToolInsertSchema;
 exports.ToolSelectSchema = ToolSelectSchema;
 exports.ToolStatusSchema = ToolStatusSchema;
 exports.ToolUpdateSchema = ToolUpdateSchema;
+exports.TransferDataSchema = TransferDataSchema;
 exports.URL_SAFE_ID_PATTERN = URL_SAFE_ID_PATTERN;
 exports.generateIdFromName = generateIdFromName;
 exports.isExternalAgent = isExternalAgent;