@nanocollective/nanocoder 1.22.5 → 1.23.0

package/dist/utils/question-queue.d.ts

@@ -0,0 +1,15 @@
+export interface PendingQuestion {
+    question: string;
+    options: string[];
+    allowFreeform: boolean;
+}
+/**
+ * Called once from App.tsx to wire up the UI handler.
+ */
+export declare function setGlobalQuestionHandler(handler: (question: PendingQuestion) => Promise<string>): void;
+/**
+ * Called from the ask_question tool's execute function.
+ * Returns a Promise that resolves with the user's answer string.
+ */
+export declare function signalQuestion(question: PendingQuestion): Promise<string>;
+//# sourceMappingURL=question-queue.d.ts.map

package/dist/utils/question-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"question-queue.d.ts","sourceRoot":"","sources":["../../source/utils/question-queue.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,eAAe;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,aAAa,EAAE,OAAO,CAAC;CACvB;AAQD;;GAEG;AACH,wBAAgB,wBAAwB,CACvC,OAAO,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,OAAO,CAAC,MAAM,CAAC,QAGvD;AAED;;;GAGG;AACH,wBAAsB,cAAc,CACnC,QAAQ,EAAE,eAAe,GACvB,OAAO,CAAC,MAAM,CAAC,CAKjB"}

package/dist/utils/question-queue.js

@@ -0,0 +1,25 @@
+// Global question queue - allows the ask_question tool to present
+// interactive questions to the user via the UI.
+//
+// Pattern mirrors message-queue.tsx: a module-level singleton handler
+// set by App.tsx, called from the tool's execute function.
+// The handler set by App.tsx. It receives the question data and returns
+// a Promise<string> that resolves when the user picks an answer.
+let globalQuestionHandler = null;
+/**
+ * Called once from App.tsx to wire up the UI handler.
+ */
+export function setGlobalQuestionHandler(handler) {
+    globalQuestionHandler = handler;
+}
+/**
+ * Called from the ask_question tool's execute function.
+ * Returns a Promise that resolves with the user's answer string.
+ */
+export async function signalQuestion(question) {
+    if (!globalQuestionHandler) {
+        return 'Error: Question handler not initialized. The UI is not ready to accept questions.';
+    }
+    return globalQuestionHandler(question);
+}
+//# sourceMappingURL=question-queue.js.map

package/dist/utils/question-queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"question-queue.js","sourceRoot":"","sources":["../../source/utils/question-queue.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,gDAAgD;AAChD,EAAE;AACF,sEAAsE;AACtE,2DAA2D;AAQ3D,wEAAwE;AACxE,iEAAiE;AACjE,IAAI,qBAAqB,GAEf,IAAI,CAAC;AAEf;;GAEG;AACH,MAAM,UAAU,wBAAwB,CACvC,OAAuD;IAEvD,qBAAqB,GAAG,OAAO,CAAC;AACjC,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CACnC,QAAyB;IAEzB,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC5B,OAAO,mFAAmF,CAAC;IAC5F,CAAC;IACD,OAAO,qBAAqB,CAAC,QAAQ,CAAC,CAAC;AACxC,CAAC"}

package/dist/utils/response-formatter.d.ts

