@illuma-ai/agents 1.0.81

package/dist/esm/utils/title.mjs

@@ -0,0 +1,122 @@
+import { ChatPromptTemplate } from '@langchain/core/prompts';
+import { RunnableLambda, RunnableSequence } from '@langchain/core/runnables';
+import { ContentTypes } from '../common/enum.mjs';
+
+const defaultTitlePrompt = `Analyze this conversation and provide:
+1. The detected language of the conversation
+2. A concise title in the detected language (5 words or less, no punctuation or quotation)
+
+{convo}`;
+const titleSchema = {
+    type: 'object',
+    properties: {
+        title: {
+            type: 'string',
+            description: 'A concise title for the conversation in 5 words or less, without punctuation or quotation',
+        },
+    },
+    required: ['title'],
+};
+const combinedSchema = {
+    type: 'object',
+    properties: {
+        language: {
+            type: 'string',
+            description: 'The detected language of the conversation',
+        },
+        title: {
+            type: 'string',
+            description: 'A concise title for the conversation in 5 words or less, without punctuation or quotation',
+        },
+    },
+    required: ['language', 'title'],
+};
+const createTitleRunnable = async (model, _titlePrompt) => {
+    // Disabled since this works fine
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    /* @ts-ignore */
+    const titleLLM = model.withStructuredOutput(titleSchema);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    /* @ts-ignore */
+    const combinedLLM = model.withStructuredOutput(combinedSchema);
+    const titlePrompt = ChatPromptTemplate.fromTemplate(_titlePrompt ?? defaultTitlePrompt).withConfig({ runName: 'TitlePrompt' });
+    const titleOnlyInnerChain = RunnableSequence.from([titlePrompt, titleLLM]);
+    const combinedInnerChain = RunnableSequence.from([titlePrompt, combinedLLM]);
+    /** Wrap titleOnlyChain in RunnableLambda to create parent span */
+    const titleOnlyChain = new RunnableLambda({
+        func: async (input, config) => {
+            const result = await titleOnlyInnerChain.invoke(input, config);
+            return result;
+        },
+    }).withConfig({ runName: 'TitleOnlyChain' });
+    /** Wrap combinedChain in RunnableLambda to create parent span */
+    const combinedChain = new RunnableLambda({
+        func: async (input, config) => {
+            const result = await combinedInnerChain.invoke(input, config);
+            return result;
+        },
+    }).withConfig({ runName: 'TitleLanguageChain' });
+    /** Runnable to add default values if needed */
+    const addDefaults = new RunnableLambda({
+        func: (result) => ({
+            language: result?.language ?? 'English',
+            title: result?.title ?? '',
+        }),
+    }).withConfig({ runName: 'AddDefaults' });
+    const combinedChainInner = RunnableSequence.from([
+        combinedChain,
+        addDefaults,
+    ]);
+    /** Wrap combinedChainWithDefaults in RunnableLambda to create parent span */
+    const combinedChainWithDefaults = new RunnableLambda({
+        func: async (input, config) => {
+            return await combinedChainInner.invoke(input, config);
+        },
+    }).withConfig({ runName: 'CombinedChainWithDefaults' });
+    return new RunnableLambda({
+        func: async (input, config) => {
+            const invokeInput = { convo: input.convo };
+            if (input.skipLanguage) {
+                return (await titleOnlyChain.invoke(invokeInput, config));
+            }
+            return await combinedChainWithDefaults.invoke(invokeInput, config);
+        },
+    }).withConfig({ runName: 'TitleGenerator' });
+};
+const defaultCompletionPrompt = `Provide a concise, 5-word-or-less title for the conversation, using title case conventions. Only return the title itself.
+
+Conversation:
+{convo}`;
+const createCompletionTitleRunnable = async (model, titlePrompt) => {
+    const completionPrompt = ChatPromptTemplate.fromTemplate(titlePrompt ?? defaultCompletionPrompt).withConfig({ runName: 'CompletionTitlePrompt' });
+    /** Runnable to extract content from model response */
+    const extractContent = new RunnableLambda({
+        func: (response) => {
+            let content = '';
+            if (typeof response.content === 'string') {
+                content = response.content;
+            }
+            else if (Array.isArray(response.content)) {
+                content = response.content
+                    .filter((part) => part.type === ContentTypes.TEXT)
+                    .map((part) => part.text)
+                    .join('');
+            }
+            return { title: content.trim() };
+        },
+    }).withConfig({ runName: 'ExtractTitle' });
+    const innerChain = RunnableSequence.from([
+        completionPrompt,
+        model,
+        extractContent,
+    ]);
+    /** Wrap in RunnableLambda to create a parent span for LangFuse */
+    return new RunnableLambda({
+        func: async (input, config) => {
+            return await innerChain.invoke(input, config);
+        },
+    }).withConfig({ runName: 'CompletionTitleChain' });
+};
+
+export { createCompletionTitleRunnable, createTitleRunnable };
+//# sourceMappingURL=title.mjs.map

