@inkeep/agents-core 0.18.1 → 0.19.1

package/README.md

@@ -245,10 +245,10 @@ Define any relationships with existing tables:
 
 ```typescript
 export const workflowRelations = relations(workflows, ({ one, many }) => ({
-  // Example: A workflow belongs to an agent graph
-  agentGraph: one(agentGraphs, {
-    fields: [workflows.agentGraphId],
-    references: [agentGraphs.id],
+  // Example: A workflow belongs to an agent
+  agent: one(agents, {
+    fields: [workflows.agentId],
+    references: [agents.id],
   }),
   // Example: A workflow can have many tasks
   tasks: many(tasks),

package/dist/{chunk-JTHQYGCX.js → chunk-4FMDWUE4.js}

@@ -1,4 +1,4 @@
-import { GraphWithinContextOfProjectSchema, resourceIdSchema, MAX_ID_LENGTH } from './chunk-E4SFK6AI.js';
+import { AgentWithinContextOfProjectSchema, resourceIdSchema, MAX_ID_LENGTH } from './chunk-VICWT3WO.js';
 import { z } from 'zod';
 
 var TransferDataSchema = z.object({
@@ -39,24 +39,24 @@ var A2AMessageMetadataSchema = z.object({
   a2aTaskId: z.string().optional().describe("A2A-specific task ID")
 });
 
-// src/validation/graphFull.ts
+// src/validation/agentFull.ts
 function isInternalAgent(agent) {
   return "prompt" in agent;
 }
 function isExternalAgent(agent) {
   return "baseUrl" in agent;
 }
-function validateAndTypeGraphData(data) {
-  return GraphWithinContextOfProjectSchema.parse(data);
+function validateAndTypeAgentData(data) {
+  return AgentWithinContextOfProjectSchema.parse(data);
 }
-function validateToolReferences(graphData, availableToolIds) {
+function validateToolReferences(agentData, availableToolIds) {
   if (!availableToolIds) {
     return;
   }
   const errors = [];
-  for (const [subAgentId, agentData] of Object.entries(graphData.subAgents)) {
-    if (isInternalAgent(agentData) && agentData.canUse && Array.isArray(agentData.canUse)) {
-      for (const canUseItem of agentData.canUse) {
+  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
+    if (isInternalAgent(subAgent) && subAgent.canUse && Array.isArray(subAgent.canUse)) {
+      for (const canUseItem of subAgent.canUse) {
         if (!availableToolIds.has(canUseItem.toolId)) {
           errors.push(`Agent '${subAgentId}' references non-existent tool '${canUseItem.toolId}'`);
         }
@@ -68,14 +68,14 @@ function validateToolReferences(graphData, availableToolIds) {
 ${errors.join("\n")}`);
   }
 }