@@ -0,0 +1,108 @@
+/**
+ * TYPE PRESERVATION STRATEGY EXPLAINED
+ * =====================================
+ *
+ * "Preserving types" does NOT mean keeping everything as objects/arrays in memory.
+ * It means:
+ *
+ * 1. When receiving LLM responses (which can be ANY type):
+ *    - We accept unknown types (string, object, array, null, undefined)
+ *    - We convert to string ONLY for PARSING OPERATIONS
+ *    - We preserve the original type in the tool call structure
+ *
+ * 2. When storing ToolCall.arguments:
+ *    - MUST preserve as Record<string, unknown> (object type)
+ *    - NOT convert to string
+ *    - Enables direct property access without JSON.parse
+ *
+ * 3. When displaying/writing to disk:
+ *    - Convert to string for display/storage operations
+ *    - Use JSON.stringify for objects/arrays
+ *    - Use String() for primitives
+ *
+ * The confusion comes from mixing up:
+ * - "Preserve types in memory" (CRITICAL: ToolCall.arguments stays as object)
+ * - "Convert to string for processing" (NECESSARY: Parser expects strings)
+ *
+ * This formatter handles the INCOMING data, then the parser handles the
+ * conversion to ToolCall format with type preservation.
+ */
+import type { ToolCall } from '../types/index.js';
+/**
+ * Result of normalizing an LLM response
+ * Contains the raw response, processed content, extracted tool calls, and metadata
+ */
+export interface NormalizedResponse {
+    /** The original response from the LLM (unknown type for maximum flexibility) */
+    raw: unknown;
+    /** The content after normalization (always a string for parsing) */
+    content: string;
+    /** Any tool calls extracted during normalization */
+    toolCalls: ToolCall[];
+    /** Metadata about the response for debugging and strategy selection */
+    metadata: ResponseMetadata;
+}
+/**
+ * Metadata about the normalized response
+ * Used for:
+ * - Debugging and logging
+ * - Selecting the best parsing strategy
+ * - Error handling and recovery
+ */
+export interface ResponseMetadata {
+    /** Whether response contained markdown code blocks */
+    hasCodeBlocks: boolean;
+    /** Whether response contained XML tags */
+    hasXMLTags: boolean;
+    /** Whether response contained JSON tool call structures */
+    hasJSONBlocks: boolean;
+    /** Confidence level in the response type classification */
+    confidence: 'high' | 'medium' | 'low';
+    /** Detected response format */
+    detectedFormat: 'plain' | 'json' | 'xml' | 'mixed' | 'unknown';
+    /** Whether response appears to be malformed */
+    isMalformed: boolean;
+    /** Detected error if malformed */
+    malformedError?: string;
+}
+/**
+ * Main entry point for normalizing LLM responses
+ *
+ * This function handles all possible LLM response types:
+ * - Plain strings (most common)
+ * - JSON objects (with/without tool_calls field)
+ * - Arrays (line-based content)
+ * - Null/undefined (error responses)
+ * - Mixed content (text + tool calls embedded)
+ *
+ * @param response - The raw response from the LLM (can be any type)
+ * @param options - Configuration options
+ * @returns A normalized response with content and extracted tool calls
+ */
+export declare function normalizeLLMResponse(response: unknown, options?: NormalizeOptions): Promise<NormalizedResponse>;
+/**
+ * Formats a normalized response for debugging
+ *
+ * @param response - Normalized response to format
+ * @returns Formatted string for debugging
+ */
+export declare function formatNormalizedResponse(response: NormalizedResponse): string;
+/**
+ * Checks if a response is complete and ready for processing
+ *
+ * A response is complete if:
+ * 1. It has content
+ * 2. It has low confidence (means no tool calls were found, so no further processing needed)
+ * 3. It's not malformed
+ *
+ * @param response - Normalized response to check
+ * @returns True if response is complete
+ */
+export declare function isResponseComplete(response: NormalizedResponse): boolean;
+export interface NormalizeOptions {
+    /** If true, keeps the raw object structure instead of JSON.stringify */
+    preserveRawTypes?: boolean;
+    /** If true, extracts tool calls from mixed content (text + tool calls) */
+    allowMixedContent?: boolean;
+}
+//# sourceMappingURL=response-formatter.d.ts.map

