@aigne/core 1.72.0 → 1.74.0-beta

package/dist/utils/test/agent-response.cjs

@@ -0,0 +1,16 @@
+const require_utils_stream_utils = require('../stream-utils.cjs');
+const require_agent = require('../../agents/agent.cjs');
+require('../../index.cjs');
+
+//#region src/utils/test/agent-response.ts
+async function agentResponseStreamToArraySnapshot(stream, options) {
+	return (await require_utils_stream_utils.readableStreamToArray(stream, options)).map((i) => !(i instanceof Error) && require_agent.isAgentResponseProgress(i) ? { progress: {
+		...i.progress,
+		contextId: "TEST_CONTEXT_ID",
+		parentContextId: "TEST_PARENT_CONTEXT_ID",
+		timestamp: 123456
+	} } : i);
+}
+
+//#endregion
+exports.agentResponseStreamToArraySnapshot = agentResponseStreamToArraySnapshot;

package/dist/utils/test/agent-response.d.cts

@@ -0,0 +1,12 @@
+import { AgentResponseChunk, AgentResponseStream, Message } from "../../agents/agent.cjs";
+
+//#region src/utils/test/agent-response.d.ts
+declare function agentResponseStreamToArraySnapshot<T extends Message>(stream: AgentResponseStream<T>, options?: {
+  catchError?: false;
+}): Promise<AgentResponseChunk<T>[]>;
+declare function agentResponseStreamToArraySnapshot<T extends Message>(stream: AgentResponseStream<T>, options?: {
+  catchError?: boolean;
+}): Promise<(AgentResponseChunk<T> | Error)[]>;
+//#endregion
+export { agentResponseStreamToArraySnapshot };
+//# sourceMappingURL=agent-response.d.cts.map

package/dist/utils/test/agent-response.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-response.d.cts","names":[],"sources":["../../../src/utils/test/agent-response.ts"],"mappings":";;;iBAQsB,kCAAA,WAA6C,OAAA,CAAA,CAAA,MAAA,EACzD,mBAAA,CAAoB,CAAA,GAAA,OAAA;EAAA,UAAA;AAAA,IAE3B,OAAA,CAAQ,kBAAA,CAAmB,CAAA;AAAA,iBACR,kCAAA,WAA6C,OAAA,CAAA,CAAA,MAAA,EACzD,mBAAA,CAAoB,CAAA,GAAA,OAAA;EAAA,UAAA;AAAA,IAE3B,OAAA,EAAS,kBAAA,CAAmB,CAAA,IAAK,KAAA"}

package/dist/utils/test/agent-response.d.mts

@@ -0,0 +1,13 @@
+import { AgentResponseChunk, AgentResponseStream, Message } from "../../agents/agent.mjs";
+import "../../index.mjs";
+
+//#region src/utils/test/agent-response.d.ts
+declare function agentResponseStreamToArraySnapshot<T extends Message>(stream: AgentResponseStream<T>, options?: {
+  catchError?: false;
+}): Promise<AgentResponseChunk<T>[]>;
+declare function agentResponseStreamToArraySnapshot<T extends Message>(stream: AgentResponseStream<T>, options?: {
+  catchError?: boolean;
+}): Promise<(AgentResponseChunk<T> | Error)[]>;
+//#endregion
+export { agentResponseStreamToArraySnapshot };
+//# sourceMappingURL=agent-response.d.mts.map

package/dist/utils/test/agent-response.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-response.d.mts","names":[],"sources":["../../../src/utils/test/agent-response.ts"],"mappings":";;;;iBAQsB,kCAAA,WAA6C,OAAA,CAAA,CAAA,MAAA,EACzD,mBAAA,CAAoB,CAAA,GAAA,OAAA;EAAA,UAAA;AAAA,IAE3B,OAAA,CAAQ,kBAAA,CAAmB,CAAA;AAAA,iBACR,kCAAA,WAA6C,OAAA,CAAA,CAAA,MAAA,EACzD,mBAAA,CAAoB,CAAA,GAAA,OAAA;EAAA,UAAA;AAAA,IAE3B,OAAA,EAAS,kBAAA,CAAmB,CAAA,IAAK,KAAA"}

package/dist/utils/test/agent-response.mjs

@@ -0,0 +1,17 @@
+import { readableStreamToArray } from "../stream-utils.mjs";
+import { isAgentResponseProgress } from "../../agents/agent.mjs";
+import "../../index.mjs";
+
+//#region src/utils/test/agent-response.ts
+async function agentResponseStreamToArraySnapshot(stream, options) {
+	return (await readableStreamToArray(stream, options)).map((i) => !(i instanceof Error) && isAgentResponseProgress(i) ? { progress: {
+		...i.progress,
+		contextId: "TEST_CONTEXT_ID",
+		parentContextId: "TEST_PARENT_CONTEXT_ID",
+		timestamp: 123456
+	} } : i);
+}
+
+//#endregion
+export { agentResponseStreamToArraySnapshot };
+//# sourceMappingURL=agent-response.mjs.map

