@aigne/core 1.73.0-beta → 1.74.0-beta

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

@@ -0,0 +1,20 @@
+import { Message } from "../agents/agent.cjs";
+import { ZodType, z } from "zod";
+
+//#region src/utils/json-schema.d.ts
+declare function outputSchemaToResponseFormatSchema(agentOutput: ZodType<Message>): Record<string, unknown>;
+declare function parseJSON(json: string): any;
+/**
+ * Ensure that the union array has at least 1 item.
+ * NOTE: the zod union requires at least 2 items (just type definition, not runtime behavior)
+ * so we need to ensure that the union has at least 1 item.
+ * @param union - The union array
+ * @returns The union array with at least 1 item (but the type is at least 2 items for z.union)
+ */
+declare function ensureZodUnionArray<T extends z.ZodType>(union: T[]): [T, T, ...T[]];
+declare function isZodSchema(schema: ZodType): schema is ZodType;
+declare const wrapAutoParseJsonSchema: <T extends ZodType>(schema: T) => T;
+declare function getZodObjectKeys(schema: ZodType): string[];
+//#endregion
+export { ensureZodUnionArray, getZodObjectKeys, isZodSchema, outputSchemaToResponseFormatSchema, parseJSON, wrapAutoParseJsonSchema };
+//# sourceMappingURL=json-schema.d.cts.map

package/dist/utils/json-schema.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.d.cts","names":[],"sources":["../../src/utils/json-schema.ts"],"mappings":";;;;iBAOgB,kCAAA,CAAA,WAAA,EACD,OAAA,CAAQ,OAAA,IACpB,MAAA;AAAA,iBAyBa,SAAA,CAAA,IAAA;AAAA;AAgBhB;;;;;;AAhBgB,iBAgBA,mBAAA,WAA8B,CAAA,CAAE,OAAA,CAAA,CAAA,KAAA,EAAgB,CAAA,MAAO,CAAA,EAAG,CAAA,KAAM,CAAA;AAAA,iBAOhE,WAAA,CAAA,MAAA,EAAoB,OAAA,GAAA,MAAA,IAAoB,OAAA;AAAA,cA4D3C,uBAAA,aAAqC,OAAA,EAAA,MAAA,EAAiB,CAAA,KAAI,CAAA;AAAA,iBAuBvD,gBAAA,CAAA,MAAA,EAAyB,OAAA"}

package/dist/utils/json-schema.d.mts

@@ -0,0 +1,20 @@
+import { Message } from "../agents/agent.mjs";
+import { ZodType, z as z$1 } from "zod";
+
+//#region src/utils/json-schema.d.ts
+declare function outputSchemaToResponseFormatSchema(agentOutput: ZodType<Message>): Record<string, unknown>;
+declare function parseJSON(json: string): any;
+/**
+ * Ensure that the union array has at least 1 item.
+ * NOTE: the zod union requires at least 2 items (just type definition, not runtime behavior)
+ * so we need to ensure that the union has at least 1 item.
+ * @param union - The union array
+ * @returns The union array with at least 1 item (but the type is at least 2 items for z.union)
+ */
+declare function ensureZodUnionArray<T extends z$1.ZodType>(union: T[]): [T, T, ...T[]];
+declare function isZodSchema(schema: ZodType): schema is ZodType;
+declare const wrapAutoParseJsonSchema: <T extends ZodType>(schema: T) => T;
+declare function getZodObjectKeys(schema: ZodType): string[];
+//#endregion
+export { ensureZodUnionArray, getZodObjectKeys, isZodSchema, outputSchemaToResponseFormatSchema, parseJSON, wrapAutoParseJsonSchema };
+//# sourceMappingURL=json-schema.d.mts.map

package/dist/utils/json-schema.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.d.mts","names":[],"sources":["../../src/utils/json-schema.ts"],"mappings":";;;;iBAOgB,kCAAA,CAAA,WAAA,EACD,OAAA,CAAQ,OAAA,IACpB,MAAA;AAAA,iBAyBa,SAAA,CAAA,IAAA;AAAA;AAgBhB;;;;;;AAhBgB,iBAgBA,mBAAA,WAA8B,GAAA,CAAE,OAAA,CAAA,CAAA,KAAA,EAAgB,CAAA,MAAO,CAAA,EAAG,CAAA,KAAM,CAAA;AAAA,iBAOhE,WAAA,CAAA,MAAA,EAAoB,OAAA,GAAA,MAAA,IAAoB,OAAA;AAAA,cA4D3C,uBAAA,aAAqC,OAAA,EAAA,MAAA,EAAiB,CAAA,KAAI,CAAA;AAAA,iBAuBvD,gBAAA,CAAA,MAAA,EAAyB,OAAA"}

package/dist/utils/json-schema.mjs