package/dist/utils/response-formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-formatter.d.ts","sourceRoot":"","sources":["../../source/utils/response-formatter.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,eAAe,CAAC;AAM5C;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IAClC,gFAAgF;IAChF,GAAG,EAAE,OAAO,CAAC;IAEb,oEAAoE;IACpE,OAAO,EAAE,MAAM,CAAC;IAEhB,oDAAoD;IACpD,SAAS,EAAE,QAAQ,EAAE,CAAC;IAEtB,uEAAuE;IACvE,QAAQ,EAAE,gBAAgB,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAChC,sDAAsD;IACtD,aAAa,EAAE,OAAO,CAAC;IAEvB,0CAA0C;IAC1C,UAAU,EAAE,OAAO,CAAC;IAEpB,2DAA2D;IAC3D,aAAa,EAAE,OAAO,CAAC;IAEvB,2DAA2D;IAC3D,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IAEtC,+BAA+B;IAC/B,cAAc,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,SAAS,CAAC;IAE/D,+CAA+C;IAC/C,WAAW,EAAE,OAAO,CAAC;IAErB,kCAAkC;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;CACxB;AAMD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,oBAAoB,CACzC,QAAQ,EAAE,OAAO,EACjB,OAAO,GAAE,gBAAqB,GAC5B,OAAO,CAAC,kBAAkB,CAAC,CA4C7B;AAuVD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,CA0B7E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAOxE;AAMD,MAAM,WAAW,gBAAgB;IAChC,wEAAwE;IACxE,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B,0EAA0E;IAC1E,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC5B"}

package/dist/utils/response-formatter.js