package/dist/utils/test/agent-response.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-response.mjs","names":[],"sources":["../../../src/utils/test/agent-response.ts"],"sourcesContent":["import {\n  type AgentResponseChunk,\n  type AgentResponseStream,\n  isAgentResponseProgress,\n  type Message,\n} from \"../../index.js\";\nimport { readableStreamToArray } from \"../stream-utils.js\";\n\nexport async function agentResponseStreamToArraySnapshot<T extends Message>(\n  stream: AgentResponseStream<T>,\n  options?: { catchError?: false },\n): Promise<AgentResponseChunk<T>[]>;\nexport async function agentResponseStreamToArraySnapshot<T extends Message>(\n  stream: AgentResponseStream<T>,\n  options?: { catchError?: boolean },\n): Promise<(AgentResponseChunk<T> | Error)[]>;\nexport async function agentResponseStreamToArraySnapshot<T extends Message>(\n  stream: AgentResponseStream<T>,\n  options?: { catchError?: boolean },\n): Promise<(AgentResponseChunk<T> | Error)[]> {\n  return (await readableStreamToArray(stream, options)).map((i) =>\n    !(i instanceof Error) && isAgentResponseProgress(i)\n      ? {\n          progress: {\n            ...i.progress,\n            contextId: \"TEST_CONTEXT_ID\",\n            parentContextId: \"TEST_PARENT_CONTEXT_ID\",\n            timestamp: 123456,\n          },\n        }\n      : i,\n  );\n}\n"],"mappings":";;;;;AAgBA,eAAsB,mCACpB,QACA,SAC4C;AAC5C,SAAQ,MAAM,sBAAsB,QAAQ,QAAQ,EAAE,KAAK,MACzD,EAAE,aAAa,UAAU,wBAAwB,EAAE,GAC/C,EACE,UAAU;EACR,GAAG,EAAE;EACL,WAAW;EACX,iBAAiB;EACjB,WAAW;EACZ,EACF,GACD,EACL"}

package/dist/utils/test/openai-like-utils.cjs

@@ -0,0 +1,73 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_template = require('../../prompt/template.cjs');
+require('../../index.cjs');
+let bun_test = require("bun:test");
+
+//#region src/utils/test/openai-like-utils.ts
+const COMMON_TOOLS = [{
+	type: "function",
+	function: {
+		name: "get_weather",
+		parameters: {
+			type: "object",
+			properties: { city: { type: "string" } },
+			required: ["city"]
+		}
+	}
+}];
+const COMMON_RESPONSE_FORMAT = {
+	type: "json_schema",
+	jsonSchema: {
+		name: "output",
+		schema: {
+			type: "object",
+			properties: { text: { type: "string" } },
+			required: ["text"],
+			additionalProperties: false
+		},
+		strict: true
+	}
+};
+const createBaseMessages = () => [require_template.SystemMessageTemplate.from("You are a chatbot"), require_template.UserMessageTemplate.from([{
+	type: "text",
+	text: "What is the weather in New York?"
+}])];
+const createWeatherToolMessages = () => require_template.ChatMessagesTemplate.from(createBaseMessages()).format();
+const createWeatherToolExpected = () => bun_test.expect.objectContaining({ toolCalls: [{
+	function: {
+		arguments: { city: "New York" },
+		name: "get_weather"
+	},
+	id: bun_test.expect.any(String),
+	type: "function"
+}] });
+const createWeatherToolCallMessages = () => require_template.ChatMessagesTemplate.from([
+	...createBaseMessages(),
+	require_template.AgentMessageTemplate.from(void 0, [{
+		id: "get_weather",
+		type: "function",
+		function: {
+			name: "get_weather",
+			arguments: { city: "New York" }
+		}
+	}]),
+	require_template.ToolMessageTemplate.from({ temperature: 20 }, "get_weather")
+]).format();
+function createToolCallResponse(functionName, args) {
+	return {
+		id: functionName,
+		type: "function",
+		function: {
+			name: functionName,
+			arguments: args
+		}
+	};
+}
+
+//#endregion
+exports.COMMON_RESPONSE_FORMAT = COMMON_RESPONSE_FORMAT;
+exports.COMMON_TOOLS = COMMON_TOOLS;
+exports.createToolCallResponse = createToolCallResponse;
+exports.createWeatherToolCallMessages = createWeatherToolCallMessages;
+exports.createWeatherToolExpected = createWeatherToolExpected;
+exports.createWeatherToolMessages = createWeatherToolMessages;

package/dist/utils/test/openai-like-utils.d.cts

@@ -0,0 +1,13 @@
+import { ChatModelInputMessage, ChatModelInputResponseFormat, ChatModelInputTool, ChatModelOutputToolCall } from "../../agents/chat-model.cjs";
+import { Message } from "../../agents/agent.cjs";
+
+//#region src/utils/test/openai-like-utils.d.ts
+declare const COMMON_TOOLS: ChatModelInputTool[];
+declare const COMMON_RESPONSE_FORMAT: ChatModelInputResponseFormat;
+declare const createWeatherToolMessages: () => Promise<ChatModelInputMessage[]>;
+declare const createWeatherToolExpected: () => any;
+declare const createWeatherToolCallMessages: () => Promise<ChatModelInputMessage[]>;
+declare function createToolCallResponse(functionName: string, args: Message): ChatModelOutputToolCall;
+//#endregion
+export { COMMON_RESPONSE_FORMAT, COMMON_TOOLS, createToolCallResponse, createWeatherToolCallMessages, createWeatherToolExpected, createWeatherToolMessages };
+//# sourceMappingURL=openai-like-utils.d.cts.map

package/dist/utils/test/openai-like-utils.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-like-utils.d.cts","names":[],"sources":["../../../src/utils/test/openai-like-utils.ts"],"mappings":";;;;cAaa,YAAA,EAAc,kBAAA;AAAA,cAkBd,sBAAA,EAAwB,4BAAA;AAAA,cAuBxB,yBAAA,QAAyB,OAAA,CACoB,qBAAA;AAAA,cAE7C,yBAAA;AAAA,cAgBA,6BAAA,QAA6B,OAAA,CAW7B,qBAAA;AAAA,iBAEG,sBAAA,CAAA,YAAA,UAAA,IAAA,EAER,OAAA,GACL,uBAAA"}