-function validateDataComponentReferences(graphData, availableDataComponentIds) {
+function validateDataComponentReferences(agentData, availableDataComponentIds) {
   if (!availableDataComponentIds) {
     return;
   }
   const errors = [];
-  for (const [subAgentId, agentData] of Object.entries(graphData.subAgents)) {
-    if (isInternalAgent(agentData) && agentData.dataComponents) {
-      for (const dataComponentId of agentData.dataComponents) {
+  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
+    if (isInternalAgent(subAgent) && subAgent.dataComponents) {
+      for (const dataComponentId of subAgent.dataComponents) {
         if (!availableDataComponentIds.has(dataComponentId)) {
           errors.push(
             `Agent '${subAgentId}' references non-existent dataComponent '${dataComponentId}'`
@@ -89,14 +89,14 @@ function validateDataComponentReferences(graphData, availableDataComponentIds) {
 ${errors.join("\n")}`);
   }
 }
-function validateArtifactComponentReferences(graphData, availableArtifactComponentIds) {
+function validateArtifactComponentReferences(agentData, availableArtifactComponentIds) {
   if (!availableArtifactComponentIds) {
     return;
   }
   const errors = [];
-  for (const [subAgentId, agentData] of Object.entries(graphData.subAgents)) {
-    if (isInternalAgent(agentData) && agentData.artifactComponents) {
-      for (const artifactComponentId of agentData.artifactComponents) {
+  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
+    if (isInternalAgent(subAgent) && subAgent.artifactComponents) {
+      for (const artifactComponentId of subAgent.artifactComponents) {
         if (!availableArtifactComponentIds.has(artifactComponentId)) {
           errors.push(
             `Agent '${subAgentId}' references non-existent artifactComponent '${artifactComponentId}'`
@@ -110,25 +110,25 @@ function validateArtifactComponentReferences(graphData, availableArtifactCompone
 ${errors.join("\n")}`);
   }
 }
-function validateAgentRelationships(graphData) {
+function validateAgentRelationships(agentData) {
   const errors = [];
-  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) {
+  const availableAgentIds = new Set(Object.keys(agentData.subAgents));
+  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
+    if (isInternalAgent(subAgent)) {
+      if (subAgent.canTransferTo && Array.isArray(subAgent.canTransferTo)) {
+        for (const targetId of subAgent.canTransferTo) {
           if (!availableAgentIds.has(targetId)) {
             errors.push(
-              `Agent '${subAgentId}' has transfer target '${targetId}' that doesn't exist in graph`
+              `Agent '${subAgentId}' has transfer target '${targetId}' that doesn't exist in agent`
             );
           }
         }
       }
-      if (agentData.canDelegateTo && Array.isArray(agentData.canDelegateTo)) {
-        for (const targetId of agentData.canDelegateTo) {
+      if (subAgent.canDelegateTo && Array.isArray(subAgent.canDelegateTo)) {
+        for (const targetId of subAgent.canDelegateTo) {
           if (!availableAgentIds.has(targetId)) {
             errors.push(
-              `Agent '${subAgentId}' has delegation target '${targetId}' that doesn't exist in graph`
+              `Agent '${subAgentId}' has delegation target '${targetId}' that doesn't exist in agent`
             );
           }
         }
@@ -140,16 +140,16 @@ function validateAgentRelationships(graphData) {
 ${errors.join("\n")}`);
   }
 }
-function validateGraphStructure(graphData, projectResources) {
-  if (graphData.defaultSubAgentId && !graphData.subAgents[graphData.defaultSubAgentId]) {
-    throw new Error(`Default agent '${graphData.defaultSubAgentId}' does not exist in agents`);
+function validateAgentStructure(agentData, projectResources) {
+  if (agentData.defaultSubAgentId && !agentData.subAgents[agentData.defaultSubAgentId]) {
+    throw new Error(`Default agent '${agentData.defaultSubAgentId}' does not exist in agents`);
   }
   if (projectResources) {
-    validateToolReferences(graphData, projectResources.toolIds);
-    validateDataComponentReferences(graphData, projectResources.dataComponentIds);
-    validateArtifactComponentReferences(graphData, projectResources.artifactComponentIds);
+    validateToolReferences(agentData, projectResources.toolIds);
+    validateDataComponentReferences(agentData, projectResources.dataComponentIds);
+    validateArtifactComponentReferences(agentData, projectResources.artifactComponentIds);
   }
-  validateAgentRelationships(graphData);
+  validateAgentRelationships(agentData);
 }
 
 // src/validation/id-validation.ts
@@ -170,4 +170,4 @@ function generateIdFromName(name) {
   return truncatedId;
 }
 
-export { A2AMessageMetadataSchema, DataOperationDetailsSchema, DataOperationEventSchema, DelegationReturnedDataSchema, DelegationSentDataSchema, TransferDataSchema, generateIdFromName, isExternalAgent, isInternalAgent, isValidResourceId, validateAgentRelationships, validateAndTypeGraphData, validateArtifactComponentReferences, validateDataComponentReferences, validateGraphStructure, validateToolReferences };
+export { A2AMessageMetadataSchema, DataOperationDetailsSchema, DataOperationEventSchema, DelegationReturnedDataSchema, DelegationSentDataSchema, TransferDataSchema, generateIdFromName, isExternalAgent, isInternalAgent, isValidResourceId, validateAgentRelationships, validateAgentStructure, validateAndTypeAgentData, validateArtifactComponentReferences, validateDataComponentReferences, validateToolReferences };