@@ -0,0 +1,387 @@
+// source/utils/response-formatter.ts
+// ============================================================================
+// NORMALIZATION FUNCTIONS
+// ============================================================================
+/**
+ * Main entry point for normalizing LLM responses
+ *
+ * This function handles all possible LLM response types:
+ * - Plain strings (most common)
+ * - JSON objects (with/without tool_calls field)
+ * - Arrays (line-based content)
+ * - Null/undefined (error responses)
+ * - Mixed content (text + tool calls embedded)
+ *
+ * @param response - The raw response from the LLM (can be any type)
+ * @param options - Configuration options
+ * @returns A normalized response with content and extracted tool calls
+ */
+export async function normalizeLLMResponse(response, options = {}) {
+    const { preserveRawTypes = false, // If true, keeps object structure instead of JSON.stringify
+    allowMixedContent = true, // If true, extracts tool calls from mixed content
+     } = options;
+    // Step 1: Detect response type and convert to string for parsing
+    const { content, detectedFormat } = convertToProcessableString(response);
+    // Step 2: Extract tool calls from the content
+    const { toolCalls, malformedError } = await extractToolCalls(content, {
+        allowMixedContent,
+        detectedFormat,
+    });
+    // Step 3: Detect if response is malformed
+    const isMalformed = !toolCalls.length && hasMalformedPatterns(content);
+    // Step 4: Build metadata for debugging and strategy selection
+    // Check for JSON blocks in content - only match tool call patterns, not plain JSON objects
+    const hasCodeBlocks = /```/.test(content);
+    const hasJSONBlocks = /"name"\s*:\s*"[^"]+"\s*,\s*"arguments"\s*:\s*\{/.test(content);
+    const metadata = buildMetadata(content, {
+        hasCodeBlocks,
+        hasXMLTags: /<[^>]+>/.test(content),
+        hasJSONBlocks,
+        detectedFormat,
+        malformedError,
+        isMalformed,
+    }, toolCalls.length > 0);
+    return {
+        raw: preserveRawTypes ? response : undefined, // Only preserve if requested
+        content,
+        toolCalls,
+        metadata,
+    };
+}
+/**
+ * Converts any LLM response type to a string suitable for parsing
+ *
+ * Handles the following cases:
+ * 1. string → string (identity, already processable)
+ * 2. object → JSON.stringify (structured data)
+ * 3. array → JSON.stringify (array data)
+ * 4. null/undefined → empty string (error handling)
+ * 5. number/boolean → String() (primitive types)
+ *
+ * This conversion is NECESSARY because our parsers expect strings.
+ * The type preservation happens later in the ToolCall structure.
+ *
+ * @param response - Raw response from LLM (any type)
+ * @returns Object with processable string content and detected format
+ */
+function convertToProcessableString(response) {
+    let content;
+    let detectedFormat = 'plain';
+    // CASE 1: Plain string response (most common)
+    if (typeof response === 'string') {
+        content = response.trim();
+        // Check if it looks like a JSON structure
+        if (content.startsWith('{') && content.endsWith('}')) {
+            detectedFormat = 'json';
+            // Don't JSON.stringify a string that's already JSON - just use it as-is
+            // The parser will parse it correctly
+        }
+        // Check if it looks like XML
+        else if (content.startsWith('<') && content.endsWith('>')) {
+            detectedFormat = 'xml';
+            // Don't JSON.stringify a string that's already XML - just use it as-is
+            // The parser will parse it correctly
+        }
+        // Check for mixed content (text + tool calls)
+        else if (hasEmbeddedToolCallPatterns(content)) {
+            detectedFormat = 'mixed';
+            // Don't JSON.stringify - keep as plain string for parser to handle
+        }
+    }
+    // CASE 2: JSON object response (structured data)
+    else if (response !== null && typeof response === 'object') {
+        // Check if it has a tool_calls field (AI SDK format)
+        if ('tool_calls' in response || 'function' in response) {
+            detectedFormat = 'json';
+            // If it's already structured, we might not need JSON.stringify
+            // But for consistency with parsers, we still convert to string
+            content = JSON.stringify(response);
+        }
+        // Regular object (not a tool_calls response)
+        else {
+            detectedFormat = 'json';
+            content = JSON.stringify(response);
+        }
+    }
+    // CASE 3: Array response (line-based content)
+    else if (Array.isArray(response)) {
+        detectedFormat = 'mixed';
+        content = response.join('\n').trim();
+    }
+    // CASE 4: Primitives (number, boolean, null, undefined)
+    else {
+        // Convert primitives to strings
+        content = String(response);
+        // Empty string if null or undefined
+        if (response === null || response === undefined) {
+            content = '';
+        }
+    }
+    return { content, detectedFormat };
+}
+/**
+ * Extracts tool calls from normalized content
+ *
+ * This function uses the unified parser to extract tool calls from:
+ * - Plain text with embedded JSON/XML tool calls
+ * - JSON objects with tool_calls field
+ * - Mixed content (text + tool calls)
+ *
+ * @param content - Normalized content string
+ * @param options - Extraction options
+ * @returns Object with extracted tool calls and any malformed error
+ */
+async function extractToolCalls(content, options) {
+    const { allowMixedContent, detectedFormat } = options;
+    // If no content, no tool calls
+    if (!content) {
+        return { toolCalls: [] };
+    }
+    // CASE 1: Detected JSON format - try JSON parser
+    if (detectedFormat === 'json') {
+        try {
+            // Import here to avoid circular dependencies
+            const { parseJSONToolCalls } = await import('../tool-calling/json-parser.js');
+            const toolCalls = parseJSONToolCalls(content);
+            if (toolCalls.length > 0) {
+                return { toolCalls };
+            }
+        }
+        catch (error) {
+            // If JSON parsing fails, fall through to mixed content handling
+            console.warn('JSON parsing failed, trying mixed content:', error);
+        }
+    }
+    // CASE 2: Try XML parser
+    try {
+        const { XMLToolCallParser } = await import('../tool-calling/xml-parser.js');
+        // Check for malformed XML first
+        const malformedError = XMLToolCallParser.detectMalformedToolCall(content);
+        if (malformedError) {
+            return { toolCalls: [], malformedError: malformedError.error };
+        }
+        // Check if has XML tool calls
+        if (XMLToolCallParser.hasToolCalls(content)) {
+            const parsedCalls = XMLToolCallParser.parseToolCalls(content);
+            const toolCalls = XMLToolCallParser.convertToToolCalls(parsedCalls);
+            if (toolCalls.length > 0) {
+                return { toolCalls };
+            }
+        }
+    }
+    catch (error) {
+        // XML parsing failed, continue
+        console.warn('XML parsing failed:', error);
+    }
+    // CASE 3: Mixed content - use unified parser
+    if (allowMixedContent) {
+        try {
+            const { parseToolCalls } = await import('../tool-calling/tool-parser.js');
+            const result = parseToolCalls(content);
+            if (result.success && result.toolCalls.length > 0) {
+                return { toolCalls: result.toolCalls };
+            }
+            if (!result.success) {
+                return { toolCalls: [], malformedError: result.error };
+            }
+        }
+        catch (error) {
+            // Parsing failed, return empty tool calls
+            console.warn('Mixed content parsing failed:', error);
+        }
+    }
+    // No tool calls found
+    return { toolCalls: [] };
+}
+/**
+ * Detects if content contains malformed patterns
+ *
+ * Logic:
+ * 1. If it parses as valid JSON via try/catch, it is NOT malformed.
+ * 2. If parsing fails, check for known "broken tool call" signatures.
+ *
+ * @param content - Content to check
+ * @returns True if malformed patterns detected
+ */
+function hasMalformedPatterns(content) {
+    const trimmed = content.trim();
+    // 1. Sanity Check: Empty content is not "malformed", just empty.
+    if (!trimmed) {
+        return false;
+    }
+    // 2. THE SAFETY CHECK: Trust the Runtime (JSON.parse)
+    // We check if it starts and ends with braces to identify it as a candidate for an Object.
+    if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+        try {
+            // CRASH PROTECTION: If this succeeds, the JSON is valid.
+            // Therefore, it cannot be "malformed".
+            JSON.parse(trimmed);
+            return false;
+        }
+        catch (_e) {
+            // It crashed. It might be malformed.
+            // Fall through to regex checks below.
+        }
+    }
+    // 3. Check for specific broken tool call patterns.
+    const malformedJSONPatterns = [
+        /^\s*\{\s*"name"\s*:\s*"[^"]+"\s*\}\s*$/, // name only, no arguments
+        /^\s*\{\s*"arguments"\s*:\s*\}\s*$/, // arguments only, no name
+        /"arguments"\s*:\s*null\s*([,}\s]*$)/s, // arguments as JSON null (followed by comma, brace, or end)
+        /^\s*\{\s*"arguments"\s*:\s*\[\s*\]\s*\}$/, // arguments as empty array
+        /^\s*\{\s*"arguments"\s*:\s*""\s*\}$/, // arguments as empty string
+    ];
+    for (const pattern of malformedJSONPatterns) {
+        if (pattern.test(trimmed)) {
+            return true;
+        }
+    }
+    // 4. Check for malformed XML patterns
+    const malformedXMLPatterns = [
+        /\[(?:tool_use|Tool):\s*(\w+)\]/i, // [tool_use: name] syntax
+        /<function=(\w+)>/, // <function=name> syntax
+        /<parameter=(\w+)>/, // <parameter=name> syntax
+    ];
+    for (const pattern of malformedXMLPatterns) {
+        if (pattern.test(content)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Builds metadata object for debugging and strategy selection
+ *
+ * @param content - Normalized content
+ * @param partialMetadata - Partial metadata from earlier detection
+ * @param hasToolCalls - Whether tool calls were actually extracted
+ * @returns Complete metadata object
+ */
+function buildMetadata(content, partialMetadata, hasToolCalls) {
+    // Check if content looks like JSON (has { and })
+    // Check if content looks like XML (has < and >)
+    // Check if content has code blocks
+    const hasCodeBlocks = /```/.test(content);
+    // Check if content has XML tags
+    const hasXMLTags = /<[^>]+>/.test(content);
+    // Check if content has JSON blocks (tool call patterns only, not plain JSON objects)
+    const hasJSONBlocks = /"name"\s*:\s*"[^"]+"\s*,\s*"arguments"\s*:\s*\{/.test(content);
+    return {
+        hasCodeBlocks: partialMetadata.hasCodeBlocks ?? hasCodeBlocks,
+        hasXMLTags: partialMetadata.hasXMLTags ?? hasXMLTags,
+        hasJSONBlocks: partialMetadata.hasJSONBlocks ?? hasJSONBlocks,
+        confidence: determineConfidence({
+            ...partialMetadata,
+            hasCodeBlocks,
+            hasXMLTags,
+            hasJSONBlocks,
+        }, hasToolCalls),
+        detectedFormat: partialMetadata.detectedFormat ?? 'unknown',
+        isMalformed: partialMetadata.isMalformed ?? hasMalformedPatterns(content),
+        malformedError: partialMetadata.malformedError,
+    };
+}
+/**
+ * Determines confidence level in the response type classification
+ *
+ * Confidence levels:
+ * - HIGH: Clear format detected (JSON with tool_calls, XML with tool calls)
+ * - MEDIUM: Unclear format (plain text with possible tool calls)
+ * - LOW: No format detected (plain text with no tool calls)
+ *
+ * @param metadata - Metadata from response
+ * @param hasToolCalls - Whether tool calls were actually extracted
+ * @returns Confidence level
+ */
+function determineConfidence(metadata, hasToolCalls) {
+    // High confidence if we actually extracted tool calls
+    if (hasToolCalls) {
+        return 'high';
+    }
+    // If it is explicitly malformed, confidence is LOW
+    if (metadata.isMalformed) {
+        return 'low';
+    }
+    // Medium confidence if it looks like code/data, but contained no valid tools
+    if (metadata.detectedFormat === 'json' ||
+        metadata.detectedFormat === 'xml' ||
+        metadata.hasCodeBlocks ||
+        metadata.hasJSONBlocks ||
+        metadata.hasXMLTags) {
+        return 'medium';
+    }
+    // LOW: Plain text with no format indicators
+    return 'low';
+}
+/**
+ * Checks if content contains embedded tool call patterns
+ *
+ * @param content - Content to check
+ * @returns True if embedded patterns detected
+ */
+function hasEmbeddedToolCallPatterns(content) {
+    // JSON tool call patterns (allow text before the pattern)
+    const jsonPatterns = [
+        /\s*\{\s*"name"\s*:\s*"[^"]+"\s*,\s*"arguments"\s*:\s*\{/s,
+        /\s*\{"name":\s*"([^"]+)",\s*"arguments":\s*\{/s,
+    ];
+    // XML tool call patterns
+    const xmlPatterns = [/<(\w+)>(.*?)<\/\1>/s];
+    for (const pattern of [...jsonPatterns, ...xmlPatterns]) {
+        if (pattern.test(content)) {
+            return true;
+        }
+    }
+    return false;
+}
+// ============================================================================
+// UTILITY FUNCTIONS
+// ============================================================================
+/**
+ * Formats a normalized response for debugging
+ *
+ * @param response - Normalized response to format
+ * @returns Formatted string for debugging
+ */
+export function formatNormalizedResponse(response) {
+    return [
+        `=== Normalized Response ===`,
+        `Raw Type: ${response.raw !== undefined ? typeof response.raw : 'undefined'}`,
+        `Content Type: ${typeof response.content}`,
+        `Content Length: ${response.content.length} chars`,
+        `Detected Format: ${response.metadata.detectedFormat}`,
+        `Confidence: ${response.metadata.confidence}`,
+        `Has Code Blocks: ${response.metadata.hasCodeBlocks}`,
+        `Has XML Tags: ${response.metadata.hasXMLTags}`,
+        `Has JSON Blocks: ${response.metadata.hasJSONBlocks}`,
+        `Is Malformed: ${response.metadata.isMalformed}`,
+        `Tool Calls: ${response.toolCalls.length}`,
+        ``,
+        `Content Preview:`,
+        response.content.slice(0, 500) +
+            (response.content.length > 500 ? '...' : ''),
+        ``,
+        `Tool Calls:`,
+        response.toolCalls
+            .map(tc => `  - ${tc.function.name}: ${JSON.stringify(tc.function.arguments)}`)
+            .join('\n'),
+    ].join('\n');
+}
+/**
+ * Checks if a response is complete and ready for processing
+ *
+ * A response is complete if:
+ * 1. It has content
+ * 2. It has low confidence (means no tool calls were found, so no further processing needed)
+ * 3. It's not malformed
+ *
+ * @param response - Normalized response to check
+ * @returns True if response is complete
+ */
+export function isResponseComplete(response) {
+    // Response is complete if it has content and is not malformed
+    return (response.content.length > 0 &&
+        !response.metadata.isMalformed &&
+        response.metadata.confidence !== 'low');
+}
+//# sourceMappingURL=response-formatter.js.map