@@ -0,0 +1,102 @@
+import { safeParseJSON } from "./json-utils.mjs";
+import { logger } from "./logger.mjs";
+import { isEmpty, isRecord } from "./type-utils.mjs";
+import { z as z$1 } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+//#region src/utils/json-schema.ts
+function outputSchemaToResponseFormatSchema(agentOutput) {
+	return convertNullableToOptional(setAdditionPropertiesDeep(zodToJsonSchema(agentOutput), false))[0];
+}
+function setAdditionPropertiesDeep(schema, additionalProperties) {
+	if (Array.isArray(schema)) return schema.map((s) => setAdditionPropertiesDeep(s, additionalProperties));
+	if (schema !== null && typeof schema === "object" && !Array.isArray(schema)) return Object.entries(schema).reduce((acc, [key, value]) => {
+		acc[key] = setAdditionPropertiesDeep(value, additionalProperties);
+		if (acc.type === "object") acc.additionalProperties = additionalProperties;
+		return acc;
+	}, {});
+	return schema;
+}
+function parseJSON(json) {
+	try {
+		return JSON.parse(json);
+	} catch (error) {
+		logger.error("Failed to parse JSON", {
+			json,
+			error
+		});
+		throw error;
+	}
+}
+/**
+* Ensure that the union array has at least 1 item.
+* NOTE: the zod union requires at least 2 items (just type definition, not runtime behavior)
+* so we need to ensure that the union has at least 1 item.
+* @param union - The union array
+* @returns The union array with at least 1 item (but the type is at least 2 items for z.union)
+*/
+function ensureZodUnionArray(union) {
+	if (!(union.length >= 1)) throw new Error(`Union must have at least 1 item, but got ${union.length}`);
+	return union;
+}
+function isZodSchema(schema) {
+	if (!schema || typeof schema !== "object") return false;
+	return typeof schema.parse === "function" && typeof schema.safeParse === "function";
+}
+function convertNullableToOptional(schema) {
+	if (!isRecord(schema)) return [schema, false];
+	if (schema.type === "object" && "properties" in schema && isRecord(schema.properties)) {
+		const optionalProperties = [];
+		const properties = Object.fromEntries(Object.entries(schema.properties).map(([key, value]) => {
+			const [property, optional$1] = convertNullableToOptional(value);
+			if (optional$1) optionalProperties.push(key);
+			return [key, property];
+		}));
+		const required = ("required" in schema && Array.isArray(schema.required) ? schema.required : []).filter((key) => !optionalProperties.includes(key));
+		return [{
+			...schema,
+			properties,
+			required
+		}, false];
+	}
+	if (schema.type === "array" && "items" in schema && isRecord(schema.items)) {
+		const [items, _] = convertNullableToOptional(schema.items);
+		return [{
+			...schema,
+			items
+		}, false];
+	}
+	if (Array.isArray(schema.type)) {
+		if (schema.type.includes("null") && schema.type.length === 2) return [{
+			...schema,
+			type: schema.type.filter((t) => t !== "null")[0]
+		}, true];
+	}
+	if (Array.isArray(schema.anyOf)) {
+		const anyOf = schema.anyOf.filter((i) => isRecord(i) && i.type !== "null" && !("not" in i && isEmpty(i.not)));
+		const optional$1 = anyOf.length !== schema.anyOf.length;
+		if (anyOf.length === 1) return [convertNullableToOptional(anyOf[0])[0], optional$1];
+	}
+	return [schema, false];
+}
+const wrapJsonParse = (schema) => {
+	return z$1.preprocess((val) => typeof val === "string" ? safeParseJSON(val) : val, schema);
+};
+const wrapAutoParseJsonSchema = (schema) => {
+	if (schema instanceof z$1.ZodNullable) return z$1.nullable(wrapAutoParseJsonSchema(schema._def.innerType));
+	if (schema instanceof z$1.ZodOptional) return z$1.optional(wrapAutoParseJsonSchema(schema._def.innerType));
+	if (schema instanceof z$1.ZodObject) return wrapJsonParse(schema.extend(Object.fromEntries(Object.entries(schema.shape).map(([key, value]) => [key, wrapAutoParseJsonSchema(value)]))));
+	if (schema instanceof z$1.ZodArray) {
+		schema._def.type = wrapAutoParseJsonSchema(schema._def.type);
+		return wrapJsonParse(schema);
+	}
+	return schema;
+};
+function getZodObjectKeys(schema) {
+	if ("shape" in schema && schema.shape) return Object.keys(schema.shape);
+	return [];
+}
+
+//#endregion
+export { ensureZodUnionArray, getZodObjectKeys, isZodSchema, outputSchemaToResponseFormatSchema, parseJSON, wrapAutoParseJsonSchema };
+//# sourceMappingURL=json-schema.mjs.map