package/dist/utils/test/openai-like-utils.d.mts

@@ -0,0 +1,14 @@
+import { ChatModelInputMessage, ChatModelInputResponseFormat, ChatModelInputTool, ChatModelOutputToolCall } from "../../agents/chat-model.mjs";
+import { Message } from "../../agents/agent.mjs";
+import "../../index.mjs";
+
+//#region src/utils/test/openai-like-utils.d.ts
+declare const COMMON_TOOLS: ChatModelInputTool[];
+declare const COMMON_RESPONSE_FORMAT: ChatModelInputResponseFormat;
+declare const createWeatherToolMessages: () => Promise<ChatModelInputMessage[]>;
+declare const createWeatherToolExpected: () => any;
+declare const createWeatherToolCallMessages: () => Promise<ChatModelInputMessage[]>;
+declare function createToolCallResponse(functionName: string, args: Message): ChatModelOutputToolCall;
+//#endregion
+export { COMMON_RESPONSE_FORMAT, COMMON_TOOLS, createToolCallResponse, createWeatherToolCallMessages, createWeatherToolExpected, createWeatherToolMessages };
+//# sourceMappingURL=openai-like-utils.d.mts.map

package/dist/utils/test/openai-like-utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-like-utils.d.mts","names":[],"sources":["../../../src/utils/test/openai-like-utils.ts"],"mappings":";;;;;cAaa,YAAA,EAAc,kBAAA;AAAA,cAkBd,sBAAA,EAAwB,4BAAA;AAAA,cAuBxB,yBAAA,QAAyB,OAAA,CACoB,qBAAA;AAAA,cAE7C,yBAAA;AAAA,cAgBA,6BAAA,QAA6B,OAAA,CAW7B,qBAAA;AAAA,iBAEG,sBAAA,CAAA,YAAA,UAAA,IAAA,EAER,OAAA,GACL,uBAAA"}

package/dist/utils/test/openai-like-utils.mjs

@@ -0,0 +1,68 @@
+import { AgentMessageTemplate, ChatMessagesTemplate, SystemMessageTemplate, ToolMessageTemplate, UserMessageTemplate } from "../../prompt/template.mjs";
+import "../../index.mjs";
+import { expect } from "bun:test";
+
+//#region src/utils/test/openai-like-utils.ts
+const COMMON_TOOLS = [{
+	type: "function",
+	function: {
+		name: "get_weather",
+		parameters: {
+			type: "object",
+			properties: { city: { type: "string" } },
+			required: ["city"]
+		}
+	}
+}];
+const COMMON_RESPONSE_FORMAT = {
+	type: "json_schema",
+	jsonSchema: {
+		name: "output",
+		schema: {
+			type: "object",
+			properties: { text: { type: "string" } },
+			required: ["text"],
+			additionalProperties: false
+		},
+		strict: true
+	}
+};
+const createBaseMessages = () => [SystemMessageTemplate.from("You are a chatbot"), UserMessageTemplate.from([{
+	type: "text",
+	text: "What is the weather in New York?"
+}])];
+const createWeatherToolMessages = () => ChatMessagesTemplate.from(createBaseMessages()).format();
+const createWeatherToolExpected = () => expect.objectContaining({ toolCalls: [{
+	function: {
+		arguments: { city: "New York" },
+		name: "get_weather"
+	},
+	id: expect.any(String),
+	type: "function"
+}] });
+const createWeatherToolCallMessages = () => ChatMessagesTemplate.from([
+	...createBaseMessages(),
+	AgentMessageTemplate.from(void 0, [{
+		id: "get_weather",
+		type: "function",
+		function: {
+			name: "get_weather",
+			arguments: { city: "New York" }
+		}
+	}]),
+	ToolMessageTemplate.from({ temperature: 20 }, "get_weather")
+]).format();
+function createToolCallResponse(functionName, args) {
+	return {
+		id: functionName,
+		type: "function",
+		function: {
+			name: functionName,
+			arguments: args
+		}
+	};
+}
+
+//#endregion
+export { COMMON_RESPONSE_FORMAT, COMMON_TOOLS, createToolCallResponse, createWeatherToolCallMessages, createWeatherToolExpected, createWeatherToolMessages };
+//# sourceMappingURL=openai-like-utils.mjs.map