package/dist/utils/response-formatter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-formatter.js","sourceRoot":"","sources":["../../source/utils/response-formatter.ts"],"names":[],"mappings":"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"}

package/dist/utils/shutdown/index.d.ts

@@ -0,0 +1,7 @@
+export { getShutdownManager, 
+/** @internal */
+resetShutdownManager, 
+/** @internal */
+ShutdownManager, } from './shutdown-manager.js';
+export type { ShutdownHandler, ShutdownManagerOptions } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/shutdown/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../source/utils/shutdown/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,kBAAkB;AAClB,gBAAgB;AAChB,oBAAoB;AACpB,gBAAgB;AAChB,eAAe,GACf,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EAAC,eAAe,EAAE,sBAAsB,EAAC,MAAM,SAAS,CAAC"}

package/dist/utils/shutdown/index.js

@@ -0,0 +1,6 @@
+export { getShutdownManager, 
+/** @internal */
+resetShutdownManager, 
+/** @internal */
+ShutdownManager, } from './shutdown-manager.js';
+//# sourceMappingURL=index.js.map

package/dist/utils/shutdown/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../source/utils/shutdown/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,kBAAkB;AAClB,gBAAgB;AAChB,oBAAoB;AACpB,gBAAgB;AAChB,eAAe,GACf,MAAM,oBAAoB,CAAC"}

