@inkeep/agents-core 0.35.1 → 0.35.2

package/dist/utils/schema-conversion.cjs

@@ -1,232 +0,0 @@
-'use strict';
-
-var zod = require('zod');
-var pino = require('pino');
-var pinoPretty = require('pino-pretty');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var pino__default = /*#__PURE__*/_interopDefault(pino);
-var pinoPretty__default = /*#__PURE__*/_interopDefault(pinoPretty);
-
-// src/utils/schema-conversion.ts
-var PinoLogger = class {
-  constructor(name, config = {}) {
-    this.name = name;
-    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__default.default(this.options, pino__default.default.transport({ targets: this.transportConfigs }));
-    } else {
-      try {
-        const prettyStream = pinoPretty__default.default({
-          colorize: true,
-          translateTime: "HH:MM:ss",
-          ignore: "pid,hostname"
-        });
-        this.pinoInstance = pino__default.default(this.options, prettyStream);
-      } catch (error) {
-        console.warn("Warning: pino-pretty failed, using standard JSON output:", error);
-        this.pinoInstance = pino__default.default(this.options);
-      }
-    }
-  }
-  transportConfigs = [];
-  pinoInstance;
-  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__default.default({
-          colorize: true,
-          translateTime: "HH:MM:ss",
-          ignore: "pid,hostname"
-        });
-        this.pinoInstance = pino__default.default(this.options, prettyStream);
-      } catch (error) {
-        console.warn("Warning: pino-pretty failed, using standard JSON output:", error);
-        this.pinoInstance = pino__default.default(this.options);
-      }
-    } else {
-      const multiTransport = { targets: this.transportConfigs };
-      const pinoTransport = pino__default.default.transport(multiTransport);
-      this.pinoInstance = pino__default.default(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 {
-  config = {};
-  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 = zod.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 zod.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 zod.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;
-}
-
-exports.convertZodToJsonSchema = convertZodToJsonSchema;
-exports.convertZodToJsonSchemaWithPreview = convertZodToJsonSchemaWithPreview;
-exports.extractPreviewFields = extractPreviewFields;
-exports.isZodSchema = isZodSchema;
-exports.preview = preview;

package/dist/utils/schema-conversion.d.cts

@@ -1,26 +0,0 @@
-import { z } from 'zod';
-
-/**
- * Utility function for converting Zod schemas to JSON Schema
- * Uses Zod's built-in toJSONSchema method
- */
-declare function convertZodToJsonSchema(zodSchema: any): Record<string, unknown>;
-/**
- * Simple helper to mark a Zod schema field as a preview field
- * Adds metadata to the schema definition without modifying Zod's core
- */
-declare const preview: <T extends z.ZodTypeAny>(schema: T) => T;
-/**
- * Convert Zod schema to JSON Schema while preserving preview metadata
- */
-declare function convertZodToJsonSchemaWithPreview(zodSchema: z.ZodTypeAny): Record<string, unknown>;
-/**
- * Type guard to check if a value is a Zod schema
- */
-declare function isZodSchema(value: any): value is z.ZodObject<any>;
-/**
- * Extract preview fields from either JSON Schema or Zod schema
- */
-declare function extractPreviewFields(schema: any): string[];
-
-export { convertZodToJsonSchema, convertZodToJsonSchemaWithPreview, extractPreviewFields, isZodSchema, preview };