package/dist/utils/test/openai-like-utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-like-utils.mjs","names":[],"sources":["../../../src/utils/test/openai-like-utils.ts"],"sourcesContent":["import { expect } from \"bun:test\";\nimport {\n  AgentMessageTemplate,\n  ChatMessagesTemplate,\n  type ChatModelInputResponseFormat,\n  type ChatModelInputTool,\n  type ChatModelOutputToolCall,\n  type Message,\n  SystemMessageTemplate,\n  ToolMessageTemplate,\n  UserMessageTemplate,\n} from \"../../index.js\";\n\nexport const COMMON_TOOLS: ChatModelInputTool[] = [\n  {\n    type: \"function\",\n    function: {\n      name: \"get_weather\",\n      parameters: {\n        type: \"object\",\n        properties: {\n          city: {\n            type: \"string\",\n          },\n        },\n        required: [\"city\"],\n      },\n    },\n  },\n];\n\nexport const COMMON_RESPONSE_FORMAT: ChatModelInputResponseFormat = {\n  type: \"json_schema\",\n  jsonSchema: {\n    name: \"output\",\n    schema: {\n      type: \"object\",\n      properties: {\n        text: {\n          type: \"string\",\n        },\n      },\n      required: [\"text\"],\n      additionalProperties: false,\n    },\n    strict: true,\n  },\n};\n\nconst createBaseMessages = () => [\n  SystemMessageTemplate.from(\"You are a chatbot\"),\n  UserMessageTemplate.from([{ type: \"text\", text: \"What is the weather in New York?\" }]),\n];\n\nexport const createWeatherToolMessages = () =>\n  ChatMessagesTemplate.from(createBaseMessages()).format();\n\nexport const createWeatherToolExpected = () =>\n  expect.objectContaining({\n    toolCalls: [\n      {\n        function: {\n          arguments: {\n            city: \"New York\",\n          },\n          name: \"get_weather\",\n        },\n        id: expect.any(String),\n        type: \"function\",\n      },\n    ],\n  });\n\nexport const createWeatherToolCallMessages = () =>\n  ChatMessagesTemplate.from([\n    ...createBaseMessages(),\n    AgentMessageTemplate.from(undefined, [\n      {\n        id: \"get_weather\",\n        type: \"function\",\n        function: { name: \"get_weather\", arguments: { city: \"New York\" } },\n      },\n    ]),\n    ToolMessageTemplate.from({ temperature: 20 }, \"get_weather\"),\n  ]).format();\n\nexport function createToolCallResponse(\n  functionName: string,\n  args: Message,\n): ChatModelOutputToolCall {\n  return {\n    id: functionName,\n    type: \"function\",\n    function: {\n      name: functionName,\n      arguments: args,\n    },\n  };\n}\n"],"mappings":";;;;;AAaA,MAAa,eAAqC,CAChD;CACE,MAAM;CACN,UAAU;EACR,MAAM;EACN,YAAY;GACV,MAAM;GACN,YAAY,EACV,MAAM,EACJ,MAAM,UACP,EACF;GACD,UAAU,CAAC,OAAO;GACnB;EACF;CACF,CACF;AAED,MAAa,yBAAuD;CAClE,MAAM;CACN,YAAY;EACV,MAAM;EACN,QAAQ;GACN,MAAM;GACN,YAAY,EACV,MAAM,EACJ,MAAM,UACP,EACF;GACD,UAAU,CAAC,OAAO;GAClB,sBAAsB;GACvB;EACD,QAAQ;EACT;CACF;AAED,MAAM,2BAA2B,CAC/B,sBAAsB,KAAK,oBAAoB,EAC/C,oBAAoB,KAAK,CAAC;CAAE,MAAM;CAAQ,MAAM;CAAoC,CAAC,CAAC,CACvF;AAED,MAAa,kCACX,qBAAqB,KAAK,oBAAoB,CAAC,CAAC,QAAQ;AAE1D,MAAa,kCACX,OAAO,iBAAiB,EACtB,WAAW,CACT;CACE,UAAU;EACR,WAAW,EACT,MAAM,YACP;EACD,MAAM;EACP;CACD,IAAI,OAAO,IAAI,OAAO;CACtB,MAAM;CACP,CACF,EACF,CAAC;AAEJ,MAAa,sCACX,qBAAqB,KAAK;CACxB,GAAG,oBAAoB;CACvB,qBAAqB,KAAK,QAAW,CACnC;EACE,IAAI;EACJ,MAAM;EACN,UAAU;GAAE,MAAM;GAAe,WAAW,EAAE,MAAM,YAAY;GAAE;EACnE,CACF,CAAC;CACF,oBAAoB,KAAK,EAAE,aAAa,IAAI,EAAE,cAAc;CAC7D,CAAC,CAAC,QAAQ;AAEb,SAAgB,uBACd,cACA,MACyB;AACzB,QAAO;EACL,IAAI;EACJ,MAAM;EACN,UAAU;GACR,MAAM;GACN,WAAW;GACZ;EACF"}

package/dist/utils/token-estimator.cjs

@@ -0,0 +1,57 @@
+
+//#region src/utils/token-estimator.ts
+/**
+* Token estimation ratios for different character types
+* Based on empirical data from various tokenizers
+*/
+const CHAR_TYPE_RATIOS = {
+	chinese: 1.5,
+	word: .75,
+	other: 1
+};
+/**
+* Regular expressions for character type detection
+*/
+const CHAR_PATTERNS = {
+	chinese: /[\u4e00-\u9fff\u3400-\u4dbf\u3040-\u309f\u30a0-\u30ff]/g,
+	word: /[a-zA-Z]+/g
+};
+/**
+* Estimate tokens in text by analyzing character types
+* This function handles mixed-language text (Chinese and English) by counting
+* different character types and applying appropriate token ratios for each type
+*
+* @param text - The text to estimate
+* @returns Estimated token count
+*/
+function estimateTokens(text) {
+	if (!text) return 0;
+	let tokens = 0;
+	const processedIndices = /* @__PURE__ */ new Set();
+	const chineseMatches = text.match(CHAR_PATTERNS.chinese);
+	if (chineseMatches) {
+		tokens += chineseMatches.length / CHAR_TYPE_RATIOS.chinese;
+		const chineseRegex = new RegExp(CHAR_PATTERNS.chinese.source, "g");
+		let match = chineseRegex.exec(text);
+		while (match !== null) {
+			processedIndices.add(match.index);
+			match = chineseRegex.exec(text);
+		}
+	}
+	const wordMatches = text.match(CHAR_PATTERNS.word);
+	if (wordMatches) {
+		tokens += wordMatches.length * CHAR_TYPE_RATIOS.word;
+		const wordRegex = new RegExp(CHAR_PATTERNS.word.source, "g");
+		let match = wordRegex.exec(text);
+		while (match !== null) {
+			for (let i = 0; i < match[0].length; i++) processedIndices.add(match.index + i);
+			match = wordRegex.exec(text);
+		}
+	}
+	const remainingChars = text.length - processedIndices.size;
+	if (remainingChars > 0) tokens += remainingChars / CHAR_TYPE_RATIOS.other;
+	return Math.ceil(tokens);
+}
+
+//#endregion
+exports.estimateTokens = estimateTokens;