package/dist/esm/utils/title.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"title.mjs","sources":["../../../src/utils/title.ts"],"sourcesContent":["import { ChatPromptTemplate } from '@langchain/core/prompts';\nimport { RunnableLambda, RunnableSequence } from '@langchain/core/runnables';\nimport type { Runnable, RunnableConfig } from '@langchain/core/runnables';\nimport type { AIMessage } from '@langchain/core/messages';\nimport type * as t from '@/types';\nimport { ContentTypes } from '@/common';\n\nconst defaultTitlePrompt = `Analyze this conversation and provide:\n1. The detected language of the conversation\n2. A concise title in the detected language (5 words or less, no punctuation or quotation)\n\n{convo}`;\n\nconst titleSchema = {\n  type: 'object',\n  properties: {\n    title: {\n      type: 'string',\n      description:\n        'A concise title for the conversation in 5 words or less, without punctuation or quotation',\n    },\n  },\n  required: ['title'],\n} as const;\n\nconst combinedSchema = {\n  type: 'object',\n  properties: {\n    language: {\n      type: 'string',\n      description: 'The detected language of the conversation',\n    },\n    title: {\n      type: 'string',\n      description:\n        'A concise title for the conversation in 5 words or less, without punctuation or quotation',\n    },\n  },\n  required: ['language', 'title'],\n} as const;\n\nexport const createTitleRunnable = async (\n  model: t.ChatModelInstance,\n  _titlePrompt?: string\n): Promise<Runnable> => {\n  // Disabled since this works fine\n  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  /* @ts-ignore */\n  const titleLLM = model.withStructuredOutput(titleSchema);\n  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  /* @ts-ignore */\n  const combinedLLM = model.withStructuredOutput(combinedSchema);\n\n  const titlePrompt = ChatPromptTemplate.fromTemplate(\n    _titlePrompt ?? defaultTitlePrompt\n  ).withConfig({ runName: 'TitlePrompt' });\n\n  const titleOnlyInnerChain = RunnableSequence.from([titlePrompt, titleLLM]);\n  const combinedInnerChain = RunnableSequence.from([titlePrompt, combinedLLM]);\n\n  /** Wrap titleOnlyChain in RunnableLambda to create parent span */\n  const titleOnlyChain = new RunnableLambda({\n    func: async (\n      input: { convo: string },\n      config?: Partial<RunnableConfig>\n    ): Promise<{ title: string }> => {\n      const result = await titleOnlyInnerChain.invoke(input, config);\n      return result as { title: string };\n    },\n  }).withConfig({ runName: 'TitleOnlyChain' });\n\n  /** Wrap combinedChain in RunnableLambda to create parent span */\n  const combinedChain = new RunnableLambda({\n    func: async (\n      input: { convo: string },\n      config?: Partial<RunnableConfig>\n    ): Promise<{ language: string; title: string }> => {\n      const result = await combinedInnerChain.invoke(input, config);\n      return result as { language: string; title: string };\n    },\n  }).withConfig({ runName: 'TitleLanguageChain' });\n\n  /** Runnable to add default values if needed */\n  const addDefaults = new RunnableLambda({\n    func: (\n      result: { language: string; title: string } | undefined\n    ): { language: string; title: string } => ({\n      language: result?.language ?? 'English',\n      title: result?.title ?? '',\n    }),\n  }).withConfig({ runName: 'AddDefaults' });\n\n  const combinedChainInner = RunnableSequence.from([\n    combinedChain,\n    addDefaults,\n  ]);\n\n  /** Wrap combinedChainWithDefaults in RunnableLambda to create parent span */\n  const combinedChainWithDefaults = new RunnableLambda({\n    func: async (\n      input: { convo: string },\n      config?: Partial<RunnableConfig>\n    ): Promise<{ language: string; title: string }> => {\n      return await combinedChainInner.invoke(input, config);\n    },\n  }).withConfig({ runName: 'CombinedChainWithDefaults' });\n\n  return new RunnableLambda({\n    func: async (\n      input: {\n        convo: string;\n        inputText: string;\n        skipLanguage: boolean;\n      },\n      config?: Partial<RunnableConfig>\n    ): Promise<{ language: string; title: string } | { title: string }> => {\n      const invokeInput = { convo: input.convo };\n\n      if (input.skipLanguage) {\n        return (await titleOnlyChain.invoke(invokeInput, config)) as {\n          title: string;\n        };\n      }\n\n      return await combinedChainWithDefaults.invoke(invokeInput, config);\n    },\n  }).withConfig({ runName: 'TitleGenerator' });\n};\n\nconst defaultCompletionPrompt = `Provide a concise, 5-word-or-less title for the conversation, using title case conventions. Only return the title itself.\n\nConversation:\n{convo}`;\n\nexport const createCompletionTitleRunnable = async (\n  model: t.ChatModelInstance,\n  titlePrompt?: string\n): Promise<Runnable> => {\n  const completionPrompt = ChatPromptTemplate.fromTemplate(\n    titlePrompt ?? defaultCompletionPrompt\n  ).withConfig({ runName: 'CompletionTitlePrompt' });\n\n  /** Runnable to extract content from model response */\n  const extractContent = new RunnableLambda({\n    func: (response: AIMessage): { title: string } => {\n      let content = '';\n      if (typeof response.content === 'string') {\n        content = response.content;\n      } else if (Array.isArray(response.content)) {\n        content = response.content\n          .filter(\n            (part): part is { type: ContentTypes.TEXT; text: string } =>\n              part.type === ContentTypes.TEXT\n          )\n          .map((part) => part.text)\n          .join('');\n      }\n      return { title: content.trim() };\n    },\n  }).withConfig({ runName: 'ExtractTitle' });\n\n  const innerChain = RunnableSequence.from([\n    completionPrompt,\n    model,\n    extractContent,\n  ]);\n\n  /** Wrap in RunnableLambda to create a parent span for LangFuse */\n  return new RunnableLambda({\n    func: async (\n      input: { convo: string },\n      config?: Partial<RunnableConfig>\n    ): Promise<{ title: string }> => {\n      return await innerChain.invoke(input, config);\n    },\n  }).withConfig({ runName: 'CompletionTitleChain' });\n};\n"],"names":[],"mappings":"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"}

