@inkeep/agents-core 0.0.0-chat-to-edit-20251119071712

package/dist/chunk-WG46C2WU.js

@@ -0,0 +1,394 @@
+import { AgentWithinContextOfProjectSchema, resourceIdSchema, MAX_ID_LENGTH } from './chunk-TLSKVSBR.js';
+import { z } from 'zod';
+
+// src/validation/cycleDetection.ts
+function detectDelegationCycles(agentData) {
+  const graph = buildDelegationGraph(agentData);
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const stack = /* @__PURE__ */ new Set();
+  const path = [];
+  function dfs(node) {
+    visited.add(node);
+    stack.add(node);
+    path.push(node);
+    for (const neighbor of graph.get(node) || []) {
+      if (!visited.has(neighbor)) {
+        if (dfs(neighbor)) return true;
+      } else if (stack.has(neighbor)) {
+        const cycleStart = path.indexOf(neighbor);
+        cycles.push(
+          `Circular delegation detected: ${[...path.slice(cycleStart), neighbor].join(" \u2192 ")}`
+        );
+        return true;
+      }
+    }
+    stack.delete(node);
+    path.pop();
+    return false;
+  }
+  for (const node of graph.keys()) {
+    if (!visited.has(node)) {
+      path.length = 0;
+      dfs(node);
+    }
+  }
+  return cycles;
+}
+function buildDelegationGraph(agentData) {
+  const graph = /* @__PURE__ */ new Map();
+  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
+    const delegates = subAgent.canDelegateTo?.filter((d) => typeof d === "string");
+    if (delegates?.length) {
+      graph.set(subAgentId, delegates);
+    }
+  }
+  return graph;
+}
+
+// src/validation/agentFull.ts
+function validateAndTypeAgentData(data) {
+  return AgentWithinContextOfProjectSchema.parse(data);
+}
+function validateToolReferences(agentData, availableToolIds) {
+  if (!availableToolIds) {
+    return;
+  }
+  const errors = [];
+  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
+    if (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}'`);
+        }
+      }
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(`Tool reference validation failed:
+${errors.join("\n")}`);
+  }
+}
+function validateDataComponentReferences(agentData, availableDataComponentIds) {
+  if (!availableDataComponentIds) {
+    return;
+  }
+  const errors = [];
+  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
+    if (subAgent.dataComponents) {
+      for (const dataComponentId of subAgent.dataComponents) {
+        if (!availableDataComponentIds.has(dataComponentId)) {
+          errors.push(
+            `Agent '${subAgentId}' references non-existent dataComponent '${dataComponentId}'`
+          );
+        }
+      }
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(`DataComponent reference validation failed:
+${errors.join("\n")}`);
+  }
+}
+function validateArtifactComponentReferences(agentData, availableArtifactComponentIds) {
+  if (!availableArtifactComponentIds) {
+    return;
+  }
+  const errors = [];
+  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
+    if (subAgent.artifactComponents) {
+      for (const artifactComponentId of subAgent.artifactComponents) {
+        if (!availableArtifactComponentIds.has(artifactComponentId)) {
+          errors.push(
+            `Agent '${subAgentId}' references non-existent artifactComponent '${artifactComponentId}'`
+          );
+        }
+      }
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(`ArtifactComponent reference validation failed:
+${errors.join("\n")}`);
+  }
+}
+function validateAgentRelationships(agentData) {
+  const errors = [];
+  const availableAgentIds = new Set(Object.keys(agentData.subAgents));
+  const availableExternalAgentIds = new Set(Object.keys(agentData.externalAgents ?? {}));
+  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
+    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 agent`
+          );
+        }
+      }
+    }
+    if (subAgent.canDelegateTo && Array.isArray(subAgent.canDelegateTo)) {
+      for (const targetItem of subAgent.canDelegateTo) {
+        console.log("targetItem", targetItem);
+        if (typeof targetItem === "string") {
+          console.log("targetItem is string", targetItem);
+          if (!availableAgentIds.has(targetItem) && !availableExternalAgentIds.has(targetItem)) {
+            errors.push(
+              `Agent '${subAgentId}' has delegation target '${targetItem}' that doesn't exist in agent`
+            );
+          }
+        }
+      }
+    }
+  }
+  const cycles = detectDelegationCycles(agentData);
+  if (cycles.length > 0) {
+    errors.push(...cycles);
+  }
+  if (errors.length > 0)
+    throw new Error(`Agent relationship validation failed:
+${errors.join("\n")}`);
+}
+function validateSubAgentExternalAgentRelations(agentData, availableExternalAgentIds) {
+  if (!availableExternalAgentIds) {
+    return;
+  }
+  const errors = [];
+  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
+    if (subAgent.canDelegateTo && Array.isArray(subAgent.canDelegateTo)) {
+      for (const targetItem of subAgent.canDelegateTo) {
+        if (typeof targetItem === "object" && "externalAgentId" in targetItem) {
+          if (!availableExternalAgentIds.has(targetItem.externalAgentId)) {
+            errors.push(
+              `Agent '${subAgentId}' has delegation target '${targetItem.externalAgentId}' that doesn't exist in agent`
+            );
+          }
+        }
+      }
+    }
+  }
+  if (errors.length > 0)
+    throw new Error(`Sub agent external agent relation validation failed:
+${errors.join("\n")}`);
+}
+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(agentData, projectResources.toolIds);
+    validateDataComponentReferences(agentData, projectResources.dataComponentIds);
+    validateArtifactComponentReferences(agentData, projectResources.artifactComponentIds);
+    validateSubAgentExternalAgentRelations(agentData, projectResources.externalAgentIds);
+  }
+  validateAgentRelationships(agentData);
+}
+var TransferDataSchema = z.object({
+  fromSubAgent: z.string().describe("ID of the sub-agent transferring control"),
+  targetSubAgent: z.string().describe("ID of the sub-agent receiving control"),
+  reason: z.string().optional().describe("Reason for the transfer"),
+  context: z.any().optional().describe("Additional context data")
+});
+var DelegationSentDataSchema = z.object({
+  delegationId: z.string().describe("Unique identifier for this delegation"),
+  fromSubAgent: z.string().describe("ID of the delegating sub-agent"),
+  targetSubAgent: z.string().describe("ID of the sub-agent receiving the delegation"),
+  taskDescription: z.string().describe("Description of the delegated task"),
+  context: z.any().optional().describe("Additional context data")
+});
+var DelegationReturnedDataSchema = z.object({
+  delegationId: z.string().describe("Unique identifier matching the original delegation"),
+  fromSubAgent: z.string().describe("ID of the sub-agent that completed the task"),
+  targetSubAgent: z.string().describe("ID of the sub-agent receiving the result"),
+  result: z.any().optional().describe("Result data from the delegated task")
+});
+var DataOperationDetailsSchema = z.object({
+  timestamp: z.number().describe("Unix timestamp in milliseconds"),
+  subAgentId: z.string().describe("ID of the sub-agent that generated this data"),
+  data: z.any().describe("The actual data payload")
+});
+var DataOperationEventSchema = z.object({
+  type: z.string().describe("Event type identifier"),
+  label: z.string().describe("Human-readable label for the event"),
+  details: DataOperationDetailsSchema
+});
+var A2AMessageMetadataSchema = z.object({
+  fromSubAgentId: z.string().optional().describe("ID of the sending sub-agent"),
+  toSubAgentId: z.string().optional().describe("ID of the receiving sub-agent"),
+  fromExternalAgentId: z.string().optional().describe("ID of the sending external agent"),
+  toExternalAgentId: z.string().optional().describe("ID of the receiving external agent"),
+  taskId: z.string().optional().describe("Associated task ID"),
+  a2aTaskId: z.string().optional().describe("A2A-specific task ID")
+});
+
+// src/validation/id-validation.ts
+function isValidResourceId(id) {
+  const result = resourceIdSchema.safeParse(id);
+  return result.success;
+}
+function generateIdFromName(name) {
+  const id = name.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+  if (!id) {
+    throw new Error("Cannot generate valid ID from provided name");
+  }
+  const truncatedId = id.substring(0, MAX_ID_LENGTH);
+  const result = resourceIdSchema.safeParse(truncatedId);
+  if (!result.success) {
+    throw new Error(`Generated ID "${truncatedId}" is not valid: ${result.error.message}`);
+  }
+  return truncatedId;
+}
+
+// src/validation/render-validation.ts
+var MAX_CODE_SIZE = 5e4;
+var MAX_DATA_SIZE = 1e4;
+var DANGEROUS_PATTERNS = [
+  {
+    pattern: /\beval\s*\(/i,
+    message: "eval() is not allowed"
+  },
+  {
+    pattern: /\bFunction\s*\(/i,
+    message: "Function constructor is not allowed"
+  },
+  {
+    pattern: /dangerouslySetInnerHTML/i,
+    message: "dangerouslySetInnerHTML is not allowed"
+  },
+  {
+    pattern: /<script\b/i,
+    message: "Script tags are not allowed"
+  },
+  {
+    pattern: /\bon\w+\s*=/i,
+    message: "Inline event handlers (onClick=, onLoad=, etc.) are not allowed"
+  },
+  {
+    pattern: /document\.write/i,
+    message: "document.write is not allowed"
+  },
+  {
+    pattern: /window\.location/i,
+    message: "window.location is not allowed"
+  },
+  {
+    pattern: /\.innerHTML\s*=/i,
+    message: "innerHTML manipulation is not allowed"
+  }
+];
+var ALLOWED_IMPORTS = ["lucide-react", "react"];
+function validateRender(render) {
+  const errors = [];
+  if (!render.component || typeof render.component !== "string") {
+    return {
+      isValid: false,
+      errors: [{ field: "render.component", message: "Component must be a non-empty string" }]
+    };
+  }
+  if (!render.mockData || typeof render.mockData !== "object") {
+    return {
+      isValid: false,
+      errors: [{ field: "render.mockData", message: "MockData must be an object" }]
+    };
+  }
+  if (render.component.length > MAX_CODE_SIZE) {
+    errors.push({
+      field: "render.component",
+      message: `Component size exceeds maximum allowed (${MAX_CODE_SIZE} characters)`
+    });
+  }
+  const dataString = JSON.stringify(render.mockData);
+  if (dataString.length > MAX_DATA_SIZE) {
+    errors.push({
+      field: "render.mockData",
+      message: `MockData size exceeds maximum allowed (${MAX_DATA_SIZE} characters)`
+    });
+  }
+  for (const { pattern, message } of DANGEROUS_PATTERNS) {
+    if (pattern.test(render.component)) {
+      errors.push({
+        field: "render.component",
+        message: `Component contains potentially dangerous pattern: ${message}`
+      });
+    }
+  }
+  const importMatches = render.component.matchAll(/import\s+.*?\s+from\s+['"]([^'"]+)['"]/g);
+  for (const match of importMatches) {
+    const importPath = match[1];
+    if (!ALLOWED_IMPORTS.includes(importPath) && !importPath.startsWith(".")) {
+      errors.push({
+        field: "render.component",
+        message: `Import from "${importPath}" is not allowed. Only imports from ${ALLOWED_IMPORTS.join(", ")} are permitted`
+      });
+    }
+  }
+  const hasFunctionDeclaration = /function\s+\w+\s*\(/.test(render.component);
+  if (!hasFunctionDeclaration) {
+    errors.push({
+      field: "render.component",
+      message: "Component must contain a function declaration"
+    });
+  }
+  const hasReturn = /return\s*\(?\s*</.test(render.component);
+  if (!hasReturn) {
+    errors.push({
+      field: "render.component",
+      message: "Component function must have a return statement with JSX"
+    });
+  }
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+var TextStartEventSchema = z.object({
+  type: z.literal("text-start"),
+  id: z.string()
+});
+var TextDeltaEventSchema = z.object({
+  type: z.literal("text-delta"),
+  id: z.string(),
+  delta: z.string()
+});
+var TextEndEventSchema = z.object({
+  type: z.literal("text-end"),
+  id: z.string()
+});
+var DataComponentStreamEventSchema = z.object({
+  type: z.literal("data-component"),
+  id: z.string(),
+  data: z.any()
+});
+var DataOperationStreamEventSchema = z.object({
+  type: z.literal("data-operation"),
+  data: z.any()
+  // Contains OperationEvent types (AgentInitializingEvent, CompletionEvent, etc.)
+});
+var DataSummaryStreamEventSchema = z.object({
+  type: z.literal("data-summary"),
+  data: z.any()
+  // Contains SummaryEvent from entities.ts
+});
+var StreamErrorEventSchema = z.object({
+  type: z.literal("error"),
+  error: z.string()
+});
+var StreamFinishEventSchema = z.object({
+  type: z.literal("finish"),
+  finishReason: z.string().optional(),
+  usage: z.object({
+    promptTokens: z.number().optional(),
+    completionTokens: z.number().optional(),
+    totalTokens: z.number().optional()
+  }).optional()
+});
+var StreamEventSchema = z.discriminatedUnion("type", [
+  TextStartEventSchema,
+  TextDeltaEventSchema,
+  TextEndEventSchema,
+  DataComponentStreamEventSchema,
+  DataOperationStreamEventSchema,
+  DataSummaryStreamEventSchema,
+  StreamErrorEventSchema,
+  StreamFinishEventSchema
+]);
+
+export { A2AMessageMetadataSchema, DataComponentStreamEventSchema, DataOperationDetailsSchema, DataOperationEventSchema, DataOperationStreamEventSchema, DataSummaryStreamEventSchema, DelegationReturnedDataSchema, DelegationSentDataSchema, StreamErrorEventSchema, StreamEventSchema, StreamFinishEventSchema, TextDeltaEventSchema, TextEndEventSchema, TextStartEventSchema, TransferDataSchema, generateIdFromName, isValidResourceId, validateAgentRelationships, validateAgentStructure, validateAndTypeAgentData, validateArtifactComponentReferences, validateDataComponentReferences, validateRender, validateSubAgentExternalAgentRelations, validateToolReferences };

package/dist/chunk-YECQCT5N.js

@@ -0,0 +1,223 @@
+import { __publicField } from './chunk-E6R6PML7.js';
+import { z } from 'zod';
+import pino from 'pino';
+import pinoPretty from 'pino-pretty';
+
+var PinoLogger = class {
+  constructor(name, config = {}) {
+    this.name = name;
+    __publicField(this, "transportConfigs", []);
+    __publicField(this, "pinoInstance");
+    __publicField(this, "options");
+    this.options = {
+      name: this.name,
+      level: process.env.LOG_LEVEL || (process.env.ENVIRONMENT === "test" ? "silent" : "info"),
+      serializers: {
+        obj: (value) => ({ ...value })
+      },
+      redact: ["req.headers.authorization", 'req.headers["x-inkeep-admin-authentication"]'],
+      ...config.options
+    };
+    if (config.transportConfigs) {
+      this.transportConfigs = config.transportConfigs;
+    }
+    if (this.transportConfigs.length > 0) {
+      this.pinoInstance = pino(this.options, pino.transport({ targets: this.transportConfigs }));
+    } else {
+      try {
+        const prettyStream = pinoPretty({
+          colorize: true,
+          translateTime: "HH:MM:ss",
+          ignore: "pid,hostname"
+        });
+        this.pinoInstance = pino(this.options, prettyStream);
+      } catch (error) {
+        console.warn("Warning: pino-pretty failed, using standard JSON output:", error);
+        this.pinoInstance = pino(this.options);
+      }
+    }
+  }
+  /**
+   * Recreate the pino instance with current transports
+   */
+  recreateInstance() {
+    if (this.pinoInstance && typeof this.pinoInstance.flush === "function") {
+      this.pinoInstance.flush();
+    }
+    if (this.transportConfigs.length === 0) {
+      try {
+        const prettyStream = pinoPretty({
+          colorize: true,
+          translateTime: "HH:MM:ss",
+          ignore: "pid,hostname"
+        });
+        this.pinoInstance = pino(this.options, prettyStream);
+      } catch (error) {
+        console.warn("Warning: pino-pretty failed, using standard JSON output:", error);
+        this.pinoInstance = pino(this.options);
+      }
+    } else {
+      const multiTransport = { targets: this.transportConfigs };
+      const pinoTransport = pino.transport(multiTransport);
+      this.pinoInstance = pino(this.options, pinoTransport);
+    }
+  }
+  /**
+   * Add a new transport to the logger
+   */
+  addTransport(transportConfig) {
+    this.transportConfigs.push(transportConfig);
+    this.recreateInstance();
+  }
+  /**
+   * Remove a transport by index
+   */
+  removeTransport(index) {
+    if (index >= 0 && index < this.transportConfigs.length) {
+      this.transportConfigs.splice(index, 1);
+      this.recreateInstance();
+    }
+  }
+  /**
+   * Get current transports
+   */
+  getTransports() {
+    return [...this.transportConfigs];
+  }
+  /**
+   * Update logger options
+   */
+  updateOptions(options) {
+    this.options = {
+      ...this.options,
+      ...options
+    };
+    this.recreateInstance();
+  }
+  /**
+   * Get the underlying pino instance for advanced usage
+   */
+  getPinoInstance() {
+    return this.pinoInstance;
+  }
+  error(data, message) {
+    this.pinoInstance.error(data, message);
+  }
+  warn(data, message) {
+    this.pinoInstance.warn(data, message);
+  }
+  info(data, message) {
+    this.pinoInstance.info(data, message);
+  }
+  debug(data, message) {
+    this.pinoInstance.debug(data, message);
+  }
+};
+var LoggerFactory = class {
+  constructor() {
+    __publicField(this, "config", {});
+    __publicField(this, "loggers", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Configure the logger factory
+   */
+  configure(config) {
+    this.config = config;
+    this.loggers.clear();
+  }
+  /**
+   * Get or create a logger instance
+   */
+  getLogger(name) {
+    if (this.loggers.has(name)) {
+      const logger3 = this.loggers.get(name);
+      if (!logger3) {
+        throw new Error(`Logger '${name}' not found in cache`);
+      }
+      return logger3;
+    }
+    let logger2;
+    if (this.config.loggerFactory) {
+      logger2 = this.config.loggerFactory(name);
+    } else if (this.config.defaultLogger) {
+      logger2 = this.config.defaultLogger;
+    } else {
+      logger2 = new PinoLogger(name, this.config.pinoConfig);
+    }
+    this.loggers.set(name, logger2);
+    return logger2;
+  }
+  /**
+   * Reset factory to default state
+   */
+  reset() {
+    this.config = {};
+    this.loggers.clear();
+  }
+};
+var loggerFactory = new LoggerFactory();
+function getLogger(name) {
+  return loggerFactory.getLogger(name);
+}
+
+// src/utils/schema-conversion.ts
+var logger = getLogger("schema-conversion");
+function convertZodToJsonSchema(zodSchema) {
+  try {
+    const jsonSchema = z.toJSONSchema(zodSchema);
+    if (jsonSchema.$schema) {
+      delete jsonSchema.$schema;
+    }
+    return jsonSchema;
+  } catch (error) {
+    logger.error(
+      {
+        error: error instanceof Error ? error.message : "Unknown error",
+        stack: error instanceof Error ? error.stack : void 0
+      },
+      "Failed to convert Zod schema to JSON Schema"
+    );
+    throw new Error("Failed to convert Zod schema to JSON Schema");
+  }
+}
+var preview = (schema) => {
+  schema._def.inPreview = true;
+  return schema;
+};
+function convertZodToJsonSchemaWithPreview(zodSchema) {
+  const jsonSchema = convertZodToJsonSchema(zodSchema);
+  if (zodSchema instanceof z.ZodObject && jsonSchema.properties) {
+    const shape = zodSchema.shape;
+    for (const [key, fieldSchema] of Object.entries(shape)) {
+      if (fieldSchema?._def?.inPreview === true) {
+        jsonSchema.properties[key].inPreview = true;
+      }
+    }
+  }
+  return jsonSchema;
+}
+function isZodSchema(value) {
+  return value?._def?.type === "object";
+}
+function extractPreviewFields(schema) {
+  const previewFields = [];
+  if (schema instanceof z.ZodObject) {
+    const shape = schema.shape;
+    for (const [key, fieldSchema] of Object.entries(shape)) {
+      if (fieldSchema?._def?.inPreview === true) {
+        previewFields.push(key);
+      }
+    }
+    return previewFields;
+  }
+  if (schema?.type === "object" && schema.properties) {
+    for (const [key, prop] of Object.entries(schema.properties)) {
+      if (prop.inPreview === true) {
+        previewFields.push(key);
+      }
+    }
+  }
+  return previewFields;
+}
+
+export { PinoLogger, convertZodToJsonSchema, convertZodToJsonSchemaWithPreview, extractPreviewFields, getLogger, isZodSchema, loggerFactory, preview };

package/dist/chunk-YFHT5M2R.js

@@ -0,0 +1,18 @@
+// src/types/utility.ts
+var TOOL_STATUS_VALUES = ["healthy", "unhealthy", "unknown", "needs_auth"];
+var VALID_RELATION_TYPES = ["transfer", "delegate"];
+var MCPTransportType = {
+  streamableHttp: "streamable_http",
+  sse: "sse"
+};
+var MCPServerType = {
+  nango: "nango",
+  generic: "generic"
+};
+var CredentialStoreType = {
+  memory: "memory",
+  keychain: "keychain",
+  nango: "nango"
+};
+
+export { CredentialStoreType, MCPServerType, MCPTransportType, TOOL_STATUS_VALUES, VALID_RELATION_TYPES };