package/dist/utils/token-estimator.d.cts

@@ -0,0 +1,13 @@
+//#region src/utils/token-estimator.d.ts
+/**
+ * Estimate tokens in text by analyzing character types
+ * This function handles mixed-language text (Chinese and English) by counting
+ * different character types and applying appropriate token ratios for each type
+ *
+ * @param text - The text to estimate
+ * @returns Estimated token count
+ */
+declare function estimateTokens(text: string): number;
+//#endregion
+export { estimateTokens };
+//# sourceMappingURL=token-estimator.d.cts.map

package/dist/utils/token-estimator.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-estimator.d.cts","names":[],"sources":["../../src/utils/token-estimator.ts"],"mappings":";;AA4BA;;;;;;;iBAAgB,cAAA,CAAA,IAAA"}

package/dist/utils/token-estimator.d.mts

@@ -0,0 +1,13 @@
+//#region src/utils/token-estimator.d.ts
+/**
+ * Estimate tokens in text by analyzing character types
+ * This function handles mixed-language text (Chinese and English) by counting
+ * different character types and applying appropriate token ratios for each type
+ *
+ * @param text - The text to estimate
+ * @returns Estimated token count
+ */
+declare function estimateTokens(text: string): number;
+//#endregion
+export { estimateTokens };
+//# sourceMappingURL=token-estimator.d.mts.map

package/dist/utils/token-estimator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-estimator.d.mts","names":[],"sources":["../../src/utils/token-estimator.ts"],"mappings":";;AA4BA;;;;;;;iBAAgB,cAAA,CAAA,IAAA"}

package/dist/utils/token-estimator.mjs

@@ -0,0 +1,57 @@
+//#region src/utils/token-estimator.ts
+/**
+* Token estimation ratios for different character types
+* Based on empirical data from various tokenizers
+*/
+const CHAR_TYPE_RATIOS = {
+	chinese: 1.5,
+	word: .75,
+	other: 1
+};
+/**
+* Regular expressions for character type detection
+*/
+const CHAR_PATTERNS = {
+	chinese: /[\u4e00-\u9fff\u3400-\u4dbf\u3040-\u309f\u30a0-\u30ff]/g,
+	word: /[a-zA-Z]+/g
+};
+/**
+* Estimate tokens in text by analyzing character types
+* This function handles mixed-language text (Chinese and English) by counting
+* different character types and applying appropriate token ratios for each type
+*
+* @param text - The text to estimate
+* @returns Estimated token count
+*/
+function estimateTokens(text) {
+	if (!text) return 0;
+	let tokens = 0;
+	const processedIndices = /* @__PURE__ */ new Set();
+	const chineseMatches = text.match(CHAR_PATTERNS.chinese);
+	if (chineseMatches) {
+		tokens += chineseMatches.length / CHAR_TYPE_RATIOS.chinese;
+		const chineseRegex = new RegExp(CHAR_PATTERNS.chinese.source, "g");
+		let match = chineseRegex.exec(text);
+		while (match !== null) {
+			processedIndices.add(match.index);
+			match = chineseRegex.exec(text);
+		}
+	}
+	const wordMatches = text.match(CHAR_PATTERNS.word);
+	if (wordMatches) {
+		tokens += wordMatches.length * CHAR_TYPE_RATIOS.word;
+		const wordRegex = new RegExp(CHAR_PATTERNS.word.source, "g");
+		let match = wordRegex.exec(text);
+		while (match !== null) {
+			for (let i = 0; i < match[0].length; i++) processedIndices.add(match.index + i);
+			match = wordRegex.exec(text);
+		}
+	}
+	const remainingChars = text.length - processedIndices.size;
+	if (remainingChars > 0) tokens += remainingChars / CHAR_TYPE_RATIOS.other;
+	return Math.ceil(tokens);
+}
+
+//#endregion
+export { estimateTokens };
+//# sourceMappingURL=token-estimator.mjs.map