package/dist/esm/utils/tokens.mjs

@@ -0,0 +1,121 @@
+import { getEncoding } from 'js-tiktoken';
+import { ContentTypes } from '../common/enum.mjs';
+
+function getTokenCountForMessage(message, getTokenCount) {
+    const tokensPerMessage = 3;
+    const processValue = (value) => {
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (!item ||
+                    !item.type ||
+                    item.type === ContentTypes.ERROR ||
+                    item.type === ContentTypes.IMAGE_URL) {
+                    continue;
+                }
+                if (item.type === ContentTypes.TOOL_CALL && item.tool_call != null) {
+                    const toolName = item.tool_call?.name || '';
+                    if (toolName != null && toolName && typeof toolName === 'string') {
+                        numTokens += getTokenCount(toolName);
+                    }
+                    const args = item.tool_call?.args || '';
+                    if (args != null && args && typeof args === 'string') {
+                        numTokens += getTokenCount(args);
+                    }
+                    const output = item.tool_call?.output || '';
+                    if (output != null && output && typeof output === 'string') {
+                        numTokens += getTokenCount(output);
+                    }
+                    continue;
+                }
+                const nestedValue = item[item.type];
+                if (!nestedValue) {
+                    continue;
+                }
+                processValue(nestedValue);
+            }
+        }
+        else if (typeof value === 'string') {
+            numTokens += getTokenCount(value);
+        }
+        else if (typeof value === 'number') {
+            numTokens += getTokenCount(value.toString());
+        }
+        else if (typeof value === 'boolean') {
+            numTokens += getTokenCount(value.toString());
+        }
+    };
+    let numTokens = tokensPerMessage;
+    processValue(message.content);
+    return numTokens;
+}
+let encoderPromise;
+let tokenCounterPromise;
+/**
+ * Simple character-based token estimation (~4 chars per token).
+ * Used as fallback when tiktoken encoder fails to load.
+ */
+const estimateTokens = (text) => Math.ceil(text.length / 4);
+async function getSharedEncoder() {
+    if (encoderPromise) {
+        return encoderPromise;
+    }
+    // Use bundled tokenizer data - no external network calls
+    encoderPromise = Promise.resolve().then(() => {
+        try {
+            return getEncoding('o200k_base');
+        }
+        catch {
+            // Fallback to null - will use character estimation
+            return null;
+        }
+    });
+    return encoderPromise;
+}
+/**
+ * Creates a singleton token counter function that reuses the same encoder instance.
+ * Falls back to character-based estimation (~4 chars per token) if encoder fails.
+ * This ensures token counting never blocks LLM calls.
+ */
+const createTokenCounter = async () => {
+    if (tokenCounterPromise) {
+        return tokenCounterPromise;
+    }
+    tokenCounterPromise = (async () => {
+        const enc = await getSharedEncoder();
+        const countTokens = enc
+            ? (text) => enc.encode(text).length
+            : estimateTokens;
+        return (message) => getTokenCountForMessage(message, countTokens);
+    })();
+    return tokenCounterPromise;
+};
+/**
+ * Utility to manage the token encoder lifecycle explicitly.
+ * Useful for applications that need fine-grained control over resource management.
+ */
+const TokenEncoderManager = {
+    /**
+     * Pre-initializes the encoder. This can be called during app startup
+     * to avoid lazy loading delays later.
+     */
+    async initialize() {
+        await getSharedEncoder();
+    },
+    /**
+     * Clears the cached encoder and token counter.
+     * Useful for testing or when you need to force a fresh reload.
+     */
+    reset() {
+        encoderPromise = undefined;
+        tokenCounterPromise = undefined;
+    },
+    /**
+     * Checks if the encoder has been initialized.
+     */
+    isInitialized() {
+        return encoderPromise !== undefined;
+    },
+};
+
+export { TokenEncoderManager, createTokenCounter, getTokenCountForMessage };
+//# sourceMappingURL=tokens.mjs.map