package/dist/utils/json-schema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.mjs","names":["optional","z"],"sources":["../../src/utils/json-schema.ts"],"sourcesContent":["import { type ZodType, z } from \"zod\";\nimport { zodToJsonSchema } from \"zod-to-json-schema\";\nimport type { Message } from \"../agents/agent.js\";\nimport { safeParseJSON } from \"./json-utils.js\";\nimport { logger } from \"./logger.js\";\nimport { isEmpty, isRecord } from \"./type-utils.js\";\n\nexport function outputSchemaToResponseFormatSchema(\n  agentOutput: ZodType<Message>,\n): Record<string, unknown> {\n  return convertNullableToOptional(\n    setAdditionPropertiesDeep(zodToJsonSchema(agentOutput), false),\n  )[0];\n}\n\nfunction setAdditionPropertiesDeep<T>(schema: T, additionalProperties: boolean): T {\n  if (Array.isArray(schema)) {\n    return schema.map((s) => setAdditionPropertiesDeep(s, additionalProperties)) as T;\n  }\n  if (schema !== null && typeof schema === \"object\" && !Array.isArray(schema)) {\n    return Object.entries(schema).reduce(\n      (acc, [key, value]) => {\n        acc[key] = setAdditionPropertiesDeep(value, additionalProperties);\n        if (acc.type === \"object\") {\n          acc.additionalProperties = additionalProperties;\n        }\n        return acc;\n      },\n      {} as Record<string, unknown>,\n    ) as T;\n  }\n  return schema;\n}\n\nexport function parseJSON(json: string) {\n  try {\n    return JSON.parse(json);\n  } catch (error) {\n    logger.error(\"Failed to parse JSON\", { json, error });\n    throw error;\n  }\n}\n\n/**\n * Ensure that the union array has at least 1 item.\n * NOTE: the zod union requires at least 2 items (just type definition, not runtime behavior)\n * so we need to ensure that the union has at least 1 item.\n * @param union - The union array\n * @returns The union array with at least 1 item (but the type is at least 2 items for z.union)\n */\nexport function ensureZodUnionArray<T extends z.ZodType>(union: T[]): [T, T, ...T[]] {\n  if (!(union.length >= 1)) {\n    throw new Error(`Union must have at least 1 item, but got ${union.length}`);\n  }\n  return union as [T, T, ...T[]];\n}\n\nexport function isZodSchema(schema: ZodType): schema is ZodType {\n  if (!schema || typeof schema !== \"object\") return false;\n  return typeof schema.parse === \"function\" && typeof schema.safeParse === \"function\";\n}\n\nfunction convertNullableToOptional(schema: any): [typeof schema, boolean] {\n  if (!isRecord(schema)) return [schema, false];\n\n  if (schema.type === \"object\" && \"properties\" in schema && isRecord(schema.properties)) {\n    const optionalProperties: string[] = [];\n\n    const properties = Object.fromEntries(\n      Object.entries(schema.properties).map(([key, value]) => {\n        const [property, optional] = convertNullableToOptional(value);\n        if (optional) optionalProperties.push(key);\n        return [key, property];\n      }),\n    );\n    const currentRequired =\n      \"required\" in schema && Array.isArray(schema.required) ? schema.required : [];\n    const required = currentRequired.filter((key) => !optionalProperties.includes(key));\n\n    return [{ ...schema, properties, required }, false];\n  }\n\n  if (schema.type === \"array\" && \"items\" in schema && isRecord(schema.items)) {\n    const [items, _] = convertNullableToOptional(schema.items);\n    return [{ ...schema, items }, false];\n  }\n\n  if (Array.isArray(schema.type)) {\n    if (schema.type.includes(\"null\") && schema.type.length === 2) {\n      return [\n        {\n          ...schema,\n          type: schema.type.filter((t) => t !== \"null\")[0],\n        },\n        true,\n      ];\n    }\n  }\n\n  if (Array.isArray(schema.anyOf)) {\n    const anyOf = schema.anyOf.filter(\n      (i) => isRecord(i) && i.type !== \"null\" && !(\"not\" in i && isEmpty(i.not)),\n    );\n    const optional = anyOf.length !== schema.anyOf.length;\n    if (anyOf.length === 1) return [convertNullableToOptional(anyOf[0])[0], optional];\n  }\n\n  return [schema, false];\n}\n\nconst wrapJsonParse = <T extends ZodType>(schema: T): T => {\n  return z.preprocess(\n    (val) => (typeof val === \"string\" ? safeParseJSON(val) : val),\n    schema,\n  ) as unknown as T;\n};\n\nexport const wrapAutoParseJsonSchema = <T extends ZodType>(schema: T): T => {\n  if (schema instanceof z.ZodNullable)\n    return z.nullable(wrapAutoParseJsonSchema(schema._def.innerType)) as unknown as T;\n  if (schema instanceof z.ZodOptional)\n    return z.optional(wrapAutoParseJsonSchema(schema._def.innerType)) as unknown as T;\n  if (schema instanceof z.ZodObject) {\n    const newSchema = schema.extend(\n      Object.fromEntries(\n        Object.entries(schema.shape).map(([key, value]: any) => [\n          key,\n          wrapAutoParseJsonSchema(value),\n        ]),\n      ),\n    );\n    return wrapJsonParse(newSchema) as unknown as T;\n  }\n  if (schema instanceof z.ZodArray) {\n    schema._def.type = wrapAutoParseJsonSchema(schema._def.type);\n    return wrapJsonParse(schema) as unknown as T;\n  }\n  return schema;\n};\n\nexport function getZodObjectKeys(schema: ZodType): string[] {\n  if (\"shape\" in schema && schema.shape) return Object.keys(schema.shape);\n  return [];\n}\n"],"mappings":"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"}

package/dist/utils/json-utils.cjs