package/dist/utils/token-estimator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-estimator.mjs","names":[],"sources":["../../src/utils/token-estimator.ts"],"sourcesContent":["/**\n * Token estimation ratios for different character types\n * Based on empirical data from various tokenizers\n */\nconst CHAR_TYPE_RATIOS = {\n  chinese: 1.5, // Chinese characters: ~1.5 characters per token\n  word: 0.75, // English words: ~0.75 tokens per word (accounting for subword tokenization)\n  other: 1, // Other characters (punctuation, numbers, etc.): ~1 character per token\n};\n\n/**\n * Regular expressions for character type detection\n */\nconst CHAR_PATTERNS = {\n  // CJK characters (Chinese, Japanese Kanji, etc.)\n  chinese: /[\\u4e00-\\u9fff\\u3400-\\u4dbf\\u3040-\\u309f\\u30a0-\\u30ff]/g,\n  // English words (sequences of letters)\n  word: /[a-zA-Z]+/g,\n};\n\n/**\n * Estimate tokens in text by analyzing character types\n * This function handles mixed-language text (Chinese and English) by counting\n * different character types and applying appropriate token ratios for each type\n *\n * @param text - The text to estimate\n * @returns Estimated token count\n */\nexport function estimateTokens(text: string): number {\n  if (!text) return 0;\n\n  let tokens = 0;\n  const processedIndices = new Set<number>();\n\n  // Count Chinese characters (including CJK)\n  const chineseMatches = text.match(CHAR_PATTERNS.chinese);\n  if (chineseMatches) {\n    tokens += chineseMatches.length / CHAR_TYPE_RATIOS.chinese;\n    // Mark processed positions\n    const chineseRegex = new RegExp(CHAR_PATTERNS.chinese.source, \"g\");\n    let match = chineseRegex.exec(text);\n    while (match !== null) {\n      processedIndices.add(match.index);\n      match = chineseRegex.exec(text);\n    }\n  }\n\n  // Count English words\n  const wordMatches = text.match(CHAR_PATTERNS.word);\n  if (wordMatches) {\n    tokens += wordMatches.length * CHAR_TYPE_RATIOS.word;\n    const wordRegex = new RegExp(CHAR_PATTERNS.word.source, \"g\");\n    let match = wordRegex.exec(text);\n    while (match !== null) {\n      for (let i = 0; i < match[0].length; i++) {\n        processedIndices.add(match.index + i);\n      }\n      match = wordRegex.exec(text);\n    }\n  }\n\n  // Count remaining characters (punctuation, numbers, whitespace, etc.)\n  const remainingChars = text.length - processedIndices.size;\n  if (remainingChars > 0) {\n    tokens += remainingChars / CHAR_TYPE_RATIOS.other;\n  }\n\n  return Math.ceil(tokens);\n}\n"],"mappings":";;;;;AAIA,MAAM,mBAAmB;CACvB,SAAS;CACT,MAAM;CACN,OAAO;CACR;;;;AAKD,MAAM,gBAAgB;CAEpB,SAAS;CAET,MAAM;CACP;;;;;;;;;AAUD,SAAgB,eAAe,MAAsB;AACnD,KAAI,CAAC,KAAM,QAAO;CAElB,IAAI,SAAS;CACb,MAAM,mCAAmB,IAAI,KAAa;CAG1C,MAAM,iBAAiB,KAAK,MAAM,cAAc,QAAQ;AACxD,KAAI,gBAAgB;AAClB,YAAU,eAAe,SAAS,iBAAiB;EAEnD,MAAM,eAAe,IAAI,OAAO,cAAc,QAAQ,QAAQ,IAAI;EAClE,IAAI,QAAQ,aAAa,KAAK,KAAK;AACnC,SAAO,UAAU,MAAM;AACrB,oBAAiB,IAAI,MAAM,MAAM;AACjC,WAAQ,aAAa,KAAK,KAAK;;;CAKnC,MAAM,cAAc,KAAK,MAAM,cAAc,KAAK;AAClD,KAAI,aAAa;AACf,YAAU,YAAY,SAAS,iBAAiB;EAChD,MAAM,YAAY,IAAI,OAAO,cAAc,KAAK,QAAQ,IAAI;EAC5D,IAAI,QAAQ,UAAU,KAAK,KAAK;AAChC,SAAO,UAAU,MAAM;AACrB,QAAK,IAAI,IAAI,GAAG,IAAI,MAAM,GAAG,QAAQ,IACnC,kBAAiB,IAAI,MAAM,QAAQ,EAAE;AAEvC,WAAQ,UAAU,KAAK,KAAK;;;CAKhC,MAAM,iBAAiB,KAAK,SAAS,iBAAiB;AACtD,KAAI,iBAAiB,EACnB,WAAU,iBAAiB,iBAAiB;AAG9C,QAAO,KAAK,KAAK,OAAO"}

package/dist/utils/type-utils.cjs

@@ -0,0 +1,159 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let zod = require("zod");
+
+//#region src/utils/type-utils.ts
+function isNil(value) {
+	return value === null || value === void 0;
+}
+function isRecord(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isEmpty(obj) {
+	if (isNil(obj)) return true;
+	if (typeof obj === "string" || Array.isArray(obj)) return obj.length === 0;
+	if (typeof obj === "object") return Object.keys(obj).length === 0;
+	return false;
+}
+function isNonNullable(value) {
+	return !isNil(value);
+}
+function isNotEmpty(arr) {
+	return arr.length > 0;
+}
+function duplicates(arr, key = (item) => item) {
+	const seen = /* @__PURE__ */ new Set();
+	const duplicates = /* @__PURE__ */ new Set();
+	for (const item of arr) {
+		const k = key(item);
+		if (seen.has(k)) duplicates.add(item);
+		else seen.add(k);
+	}
+	return Array.from(duplicates);
+}
+function remove(arr, remove) {
+	const removed = [];
+	for (let i = 0; i < arr.length; i++) {
+		const item = arr[i];
+		if (Array.isArray(remove) && remove.includes(item) || typeof remove === "function" && remove(item)) {
+			removed.push(...arr.splice(i, 1));
+			i--;
+		}
+	}
+	return removed;
+}
+function unique(arr, key = (item) => item) {
+	const seen = /* @__PURE__ */ new Set();
+	return arr.filter((item) => {
+		const k = key(item);
+		if (seen.has(k)) return false;
+		seen.add(k);
+		return true;
+	});
+}
+function get(obj, path) {
+	return path.reduce((acc, key) => isRecord(acc) ? Reflect.get(acc, key) : void 0, obj);
+}
+function pick(obj, ...keys) {
+	const flattenedKeys = new Set(keys.flat());
+	return Object.fromEntries(Object.entries(obj).filter(([key]) => flattenedKeys.has(key)));
+}
+function omit(obj, ...keys) {
+	const flattenedKeys = new Set(keys.flat());
+	return Object.fromEntries(Object.entries(obj).filter(([key]) => !flattenedKeys.has(key)));
+}
+function omitDeep(obj, ...keys) {
+	if (Array.isArray(obj)) return obj.map((item) => omitDeep(item, ...keys));
+	if (isRecord(obj)) {
+		const flattenedKeys = new Set(keys.flat());
+		return Object.fromEntries(Object.entries(obj).filter(([key]) => !flattenedKeys.has(key)).map(([key, value]) => [key, omitDeep(value, ...keys)]));
+	}
+	return obj;
+}
+function omitBy(obj, predicate) {
+	return Object.fromEntries(Object.entries(obj).filter(([key, value]) => {
+		return !predicate(value, key);
+	}));
+}
+function omitByDeep(obj, predicate) {
+	if (obj === null || obj === void 0) return obj;
+	if (Array.isArray(obj)) return obj.map((item) => omitByDeep(item, predicate));
+	if (typeof obj === "object") {
+		const result = {};
+		for (const [key, value] of Object.entries(obj)) {
+			const newValue = omitByDeep(value, predicate);
+			if (!predicate(newValue, key)) result[key] = newValue;
+		}
+		return result;
+	}
+	return obj;
+}
+function flat(...value) {
+	return value.flat().filter(isNonNullable);
+}
+function createAccessorArray(array, accessor) {
+	return new Proxy(array, { get: (t, p, r) => Reflect.get(t, p, r) ?? accessor(array, p) });
+}
+function checkArguments(prefix, schema, args) {
+	try {
+		return schema.parse(args);
+	} catch (error) {
+		if (error instanceof zod.z.ZodError) {
+			const message = error.issues.map((i) => {
+				const msg = i.code === "invalid_union" ? `${i.message} expect ${getExpectedTypes(i)} got ${get(args, i.path)}` : i.message;
+				return `${i.path}: ${msg}`;
+			}).join(", ");
+			throw new Error(`${prefix} check arguments error: ${message}`);
+		}
+		throw error;
+	}
+}
+function getExpectedTypes(issue) {
+	if (Array.isArray(issue)) return issue.flatMap((issue$1) => getExpectedTypes(issue$1));
+	if ("expected" in issue) return [String(issue.expected)];
+	if (issue.code === "invalid_union") return issue.unionErrors.flatMap((e) => getExpectedTypes(e.issues));
+	return [];
+}
+function tryOrThrow(fn, error) {
+	const createError = (e) => {
+		return typeof error === "function" ? error(e) : typeof error === "string" ? new Error(error) : error;
+	};
+	try {
+		const result = fn();
+		if (result instanceof Promise) return result.catch((e) => {
+			const error$1 = createError(e);
+			if (error$1) throw error$1;
+		});
+		return result;
+	} catch (e) {
+		const error$1 = createError(e);
+		if (error$1) throw error$1;
+	}
+}
+function partition(array, predicate) {
+	const pass = [];
+	const fail = [];
+	for (const item of array) if (predicate(item)) pass.push(item);
+	else fail.push(item);
+	return [pass, fail];
+}
+
+//#endregion
+exports.checkArguments = checkArguments;
+exports.createAccessorArray = createAccessorArray;
+exports.duplicates = duplicates;
+exports.flat = flat;
+exports.get = get;
+exports.isEmpty = isEmpty;
+exports.isNil = isNil;
+exports.isNonNullable = isNonNullable;
+exports.isNotEmpty = isNotEmpty;
+exports.isRecord = isRecord;
+exports.omit = omit;
+exports.omitBy = omitBy;
+exports.omitByDeep = omitByDeep;
+exports.omitDeep = omitDeep;
+exports.partition = partition;
+exports.pick = pick;
+exports.remove = remove;
+exports.tryOrThrow = tryOrThrow;
+exports.unique = unique;

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

@@ -0,0 +1,32 @@
+import { ZodType, z } from "zod";
+
+//#region src/utils/type-utils.d.ts
+type PromiseOrValue<T> = T | Promise<T>;
+type Nullish<T> = T | null | undefined | void;
+type OmitPropertiesFromArrayFirstElement<T extends unknown[], K extends string | number | symbol> = T extends [infer U, ...infer Rest] ? [Omit<U, K>, ...Rest] : never;
+type XOr<T, K extends keyof T, O extends keyof T> = (Omit<T, O> & { [key in O]?: undefined }) | (Omit<T, K> & { [key in K]?: undefined });
+declare function isNil(value: unknown): value is null | undefined;
+declare function isRecord<T>(value: unknown): value is Record<string, T>;
+declare function isEmpty(obj: unknown): boolean;
+declare function isNonNullable<T>(value: T): value is NonNullable<T>;
+declare function isNotEmpty<T>(arr: T[]): arr is [T, ...T[]];
+declare function duplicates<T>(arr: T[], key?: (item: T) => unknown): T[];
+declare function remove<T>(arr: T[], remove: T[] | ((item: T) => boolean)): T[];
+declare function unique<T>(arr: T[], key?: (item: T) => unknown): T[];
+declare function get(obj: any, path: (string | number | symbol)[]): any;
+declare function pick<T extends object, K extends keyof T>(obj: T, ...keys: (K | K[])[]): Pick<T, K>;
+declare function omit<T extends object, K extends keyof T>(obj: T, ...keys: (K | K[])[]): Omit<T, K>;
+declare function omitDeep<T, K>(obj: T, ...keys: (K | K[])[]): unknown;
+declare function omitBy<T extends object, K extends keyof T>(obj: T, predicate: (value: T[K], key: K) => boolean): Partial<T>;
+declare function omitByDeep(obj: any, predicate: (value: any, key: any) => boolean): any;
+declare function flat<T>(...value: (T | T[])[]): NonNullable<T>[];
+declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {
+  [key: string]: T;
+};
+declare function checkArguments<T extends ZodType>(prefix: string, schema: T, args: unknown): z.infer<T>;
+declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error: string | Error | ((error: Error) => Error)): P;
+declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error?: Nullish<string | Error | ((error: Error) => Nullish<Error>)>): P | undefined;
+declare function partition<T>(array: T[], predicate: (item: T) => boolean): [T[], T[]];
+//#endregion
+export { Nullish, OmitPropertiesFromArrayFirstElement, PromiseOrValue, XOr, checkArguments, createAccessorArray, duplicates, flat, get, isEmpty, isNil, isNonNullable, isNotEmpty, isRecord, omit, omitBy, omitByDeep, omitDeep, partition, pick, remove, tryOrThrow, unique };
+//# sourceMappingURL=type-utils.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"type-utils.d.cts","names":[],"sources":["../../src/utils/type-utils.ts"],"mappings":";;;KAEY,cAAA,MAAoB,CAAA,GAAI,OAAA,CAAQ,CAAA;AAAA,KAEhC,OAAA,MAAa,CAAA;AAAA,KAEb,mCAAA,4DAGR,CAAA,qCAAsC,IAAA,CAAK,CAAA,EAAG,CAAA,MAAO,IAAA;AAAA,KAE7C,GAAA,oBAAuB,CAAA,kBAAmB,CAAA,KACjD,IAAA,CAAK,CAAA,EAAG,CAAA,cAAe,CAAA,oBACvB,IAAA,CAAK,CAAA,EAAG,CAAA,cAAe,CAAA;AAAA,iBAEZ,KAAA,CAAA,KAAA,YAAA,KAAA;AAAA,iBAIA,QAAA,GAAA,CAAA,KAAA,YAAA,KAAA,IAAsC,MAAA,SAAe,CAAA;AAAA,iBAIrD,OAAA,CAAA,GAAA;AAAA,iBAOA,aAAA,GAAA,CAAA,KAAA,EAAwB,CAAA,GAAA,KAAA,IAAa,WAAA,CAAY,CAAA;AAAA,iBAIjD,UAAA,GAAA,CAAA,GAAA,EAAmB,CAAA,KAAA,GAAA,KAAc,CAAA,KAAM,CAAA;AAAA,iBAIvC,UAAA,GAAA,CAAA,GAAA,EAAmB,CAAA,IAAA,GAAA,IAAA,IAAA,EAAiB,CAAA,eAAoC,CAAA;AAAA,iBAcxE,MAAA,GAAA,CAAA,GAAA,EAAe,CAAA,IAAA,MAAA,EAAa,CAAA,OAAA,IAAA,EAAc,CAAA,gBAAiB,CAAA;AAAA,iBAiB3D,MAAA,GAAA,CAAA,GAAA,EAAe,CAAA,IAAA,GAAA,IAAA,IAAA,EAAiB,CAAA,eAAoC,CAAA;AAAA,iBAcpE,GAAA,CAAA,GAAA,OAAA,IAAA;AAAA,iBAIA,IAAA,mCAAuC,CAAA,CAAA,CAAA,GAAA,EAChD,CAAA,KAAA,IAAA,GACK,CAAA,GAAI,CAAA,QACb,IAAA,CAAK,CAAA,EAAG,CAAA;AAAA,iBAOK,IAAA,mCAAuC,CAAA,CAAA,CAAA,GAAA,EAChD,CAAA,KAAA,IAAA,GACK,CAAA,GAAI,CAAA,QACb,IAAA,CAAK,CAAA,EAAG,CAAA;AAAA,iBAOK,QAAA,MAAA,CAAA,GAAA,EAAoB,CAAA,KAAA,IAAA,GAAa,CAAA,GAAI,CAAA;AAAA,iBAerC,MAAA,mCAAyC,CAAA,CAAA,CAAA,GAAA,EAClD,CAAA,EAAA,SAAA,GAAA,KAAA,EACc,CAAA,CAAE,CAAA,GAAA,GAAA,EAAS,CAAA,eAC7B,OAAA,CAAQ,CAAA;AAAA,iBASK,UAAA,CAAA,GAAA,OAAA,SAAA,GAAA,KAAA,OAAA,GAAA;AAAA,iBAuBA,IAAA,GAAA,CAAA,GAAA,KAAA,GAAmB,CAAA,GAAI,CAAA,QAAS,WAAA,CAAY,CAAA;AAAA,iBAI5C,mBAAA,GAAA,CAAA,KAAA,EACP,CAAA,IAAA,QAAA,GAAA,KAAA,EACW,CAAA,IAAA,IAAA,aAAsB,CAAA,eACvC,CAAA;EAAA,CAAA,GAAA,WAAuB,CAAA;AAAA;AAAA,iBAMV,cAAA,WAAyB,OAAA,CAAA,CAAA,MAAA,UAAA,MAAA,EAE/B,CAAA,EAAA,IAAA,YAEP,CAAA,CAAE,KAAA,CAAM,CAAA;AAAA,iBAgCK,UAAA,WAAqB,cAAA,UAAA,CAAA,EAAA,QACzB,CAAA,EAAA,KAAA,WACM,KAAA,KAAA,KAAA,EAAiB,KAAA,KAAU,KAAA,IAC1C,CAAA;AAAA,iBACa,UAAA,WAAqB,cAAA,UAAA,CAAA,EAAA,QACzB,CAAA,EAAA,KAAA,GACF,OAAA,UAAiB,KAAA,KAAA,KAAA,EAAiB,KAAA,KAAU,OAAA,CAAQ,KAAA,MAC3D,CAAA;AAAA,iBA8Ba,SAAA,GAAA,CAAA,KAAA,EAAoB,CAAA,IAAA,SAAA,GAAA,IAAA,EAAuB,CAAA,gBAAiB,CAAA,IAAK,CAAA"}