package/dist/esm/utils/tokens.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.mjs","sources":["../../../src/utils/tokens.ts"],"sourcesContent":["import { getEncoding, type Tiktoken } from 'js-tiktoken';\nimport type { BaseMessage } from '@langchain/core/messages';\nimport { ContentTypes } from '@/common/enum';\n\nexport function getTokenCountForMessage(\n  message: BaseMessage,\n  getTokenCount: (text: string) => number\n): number {\n  const tokensPerMessage = 3;\n\n  const processValue = (value: unknown): void => {\n    if (Array.isArray(value)) {\n      for (const item of value) {\n        if (\n          !item ||\n          !item.type ||\n          item.type === ContentTypes.ERROR ||\n          item.type === ContentTypes.IMAGE_URL\n        ) {\n          continue;\n        }\n\n        if (item.type === ContentTypes.TOOL_CALL && item.tool_call != null) {\n          const toolName = item.tool_call?.name || '';\n          if (toolName != null && toolName && typeof toolName === 'string') {\n            numTokens += getTokenCount(toolName);\n          }\n\n          const args = item.tool_call?.args || '';\n          if (args != null && args && typeof args === 'string') {\n            numTokens += getTokenCount(args);\n          }\n\n          const output = item.tool_call?.output || '';\n          if (output != null && output && typeof output === 'string') {\n            numTokens += getTokenCount(output);\n          }\n          continue;\n        }\n\n        const nestedValue = item[item.type];\n\n        if (!nestedValue) {\n          continue;\n        }\n\n        processValue(nestedValue);\n      }\n    } else if (typeof value === 'string') {\n      numTokens += getTokenCount(value);\n    } else if (typeof value === 'number') {\n      numTokens += getTokenCount(value.toString());\n    } else if (typeof value === 'boolean') {\n      numTokens += getTokenCount(value.toString());\n    }\n  };\n\n  let numTokens = tokensPerMessage;\n  processValue(message.content);\n  return numTokens;\n}\n\nlet encoderPromise: Promise<Tiktoken | null> | undefined;\nlet tokenCounterPromise: Promise<(message: BaseMessage) => number> | undefined;\n\n/**\n * Simple character-based token estimation (~4 chars per token).\n * Used as fallback when tiktoken encoder fails to load.\n */\nconst estimateTokens = (text: string): number => Math.ceil(text.length / 4);\n\nasync function getSharedEncoder(): Promise<Tiktoken | null> {\n  if (encoderPromise) {\n    return encoderPromise;\n  }\n  // Use bundled tokenizer data - no external network calls\n  encoderPromise = Promise.resolve().then(() => {\n    try {\n      return getEncoding('o200k_base');\n    } catch {\n      // Fallback to null - will use character estimation\n      return null;\n    }\n  });\n  return encoderPromise;\n}\n\n/**\n * Creates a singleton token counter function that reuses the same encoder instance.\n * Falls back to character-based estimation (~4 chars per token) if encoder fails.\n * This ensures token counting never blocks LLM calls.\n */\nexport const createTokenCounter = async (): Promise<\n  (message: BaseMessage) => number\n> => {\n  if (tokenCounterPromise) {\n    return tokenCounterPromise;\n  }\n\n  tokenCounterPromise = (async (): Promise<\n    (message: BaseMessage) => number\n  > => {\n    const enc = await getSharedEncoder();\n    const countTokens = enc\n      ? (text: string): number => enc.encode(text).length\n      : estimateTokens;\n    return (message: BaseMessage): number =>\n      getTokenCountForMessage(message, countTokens);\n  })();\n\n  return tokenCounterPromise;\n};\n\n/**\n * Utility to manage the token encoder lifecycle explicitly.\n * Useful for applications that need fine-grained control over resource management.\n */\nexport const TokenEncoderManager = {\n  /**\n   * Pre-initializes the encoder. This can be called during app startup\n   * to avoid lazy loading delays later.\n   */\n  async initialize(): Promise<void> {\n    await getSharedEncoder();\n  },\n\n  /**\n   * Clears the cached encoder and token counter.\n   * Useful for testing or when you need to force a fresh reload.\n   */\n  reset(): void {\n    encoderPromise = undefined;\n    tokenCounterPromise = undefined;\n  },\n\n  /**\n   * Checks if the encoder has been initialized.\n   */\n  isInitialized(): boolean {\n    return encoderPromise !== undefined;\n  },\n};\n"],"names":[],"mappings":"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"}

package/dist/esm/utils/toonFormat.mjs

@@ -0,0 +1,381 @@
+/**
+ * TOON Format Utility
+ *
+ * Provides JSON to TOON conversion for token-efficient encoding.
+ * TOON format can reduce token count by 30-60% for JSON data.
+ *
+ * Uses the official @toon-format/toon library when available.
+ */
+// Dynamic import holder for the TOON library (ESM)
+let toonEncode = null;
+let toonLoadAttempted = false;
+let toonLoadPromise = null;
+/**
+ * Lazily loads the TOON library
+ * Tries both ESM dynamic import and CommonJS require for compatibility
+ */
+async function loadToonLibrary() {
+    if (toonLoadAttempted)
+        return toonEncode !== null;
+    toonLoadAttempted = true;
+    // Try ESM dynamic import first
+    try {
+        const mod = await import('@toon-format/toon');
+        toonEncode = mod.encode;
+        return true;
+    }
+    catch {
+        // ESM import failed, try CommonJS require
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const mod = require('@toon-format/toon');
+            toonEncode = mod.encode;
+            return true;
+        }
+        catch {
+            // Library not available - that's OK, we'll return original content
+            return false;
+        }
+    }
+}
+/**
+ * Ensures the TOON library is loaded. Call this before using jsonToToon in tests.
+ */
+async function ensureToonLoaded() {
+    if (!toonLoadPromise) {
+        toonLoadPromise = loadToonLibrary();
+    }
+    return toonLoadPromise;
+}
+// Start loading immediately
+ensureToonLoaded();
+/**
+ * Check if a string appears to be in TOON format.
+ * TOON format characteristics:
+ * - Uses key: value syntax (like YAML)
+ * - Uses array notation like [3] or {fields}
+ * - Does NOT start with { or [
+ * - Often has patterns like "name[N]:" or "name{fields}:"
+ *
+ * @param str - String to check
+ * @returns true if string appears to be TOON format
+ */
+function isToonFormat(str) {
+    if (typeof str !== 'string' || str.length === 0)
+        return false;
+    const trimmed = str.trim();
+    // TOON doesn't start with JSON brackets
+    if (trimmed.startsWith('{') || trimmed.startsWith('['))
+        return false;
+    // Check for TOON-specific patterns:
+    // 1. Key-value with colon (but not URL-like patterns)
+    // 2. Array notation like "items[3]:" or "data[10]:"
+    // 3. Object schema notation like "items{id,name}:"
+    const toonPatterns = [
+        /^\w+:$/m, // Simple key: at start of line
+        /^\w+\[\d+\]:/m, // Array notation: items[3]:
+        /^\w+\{[^}]+\}:/m, // Schema notation: items{id,name}:
+        /^\w+\[\d+\]\{[^}]+\}:/m, // Combined: items[3]{id,name}:
+    ];
+    // Must match at least one TOON pattern
+    const hasToonPattern = toonPatterns.some((pattern) => pattern.test(trimmed));
+    // Additional check: TOON typically has multiple lines with consistent indentation
+    const lines = trimmed.split('\n').filter((l) => l.trim());
+    const hasMultipleKeyValueLines = lines.filter((l) => /^\s*\w+.*:/.test(l)).length >= 2;
+    return hasToonPattern || hasMultipleKeyValueLines;
+}
+/**
+ * Extract the first valid JSON object or array from a string.
+ * Handles pure JSON or JSON embedded in text (e.g., tool responses).
+ *
+ * @param str - The string to extract JSON from
+ * @returns Object with found status, parsed JSON, and indices
+ */
+function extractFirstJson(str) {
+    if (typeof str !== 'string' || str.length === 0) {
+        return { found: false, parsed: null, startIndex: -1, endIndex: -1 };
+    }
+    // Find the first { or [ character
+    const objStart = str.indexOf('{');
+    const arrStart = str.indexOf('[');
+    if (objStart === -1 && arrStart === -1) {
+        return { found: false, parsed: null, startIndex: -1, endIndex: -1 };
+    }
+    let startIndex;
+    if (objStart === -1) {
+        startIndex = arrStart;
+    }
+    else if (arrStart === -1) {
+        startIndex = objStart;
+    }
+    else {
+        startIndex = Math.min(objStart, arrStart);
+    }
+    // Find the matching closing bracket using a stack-based approach
+    // Properly handle strings to avoid counting brackets inside strings
+    let depth = 0;
+    let inString = false;
+    let escapeNext = false;
+    for (let i = startIndex; i < str.length; i++) {
+        const char = str[i];
+        if (escapeNext) {
+            escapeNext = false;
+            continue;
+        }
+        if (char === '\\' && inString) {
+            escapeNext = true;
+            continue;
+        }
+        if (char === '"') {
+            inString = !inString;
+            continue;
+        }
+        if (inString)
+            continue;
+        if (char === '{' || char === '[')
+            depth++;
+        if (char === '}' || char === ']')
+            depth--;
+        if (depth === 0) {
+            // Found matching bracket, try to parse
+            const jsonStr = str.substring(startIndex, i + 1);
+            try {
+                const parsed = JSON.parse(jsonStr);
+                return { found: true, parsed, startIndex, endIndex: i };
+            }
+            catch {
+                // Not valid JSON at this bracket level, continue searching
+                // Reset and look for the next JSON start after this position
+                const nextResult = extractFirstJson(str.substring(i + 1));
+                if (nextResult.found) {
+                    return {
+                        found: true,
+                        parsed: nextResult.parsed,
+                        startIndex: i + 1 + nextResult.startIndex,
+                        endIndex: i + 1 + nextResult.endIndex,
+                    };
+                }
+                return { found: false, parsed: null, startIndex: -1, endIndex: -1 };
+            }
+        }
+    }
+    return { found: false, parsed: null, startIndex: -1, endIndex: -1 };
+}
+/**
+ * Convert JSON content to TOON format for token efficiency.
+ * Extracts JSON from string if embedded, converts to TOON.
+ * Returns original string if:
+ * - Already in TOON format
+ * - Not JSON
+ * - TOON conversion fails or is larger
+ *
+ * @param str - The string containing JSON to convert
+ * @returns Object with conversion status, result, and reduction percentage
+ */
+function jsonToToon(str) {
+    if (!toonEncode || typeof str !== 'string') {
+        return {
+            converted: false,
+            result: str,
+            reduction: 0,
+            error: !toonEncode ? 'TOON library not loaded' : undefined,
+        };
+    }
+    // Check if already in TOON format - skip conversion
+    if (isToonFormat(str)) {
+        return { converted: false, result: str, reduction: 0, alreadyToon: true };
+    }
+    try {
+        const { found, parsed, startIndex, endIndex } = extractFirstJson(str);
+        if (!found || !parsed) {
+            return {
+                converted: false,
+                result: str,
+                reduction: 0,
+                error: 'No JSON found in content',
+            };
+        }
+        // Check if this JSON structure would benefit from TOON
+        // Text-heavy content (emails, documents) won't compress well
+        if (!isToonBeneficial(parsed)) {
+            return {
+                converted: false,
+                result: str,
+                reduction: 0,
+                error: 'Content is text-heavy (>70% string values), TOON not beneficial',
+            };
+        }
+        const toonResult = toonEncode(parsed);
+        // Preserve text before and after the JSON block
+        const textBefore = str.substring(0, startIndex);
+        const textAfter = str.substring(endIndex + 1);
+        // Build the full result: textBefore + TOON + textAfter
+        const fullResult = textBefore + toonResult + textAfter;
+        if (fullResult.length < str.length) {
+            const reduction = Math.round(((str.length - fullResult.length) / str.length) * 100);
+            return { converted: true, result: fullResult, reduction };
+        }
+        else {
+            // TOON output was larger or same size - not beneficial
+            return {
+                converted: false,
+                result: str,
+                reduction: 0,
+                error: `TOON output not smaller (${fullResult.length} >= ${str.length})`,
+            };
+        }
+    }
+    catch (err) {
+        // TOON encoding or extraction failed - log error for debugging
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        return {
+            converted: false,
+            result: str,
+            reduction: 0,
+            error: `TOON conversion error: ${errorMsg}`,
+        };
+    }
+}
+/**
+ * Check if TOON library is loaded and available
+ */
+function isToonAvailable() {
+    return toonEncode !== null;
+}
+/**
+ * Analyze JSON structure to determine if TOON conversion would be beneficial.
+ * Text-heavy content (emails, documents) doesn't compress well with TOON.
+ * Structured data (API responses, metadata) compresses much better.
+ *
+ * @param parsed - Parsed JSON object
+ * @returns true if TOON conversion is likely beneficial
+ */
+function isToonBeneficial(parsed) {
+    if (!parsed || typeof parsed !== 'object')
+        return false;
+    const jsonStr = JSON.stringify(parsed);
+    const totalLength = jsonStr.length;
+    // Count characters in string values (text content)
+    let textContentLength = 0;
+    function countTextContent(obj) {
+        if (typeof obj === 'string') {
+            // Count string length (this is text content that TOON can't compress)
+            textContentLength += obj.length;
+        }
+        else if (Array.isArray(obj)) {
+            obj.forEach(countTextContent);
+        }
+        else if (obj && typeof obj === 'object') {
+            Object.values(obj).forEach(countTextContent);
+        }
+    }
+    countTextContent(parsed);
+    // Calculate ratio of text content to total JSON
+    const textRatio = textContentLength / totalLength;
+    // If more than 70% is text content, TOON won't help much
+    // TOON compresses structure (field names, brackets), not text
+    return textRatio < 0.7;
+}
+/**
+ * Process tool output: apply TOON conversion if beneficial, then truncate if needed.
+ * This is the main entry point for processing any tool output (regular or MCP).
+ *
+ * Flow:
+ * 1. Check if already TOON format → skip conversion
+ * 2. Try TOON conversion if content is JSON and large enough
+ * 3. Truncate if still exceeds maxLength (with smart break points)
+ *
+ * @param content - The tool output content
+ * @param options - Processing options
+ * @returns Processed content and metadata
+ */
+function processToolOutput(content, options = {}) {
+    const { maxLength = 100000, enableToon = true, minSizeForToon = 1000, minReductionPercent = 10, // Increased from 5% - only apply TOON when clearly beneficial
+     } = options;
+    const originalLength = content.length;
+    const originalTokens = Math.ceil(originalLength / 4);
+    let result = content;
+    let toonConverted = false;
+    let alreadyToon = false;
+    let reduction = 0;
+    let truncated = false;
+    let toonError;
+    // Step 1: Check if already TOON format
+    if (isToonFormat(content)) {
+        alreadyToon = true;
+    }
+    // Step 2: Apply TOON conversion if enabled and content is large enough
+    else if (enableToon && content.length > minSizeForToon) {
+        const toonResult = jsonToToon(content);
+        if (toonResult.alreadyToon) {
+            alreadyToon = true;
+        }
+        else if (toonResult.converted &&
+            toonResult.reduction >= minReductionPercent) {
+            result = toonResult.result;
+            toonConverted = true;
+            reduction = toonResult.reduction;
+        }
+        else if (toonResult.error) {
+            // Track error for debugging
+            toonError = toonResult.error;
+        }
+        else if (toonResult.converted &&
+            toonResult.reduction < minReductionPercent) {
+            // TOON converted but reduction was too small to be worth it
+            toonError = `TOON reduction ${toonResult.reduction}% below threshold ${minReductionPercent}%`;
+        }
+        else if (!toonResult.converted) {
+            // Conversion failed without explicit error - investigate
+            toonError =
+                toonResult.error || 'TOON conversion returned false with no error';
+        }
+    }
+    // Step 3: Truncate if still too long (with smart break points)
+    if (result.length > maxLength) {
+        let truncatedStr = result.substring(0, maxLength);
+        // Try to find a clean break point
+        if (toonConverted || alreadyToon) {
+            // For TOON format, break at newline for cleaner output
+            const lastNewline = truncatedStr.lastIndexOf('\n');
+            if (lastNewline > maxLength * 0.7) {
+                truncatedStr = truncatedStr.substring(0, lastNewline);
+            }
+        }
+        else {
+            // For JSON, try to find a clean JSON break point
+            const lastCompleteItem = truncatedStr.lastIndexOf('},');
+            const lastArrayItem = truncatedStr.lastIndexOf('],');
+            const breakPoint = Math.max(lastCompleteItem, lastArrayItem);
+            if (breakPoint > maxLength * 0.5) {
+                truncatedStr = truncatedStr.substring(0, breakPoint + 1);
+            }
+        }
+        // Build truncation message
+        const truncationInfo = toonConverted
+            ? `Original ${originalLength.toLocaleString()} chars → TOON ${result.length.toLocaleString()} chars (${reduction}% saved). ` +
+                `Still exceeds ${maxLength.toLocaleString()} char limit.`
+            : `Original output was ${originalLength.toLocaleString()} characters (~${originalTokens.toLocaleString()} tokens).`;
+        result =
+            truncatedStr +
+                `\n\n[OUTPUT_TRUNCATED: ${truncationInfo} Please use more specific queries or smaller date ranges.]`;
+        truncated = true;
+    }
+    const finalLength = result.length;
+    const finalTokens = Math.ceil(finalLength / 4);
+    return {
+        content: result,
+        toonConverted,
+        truncated,
+        reduction,
+        alreadyToon,
+        originalLength,
+        originalTokens,
+        finalLength,
+        finalTokens,
+        toonError,
+    };
+}
+
+export { ensureToonLoaded, extractFirstJson, isToonAvailable, isToonFormat, jsonToToon, processToolOutput };
+//# sourceMappingURL=toonFormat.mjs.map