package/dist/utils/shutdown/shutdown-manager.d.ts

@@ -0,0 +1,19 @@
+import type { ShutdownHandler, ShutdownManagerOptions } from './types.js';
+export declare class ShutdownManager {
+    private handlers;
+    private isShuttingDown;
+    private timeoutMs;
+    private boundSigterm;
+    private boundSigint;
+    private boundUncaughtException;
+    private boundUnhandledRejection;
+    constructor(options?: ShutdownManagerOptions);
+    register(handler: ShutdownHandler): void;
+    unregister(name: string): void;
+    gracefulShutdown(exitCode?: number): Promise<void>;
+    private setupSignalHandlers;
+    reset(): void;
+}
+export declare function getShutdownManager(options?: ShutdownManagerOptions): ShutdownManager;
+export declare function resetShutdownManager(): void;
+//# sourceMappingURL=shutdown-manager.d.ts.map

package/dist/utils/shutdown/shutdown-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shutdown-manager.d.ts","sourceRoot":"","sources":["../../../source/utils/shutdown/shutdown-manager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,eAAe,EAAE,sBAAsB,EAAC,MAAM,SAAS,CAAC;AAKrE,qBAAa,eAAe;IAC3B,OAAO,CAAC,QAAQ,CAA2C;IAC3D,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,SAAS,CAAS;IAE1B,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,sBAAsB,CAAuB;IACrD,OAAO,CAAC,uBAAuB,CAGrB;gBAEE,OAAO,CAAC,EAAE,sBAAsB;IAgC5C,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAIxC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIxB,gBAAgB,CAAC,QAAQ,SAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAoCnD,OAAO,CAAC,mBAAmB;IAO3B,KAAK,IAAI,IAAI;CAQb;AAID,wBAAgB,kBAAkB,CACjC,OAAO,CAAC,EAAE,sBAAsB,GAC9B,eAAe,CAKjB;AAED,wBAAgB,oBAAoB,IAAI,IAAI,CAK3C"}