@@ -0,0 +1,46 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let jaison = require("jaison");
+jaison = require_rolldown_runtime.__toESM(jaison);
+
+//#region src/utils/json-utils.ts
+/**
+* Safely parses JSON text using jaison library which handles malformed JSON better than JSON.parse
+*
+* @param text - The text to parse as JSON
+* @returns Parsed JSON object or null if parsing fails
+*
+* @example
+* ```typescript
+* const result = safeParseJSON('{"key": "value"}');
+* console.log(result); // { key: "value" }
+*
+* const malformed = safeParseJSON('{"key": "value"'); // Missing closing brace
+* console.log(malformed); // null
+* ```
+*/
+function safeParseJSON(text) {
+	if (!text) return null;
+	try {
+		return (0, jaison.default)(text);
+	} catch {
+		return null;
+	}
+}
+/**
+* Safely stringifies a value to JSON, handling errors gracefully
+*
+* @param value - The value to stringify
+* @param space - Optional spacing for pretty printing
+* @returns JSON string or null if stringification fails
+*/
+function safeStringifyJSON(value, space) {
+	try {
+		return JSON.stringify(value, null, space);
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+exports.safeParseJSON = safeParseJSON;
+exports.safeStringifyJSON = safeStringifyJSON;

package/dist/utils/json-utils.d.cts

@@ -0,0 +1,28 @@
+//#region src/utils/json-utils.d.ts
+/**
+ * Safely parses JSON text using jaison library which handles malformed JSON better than JSON.parse
+ *
+ * @param text - The text to parse as JSON
+ * @returns Parsed JSON object or null if parsing fails
+ *
+ * @example
+ * ```typescript
+ * const result = safeParseJSON('{"key": "value"}');
+ * console.log(result); // { key: "value" }
+ *
+ * const malformed = safeParseJSON('{"key": "value"'); // Missing closing brace
+ * console.log(malformed); // null
+ * ```
+ */
+declare function safeParseJSON(text: string): any;
+/**
+ * Safely stringifies a value to JSON, handling errors gracefully
+ *
+ * @param value - The value to stringify
+ * @param space - Optional spacing for pretty printing
+ * @returns JSON string or null if stringification fails
+ */
+declare function safeStringifyJSON(value: any, space?: number): string | null;
+//#endregion
+export { safeParseJSON, safeStringifyJSON };
+//# sourceMappingURL=json-utils.d.cts.map

package/dist/utils/json-utils.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-utils.d.cts","names":[],"sources":["../../src/utils/json-utils.ts"],"mappings":";;AAiBA;AAiBA;;;;;;;;;;;;;iBAjBgB,aAAA,CAAA,IAAA;AAAA;AAiBhB;;;;;;AAjBgB,iBAiBA,iBAAA,CAAA,KAAA,OAAA,KAAA"}

package/dist/utils/json-utils.d.mts

@@ -0,0 +1,28 @@
+//#region src/utils/json-utils.d.ts
+/**
+ * Safely parses JSON text using jaison library which handles malformed JSON better than JSON.parse
+ *
+ * @param text - The text to parse as JSON
+ * @returns Parsed JSON object or null if parsing fails
+ *
+ * @example
+ * ```typescript
+ * const result = safeParseJSON('{"key": "value"}');
+ * console.log(result); // { key: "value" }
+ *
+ * const malformed = safeParseJSON('{"key": "value"'); // Missing closing brace
+ * console.log(malformed); // null
+ * ```
+ */
+declare function safeParseJSON(text: string): any;
+/**
+ * Safely stringifies a value to JSON, handling errors gracefully
+ *
+ * @param value - The value to stringify
+ * @param space - Optional spacing for pretty printing
+ * @returns JSON string or null if stringification fails
+ */
+declare function safeStringifyJSON(value: any, space?: number): string | null;
+//#endregion
+export { safeParseJSON, safeStringifyJSON };
+//# sourceMappingURL=json-utils.d.mts.map

package/dist/utils/json-utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-utils.d.mts","names":[],"sources":["../../src/utils/json-utils.ts"],"mappings":";;AAiBA;AAiBA;;;;;;;;;;;;;iBAjBgB,aAAA,CAAA,IAAA;AAAA;AAiBhB;;;;;;AAjBgB,iBAiBA,iBAAA,CAAA,KAAA,OAAA,KAAA"}

package/dist/utils/json-utils.mjs

@@ -0,0 +1,44 @@
+import jaison from "jaison";
+
+//#region src/utils/json-utils.ts
+/**
+* Safely parses JSON text using jaison library which handles malformed JSON better than JSON.parse
+*
+* @param text - The text to parse as JSON
+* @returns Parsed JSON object or null if parsing fails
+*
+* @example
+* ```typescript
+* const result = safeParseJSON('{"key": "value"}');
+* console.log(result); // { key: "value" }
+*
+* const malformed = safeParseJSON('{"key": "value"'); // Missing closing brace
+* console.log(malformed); // null
+* ```
+*/
+function safeParseJSON(text) {
+	if (!text) return null;
+	try {
+		return jaison(text);
+	} catch {
+		return null;
+	}
+}
+/**
+* Safely stringifies a value to JSON, handling errors gracefully
+*
+* @param value - The value to stringify
+* @param space - Optional spacing for pretty printing
+* @returns JSON string or null if stringification fails
+*/
+function safeStringifyJSON(value, space) {
+	try {
+		return JSON.stringify(value, null, space);
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+export { safeParseJSON, safeStringifyJSON };
+//# sourceMappingURL=json-utils.mjs.map

package/dist/utils/json-utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-utils.mjs","names":[],"sources":["../../src/utils/json-utils.ts"],"sourcesContent":["import jaison from \"jaison\";\n\n/**\n * Safely parses JSON text using jaison library which handles malformed JSON better than JSON.parse\n *\n * @param text - The text to parse as JSON\n * @returns Parsed JSON object or null if parsing fails\n *\n * @example\n * ```typescript\n * const result = safeParseJSON('{\"key\": \"value\"}');\n * console.log(result); // { key: \"value\" }\n *\n * const malformed = safeParseJSON('{\"key\": \"value\"'); // Missing closing brace\n * console.log(malformed); // null\n * ```\n */\nexport function safeParseJSON(text: string): any {\n  if (!text) return null;\n\n  try {\n    return jaison(text);\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Safely stringifies a value to JSON, handling errors gracefully\n *\n * @param value - The value to stringify\n * @param space - Optional spacing for pretty printing\n * @returns JSON string or null if stringification fails\n */\nexport function safeStringifyJSON(value: any, space?: number): string | null {\n  try {\n    return JSON.stringify(value, null, space);\n  } catch {\n    return null;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiBA,SAAgB,cAAc,MAAmB;AAC/C,KAAI,CAAC,KAAM,QAAO;AAElB,KAAI;AACF,SAAO,OAAO,KAAK;SACb;AACN,SAAO;;;;;;;;;;AAWX,SAAgB,kBAAkB,OAAY,OAA+B;AAC3E,KAAI;AACF,SAAO,KAAK,UAAU,OAAO,MAAM,MAAM;SACnC;AACN,SAAO"}

package/dist/utils/logger.cjs

@@ -0,0 +1,72 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let _aigne_utils_nodejs = require("@aigne/utils/nodejs");
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+
+//#region src/utils/logger.ts
+let LogLevel = /* @__PURE__ */ function(LogLevel) {
+	LogLevel["SILENT"] = "silent";
+	LogLevel["ERROR"] = "error";
+	LogLevel["WARN"] = "warn";
+	LogLevel["INFO"] = "info";
+	LogLevel["DEBUG"] = "debug";
+	return LogLevel;
+}({});
+const levels = Object.values(LogLevel);
+function getLevelFromEnv(ns) {
+	for (const level of [...levels].reverse()) if (debug.default.enabled(`${ns}:${level}`)) return level;
+}
+var Logger = class {
+	constructor(options) {
+		this.options = options;
+		this.debugLogger = (0, debug.default)(`${options.ns}:${LogLevel.DEBUG}`);
+		this.infoLogger = (0, debug.default)(`${options.ns}:${LogLevel.INFO}`);
+		this.warnLogger = (0, debug.default)(`${options.ns}:${LogLevel.WARN}`);
+		this.errorLogger = (0, debug.default)(`${options.ns}:${LogLevel.ERROR}`);
+		this.level = getLevelFromEnv(options.ns) || options.level;
+		for (const logger of [
+			this.debugLogger,
+			this.infoLogger,
+			this.warnLogger
+		]) {
+			logger.useColors = _aigne_utils_nodejs.nodejs.isStdoutATTY;
+			logger.enabled = true;
+			logger.log = (...args) => this.logMessage(...args);
+		}
+		this.errorLogger.log = (...args) => this.logError(...args);
+		this.errorLogger.useColors = _aigne_utils_nodejs.nodejs.isStderrATTY;
+		this.errorLogger.enabled = true;
+	}
+	level;
+	debugLogger;
+	infoLogger;
+	warnLogger;
+	errorLogger;
+	logMessage = console.log;
+	logError = console.error;
+	debug(message, ...args) {
+		if (this.enabled(LogLevel.DEBUG)) this.debugLogger(message, ...args);
+	}
+	info(message, ...args) {
+		if (this.enabled(LogLevel.INFO)) this.infoLogger(message, ...args);
+	}
+	warn(message, ...args) {
+		if (this.enabled(LogLevel.WARN)) this.warnLogger(message, ...args);
+	}
+	error(message, ...args) {
+		if (this.enabled(LogLevel.ERROR)) this.errorLogger(message, ...args);
+	}
+	enabled(level) {
+		return levels.indexOf(this.level) >= levels.indexOf(level);
+	}
+};
+const logger = new Logger({
+	ns: "aigne:core",
+	level: LogLevel.SILENT
+});
+
+//#endregion
+exports.LogLevel = LogLevel;
+exports.Logger = Logger;
+exports.getLevelFromEnv = getLevelFromEnv;
+exports.logger = logger;

package/dist/utils/logger.d.cts

@@ -0,0 +1,41 @@
+//#region src/utils/logger.d.ts
+declare enum LogLevel {
+  SILENT = "silent",
+  ERROR = "error",
+  WARN = "warn",
+  INFO = "info",
+  DEBUG = "debug",
+}
+declare function getLevelFromEnv(ns: string): LogLevel | undefined;
+declare class Logger {
+  options: {
+    level: LogLevel;
+    ns: string;
+  };
+  constructor(options: {
+    level: LogLevel;
+    ns: string;
+  });
+  level: LogLevel;
+  private debugLogger;
+  private infoLogger;
+  private warnLogger;
+  private errorLogger;
+  logMessage: {
+    (...data: any[]): void;
+    (...data: any[]): void;
+  };
+  logError: {
+    (...data: any[]): void;
+    (...data: any[]): void;
+  };
+  debug(message: string, ...args: unknown[]): void;
+  info(message: string, ...args: unknown[]): void;
+  warn(message: string, ...args: unknown[]): void;
+  error(message: string, ...args: unknown[]): void;
+  enabled(level: LogLevel): boolean;
+}
+declare const logger: Logger;
+//#endregion
+export { LogLevel, Logger, getLevelFromEnv, logger };
+//# sourceMappingURL=logger.d.cts.map

package/dist/utils/logger.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.cts","names":[],"sources":["../../src/utils/logger.ts"],"mappings":";aAGY,QAAA;EAAA,MAAA;EAAA,KAAA;EAAA,IAAA;EAAA,IAAA;EAAA,KAAA;AAAA;AAAA,iBAUI,eAAA,CAAA,EAAA,WAA6B,QAAA;AAAA,cAQhC,MAAA;EAAA,OAAA;IAAA,KAAA,EAC0B,QAAA;IAAA,EAAA;EAAA;EAAA,YAAA,OAAA;IAAA,KAAA,EAAA,QAAA;IAAA,EAAA;EAAA;EAAA,KAAA,EAqB9B,QAAA;EAAA,QAAA,WAAA;EAAA,QAAA,UAAA;EAAA,QAAA,UAAA;EAAA,QAAA,WAAA;EAAA,UAAA;IAAA,IAAA,IAAA;IAAA,IAAA,IAAA;EAAA;EAAA,QAAA;IAAA,IAAA,IAAA;IAAA,IAAA,IAAA;EAAA;EAAA,MAAA,OAAA,aAAA,IAAA;EAAA,KAAA,OAAA,aAAA,IAAA;EAAA,KAAA,OAAA,aAAA,IAAA;EAAA,MAAA,OAAA,aAAA,IAAA;EAAA,QAAA,KAAA,EAsCQ,QAAA;AAAA;AAAA,cAKJ,MAAA,EAAM,MAAA"}

package/dist/utils/logger.d.mts

@@ -0,0 +1,41 @@
+//#region src/utils/logger.d.ts
+declare enum LogLevel {
+  SILENT = "silent",
+  ERROR = "error",
+  WARN = "warn",
+  INFO = "info",
+  DEBUG = "debug",
+}
+declare function getLevelFromEnv(ns: string): LogLevel | undefined;
+declare class Logger {
+  options: {
+    level: LogLevel;
+    ns: string;
+  };
+  constructor(options: {
+    level: LogLevel;
+    ns: string;
+  });
+  level: LogLevel;
+  private debugLogger;
+  private infoLogger;
+  private warnLogger;
+  private errorLogger;
+  logMessage: {
+    (...data: any[]): void;
+    (...data: any[]): void;
+  };
+  logError: {
+    (...data: any[]): void;
+    (...data: any[]): void;
+  };
+  debug(message: string, ...args: unknown[]): void;
+  info(message: string, ...args: unknown[]): void;
+  warn(message: string, ...args: unknown[]): void;
+  error(message: string, ...args: unknown[]): void;
+  enabled(level: LogLevel): boolean;
+}
+declare const logger: Logger;
+//#endregion
+export { LogLevel, Logger, getLevelFromEnv, logger };
+//# sourceMappingURL=logger.d.mts.map

package/dist/utils/logger.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.mts","names":[],"sources":["../../src/utils/logger.ts"],"mappings":";aAGY,QAAA;EAAA,MAAA;EAAA,KAAA;EAAA,IAAA;EAAA,IAAA;EAAA,KAAA;AAAA;AAAA,iBAUI,eAAA,CAAA,EAAA,WAA6B,QAAA;AAAA,cAQhC,MAAA;EAAA,OAAA;IAAA,KAAA,EAC0B,QAAA;IAAA,EAAA;EAAA;EAAA,YAAA,OAAA;IAAA,KAAA,EAAA,QAAA;IAAA,EAAA;EAAA;EAAA,KAAA,EAqB9B,QAAA;EAAA,QAAA,WAAA;EAAA,QAAA,UAAA;EAAA,QAAA,UAAA;EAAA,QAAA,WAAA;EAAA,UAAA;IAAA,IAAA,IAAA;IAAA,IAAA,IAAA;EAAA;EAAA,QAAA;IAAA,IAAA,IAAA;IAAA,IAAA,IAAA;EAAA;EAAA,MAAA,OAAA,aAAA,IAAA;EAAA,KAAA,OAAA,aAAA,IAAA;EAAA,KAAA,OAAA,aAAA,IAAA;EAAA,MAAA,OAAA,aAAA,IAAA;EAAA,QAAA,KAAA,EAsCQ,QAAA;AAAA;AAAA,cAKJ,MAAA,EAAM,MAAA"}

package/dist/utils/logger.mjs

@@ -0,0 +1,68 @@
+import { nodejs } from "@aigne/utils/nodejs";
+import debug from "debug";
+
+//#region src/utils/logger.ts
+let LogLevel = /* @__PURE__ */ function(LogLevel) {
+	LogLevel["SILENT"] = "silent";
+	LogLevel["ERROR"] = "error";
+	LogLevel["WARN"] = "warn";
+	LogLevel["INFO"] = "info";
+	LogLevel["DEBUG"] = "debug";
+	return LogLevel;
+}({});
+const levels = Object.values(LogLevel);
+function getLevelFromEnv(ns) {
+	for (const level of [...levels].reverse()) if (debug.enabled(`${ns}:${level}`)) return level;
+}
+var Logger = class {
+	constructor(options) {
+		this.options = options;
+		this.debugLogger = debug(`${options.ns}:${LogLevel.DEBUG}`);
+		this.infoLogger = debug(`${options.ns}:${LogLevel.INFO}`);
+		this.warnLogger = debug(`${options.ns}:${LogLevel.WARN}`);
+		this.errorLogger = debug(`${options.ns}:${LogLevel.ERROR}`);
+		this.level = getLevelFromEnv(options.ns) || options.level;
+		for (const logger of [
+			this.debugLogger,
+			this.infoLogger,
+			this.warnLogger
+		]) {
+			logger.useColors = nodejs.isStdoutATTY;
+			logger.enabled = true;
+			logger.log = (...args) => this.logMessage(...args);
+		}
+		this.errorLogger.log = (...args) => this.logError(...args);
+		this.errorLogger.useColors = nodejs.isStderrATTY;
+		this.errorLogger.enabled = true;
+	}
+	level;
+	debugLogger;
+	infoLogger;
+	warnLogger;
+	errorLogger;
+	logMessage = console.log;
+	logError = console.error;
+	debug(message, ...args) {
+		if (this.enabled(LogLevel.DEBUG)) this.debugLogger(message, ...args);
+	}
+	info(message, ...args) {
+		if (this.enabled(LogLevel.INFO)) this.infoLogger(message, ...args);
+	}
+	warn(message, ...args) {
+		if (this.enabled(LogLevel.WARN)) this.warnLogger(message, ...args);
+	}
+	error(message, ...args) {
+		if (this.enabled(LogLevel.ERROR)) this.errorLogger(message, ...args);
+	}
+	enabled(level) {
+		return levels.indexOf(this.level) >= levels.indexOf(level);
+	}
+};
+const logger = new Logger({
+	ns: "aigne:core",
+	level: LogLevel.SILENT
+});
+
+//#endregion
+export { LogLevel, Logger, getLevelFromEnv, logger };
+//# sourceMappingURL=logger.mjs.map

package/dist/utils/logger.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.mjs","names":[],"sources":["../../src/utils/logger.ts"],"sourcesContent":["import { nodejs } from \"@aigne/utils/nodejs\";\nimport debug from \"debug\";\n\nexport enum LogLevel {\n  SILENT = \"silent\",\n  ERROR = \"error\",\n  WARN = \"warn\",\n  INFO = \"info\",\n  DEBUG = \"debug\",\n}\n\nconst levels = Object.values(LogLevel);\n\nexport function getLevelFromEnv(ns: string): LogLevel | undefined {\n  for (const level of [...levels].reverse()) {\n    if (debug.enabled(`${ns}:${level}`)) {\n      return level;\n    }\n  }\n}\n\nexport class Logger {\n  constructor(public options: { level: LogLevel; ns: string }) {\n    this.debugLogger = debug(`${options.ns}:${LogLevel.DEBUG}`);\n    this.infoLogger = debug(`${options.ns}:${LogLevel.INFO}`);\n    this.warnLogger = debug(`${options.ns}:${LogLevel.WARN}`);\n    this.errorLogger = debug(`${options.ns}:${LogLevel.ERROR}`);\n\n    this.level = getLevelFromEnv(options.ns) || options.level;\n\n    for (const logger of [this.debugLogger, this.infoLogger, this.warnLogger]) {\n      // @ts-ignore\n      logger.useColors = nodejs.isStdoutATTY;\n      logger.enabled = true;\n      logger.log = (...args: unknown[]) => this.logMessage(...args);\n    }\n\n    this.errorLogger.log = (...args: unknown[]) => this.logError(...args);\n    // @ts-ignore\n    this.errorLogger.useColors = nodejs.isStderrATTY;\n    this.errorLogger.enabled = true;\n  }\n\n  level: LogLevel;\n\n  private debugLogger: debug.Debugger;\n\n  private infoLogger: debug.Debugger;\n\n  private warnLogger: debug.Debugger;\n\n  private errorLogger: debug.Debugger;\n\n  logMessage = console.log;\n\n  logError = console.error;\n\n  debug(message: string, ...args: unknown[]) {\n    if (this.enabled(LogLevel.DEBUG)) {\n      this.debugLogger(message, ...args);\n    }\n  }\n\n  info(message: string, ...args: unknown[]) {\n    if (this.enabled(LogLevel.INFO)) {\n      this.infoLogger(message, ...args);\n    }\n  }\n\n  warn(message: string, ...args: unknown[]) {\n    if (this.enabled(LogLevel.WARN)) {\n      this.warnLogger(message, ...args);\n    }\n  }\n\n  error(message: string, ...args: unknown[]) {\n    if (this.enabled(LogLevel.ERROR)) {\n      this.errorLogger(message, ...args);\n    }\n  }\n\n  enabled(level: LogLevel) {\n    return levels.indexOf(this.level) >= levels.indexOf(level);\n  }\n}\n\nexport const logger = new Logger({\n  ns: \"aigne:core\",\n  level: LogLevel.SILENT,\n});\n"],"mappings":";;;;AAGA,IAAY,8CAAL;AACL;AACA;AACA;AACA;AACA;;;AAGF,MAAM,SAAS,OAAO,OAAO,SAAS;AAEtC,SAAgB,gBAAgB,IAAkC;AAChE,MAAK,MAAM,SAAS,CAAC,GAAG,OAAO,CAAC,SAAS,CACvC,KAAI,MAAM,QAAQ,GAAG,GAAG,GAAG,QAAQ,CACjC,QAAO;;AAKb,IAAa,SAAb,MAAoB;CAClB,YAAY,AAAO,SAA0C;EAA1C;AACjB,OAAK,cAAc,MAAM,GAAG,QAAQ,GAAG,GAAG,SAAS,QAAQ;AAC3D,OAAK,aAAa,MAAM,GAAG,QAAQ,GAAG,GAAG,SAAS,OAAO;AACzD,OAAK,aAAa,MAAM,GAAG,QAAQ,GAAG,GAAG,SAAS,OAAO;AACzD,OAAK,cAAc,MAAM,GAAG,QAAQ,GAAG,GAAG,SAAS,QAAQ;AAE3D,OAAK,QAAQ,gBAAgB,QAAQ,GAAG,IAAI,QAAQ;AAEpD,OAAK,MAAM,UAAU;GAAC,KAAK;GAAa,KAAK;GAAY,KAAK;GAAW,EAAE;AAEzE,UAAO,YAAY,OAAO;AAC1B,UAAO,UAAU;AACjB,UAAO,OAAO,GAAG,SAAoB,KAAK,WAAW,GAAG,KAAK;;AAG/D,OAAK,YAAY,OAAO,GAAG,SAAoB,KAAK,SAAS,GAAG,KAAK;AAErE,OAAK,YAAY,YAAY,OAAO;AACpC,OAAK,YAAY,UAAU;;CAG7B;CAEA,AAAQ;CAER,AAAQ;CAER,AAAQ;CAER,AAAQ;CAER,aAAa,QAAQ;CAErB,WAAW,QAAQ;CAEnB,MAAM,SAAiB,GAAG,MAAiB;AACzC,MAAI,KAAK,QAAQ,SAAS,MAAM,CAC9B,MAAK,YAAY,SAAS,GAAG,KAAK;;CAItC,KAAK,SAAiB,GAAG,MAAiB;AACxC,MAAI,KAAK,QAAQ,SAAS,KAAK,CAC7B,MAAK,WAAW,SAAS,GAAG,KAAK;;CAIrC,KAAK,SAAiB,GAAG,MAAiB;AACxC,MAAI,KAAK,QAAQ,SAAS,KAAK,CAC7B,MAAK,WAAW,SAAS,GAAG,KAAK;;CAIrC,MAAM,SAAiB,GAAG,MAAiB;AACzC,MAAI,KAAK,QAAQ,SAAS,MAAM,CAC9B,MAAK,YAAY,SAAS,GAAG,KAAK;;CAItC,QAAQ,OAAiB;AACvB,SAAO,OAAO,QAAQ,KAAK,MAAM,IAAI,OAAO,QAAQ,MAAM;;;AAI9D,MAAa,SAAS,IAAI,OAAO;CAC/B,IAAI;CACJ,OAAO,SAAS;CACjB,CAAC"}

package/dist/utils/mcp-utils.cjs

@@ -0,0 +1,53 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_utils_type_utils = require('./type-utils.cjs');
+const require_mcp_agent = require('../agents/mcp-agent.cjs');
+let zod = require("zod");
+let _aigne_json_schema_to_zod = require("@aigne/json-schema-to-zod");
+let _modelcontextprotocol_sdk_shared_uriTemplate_js = require("@modelcontextprotocol/sdk/shared/uriTemplate.js");
+let _modelcontextprotocol_sdk_types_js = require("@modelcontextprotocol/sdk/types.js");
+
+//#region src/utils/mcp-utils.ts
+function toolFromMCPTool(tool, options) {
+	return new require_mcp_agent.MCPTool({
+		...options,
+		name: tool.name,
+		description: tool.description,
+		inputSchema: require_utils_type_utils.isEmpty(tool.inputSchema.properties) ? zod.z.object({}) : (0, _aigne_json_schema_to_zod.jsonSchemaToZod)(tool.inputSchema),
+		outputSchema: _modelcontextprotocol_sdk_types_js.CallToolResultSchema
+	});
+}
+function promptFromMCPPrompt(prompt, options) {
+	return new require_mcp_agent.MCPPrompt({
+		...options,
+		name: prompt.name,
+		description: prompt.description,
+		inputSchema: (0, _aigne_json_schema_to_zod.jsonSchemaToZod)({
+			type: "object",
+			properties: prompt.arguments && Object.fromEntries(prompt.arguments.map((i) => [i.name, {
+				type: "string",
+				description: i.description
+			}])),
+			required: prompt.arguments?.filter((i) => i.required).map((i) => i.name)
+		}),
+		outputSchema: _modelcontextprotocol_sdk_types_js.GetPromptResultSchema
+	});
+}
+function resourceFromMCPResource(resource, options) {
+	const [uri, variables] = isResourceTemplate(resource) ? [resource.uriTemplate, new _modelcontextprotocol_sdk_shared_uriTemplate_js.UriTemplate(resource.uriTemplate).variableNames] : [resource.uri, []];
+	return new require_mcp_agent.MCPResource({
+		...options,
+		name: resource.name,
+		uri,
+		description: resource.description,
+		inputSchema: zod.z.object(Object.fromEntries(variables.map((i) => [i, zod.z.string()]))),
+		outputSchema: _modelcontextprotocol_sdk_types_js.ReadResourceResultSchema
+	});
+}
+function isResourceTemplate(resource) {
+	return "uriTemplate" in resource && typeof resource.uriTemplate === "string";
+}
+
+//#endregion
+exports.promptFromMCPPrompt = promptFromMCPPrompt;
+exports.resourceFromMCPResource = resourceFromMCPResource;
+exports.toolFromMCPTool = toolFromMCPTool;

package/dist/utils/mcp-utils.d.cts

@@ -0,0 +1,10 @@
+import { MCPBaseOptions, MCPPrompt, MCPResource, MCPTool } from "../agents/mcp-agent.cjs";
+import { ListPromptsResult, ListResourceTemplatesResult, ListResourcesResult, ListToolsResult } from "@modelcontextprotocol/sdk/types.js";
+
+//#region src/utils/mcp-utils.d.ts
+declare function toolFromMCPTool(tool: ListToolsResult["tools"][number], options: MCPBaseOptions): MCPTool;
+declare function promptFromMCPPrompt(prompt: ListPromptsResult["prompts"][number], options: MCPBaseOptions): MCPPrompt;
+declare function resourceFromMCPResource(resource: ListResourcesResult["resources"][number] | ListResourceTemplatesResult["resourceTemplates"][number], options: MCPBaseOptions): MCPResource;
+//#endregion
+export { promptFromMCPPrompt, resourceFromMCPResource, toolFromMCPTool };
+//# sourceMappingURL=mcp-utils.d.cts.map

package/dist/utils/mcp-utils.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-utils.d.cts","names":[],"sources":["../../src/utils/mcp-utils.ts"],"mappings":";;;;iBAegB,eAAA,CAAA,IAAA,EAAsB,eAAA,mBAAA,OAAA,EAA2C,cAAA,GAAc,OAAA;AAAA,iBAY/E,mBAAA,CAAA,MAAA,EACN,iBAAA,qBAAA,OAAA,EACC,cAAA,GAAc,SAAA;AAAA,iBAmBT,uBAAA,CAAA,QAAA,EAEV,mBAAA,wBACA,2BAAA,+BAAA,OAAA,EACK,cAAA,GAAc,WAAA"}

package/dist/utils/mcp-utils.d.mts

@@ -0,0 +1,10 @@
+import { MCPBaseOptions, MCPPrompt, MCPResource, MCPTool } from "../agents/mcp-agent.mjs";
+import { ListPromptsResult, ListResourceTemplatesResult, ListResourcesResult, ListToolsResult } from "@modelcontextprotocol/sdk/types.js";
+
+//#region src/utils/mcp-utils.d.ts
+declare function toolFromMCPTool(tool: ListToolsResult["tools"][number], options: MCPBaseOptions): MCPTool;
+declare function promptFromMCPPrompt(prompt: ListPromptsResult["prompts"][number], options: MCPBaseOptions): MCPPrompt;
+declare function resourceFromMCPResource(resource: ListResourcesResult["resources"][number] | ListResourceTemplatesResult["resourceTemplates"][number], options: MCPBaseOptions): MCPResource;
+//#endregion
+export { promptFromMCPPrompt, resourceFromMCPResource, toolFromMCPTool };
+//# sourceMappingURL=mcp-utils.d.mts.map