@shareai-lab/kode-sdk 2.7.1 → 2.7.2

package/dist/infra/providers/core/fork.js

@@ -0,0 +1,418 @@
+"use strict";
+/**
+ * Fork Point Detection and Resume Support
+ *
+ * Provides utilities for detecting safe fork points in message history
+ * and preparing messages for resume across different providers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geminiResumeHandler = exports.openaiResponsesResumeHandler = exports.openaiChatResumeHandler = exports.qwenResumeHandler = exports.deepseekResumeHandler = exports.anthropicResumeHandler = void 0;
+exports.findSafeForkPoints = findSafeForkPoints;
+exports.getLastSafeForkPoint = getLastSafeForkPoint;
+exports.serializeForResume = serializeForResume;
+exports.getResumeHandler = getResumeHandler;
+exports.prepareMessagesForResume = prepareMessagesForResume;
+exports.validateMessagesForResume = validateMessagesForResume;
+exports.canForkAt = canForkAt;
+exports.forkAt = forkAt;
+/**
+ * Find all safe fork points in a message sequence.
+ *
+ * Safe fork points are:
+ * 1. User messages
+ * 2. Assistant messages without tool_use
+ * 3. After a user message containing all tool_results for preceding tool_uses
+ */
+function findSafeForkPoints(messages) {
+    const points = [];
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        const point = analyzeForkSafety(msg, i, messages);
+        points.push(point);
+    }
+    return points;
+}
+/**
+ * Analyze if a specific message index is a safe fork point.
+ */
+function analyzeForkSafety(msg, index, messages) {
+    // User messages are always safe fork points
+    if (msg.role === 'user') {
+        // But check if this user message contains incomplete tool results
+        const prevMsg = messages[index - 1];
+        if (prevMsg?.role === 'assistant') {
+            const toolUseIds = getToolUseIds(prevMsg);
+            if (toolUseIds.length > 0) {
+                const resultIds = getToolResultIds(msg);
+                const allHaveResults = toolUseIds.every(id => resultIds.includes(id));
+                if (!allHaveResults) {
+                    return {
+                        messageIndex: index,
+                        isSafe: false,
+                        reason: 'User message does not contain all required tool_results',
+                    };
+                }
+            }
+        }
+        return { messageIndex: index, isSafe: true };
+    }
+    // Assistant messages without tool_use are safe
+    if (msg.role === 'assistant') {
+        const hasToolUse = msg.content.some(b => b.type === 'tool_use');
+        if (!hasToolUse) {
+            return { messageIndex: index, isSafe: true };
+        }
+        // Check if all tool calls have results in the next message
+        const toolUseIds = getToolUseIds(msg);
+        const nextMsg = messages[index + 1];
+        if (nextMsg?.role === 'user') {
+            const resultIds = getToolResultIds(nextMsg);
+            const allHaveResults = toolUseIds.every(id => resultIds.includes(id));
+            if (allHaveResults) {
+                // The next user message (index + 1) is the safe fork point
+                return {
+                    messageIndex: index,
+                    isSafe: false,
+                    reason: 'Fork at next message (after tool results)',
+                };
+            }
+        }
+        return {
+            messageIndex: index,
+            isSafe: false,
+            reason: 'Pending tool calls without results',
+        };
+    }
+    // System messages
+    if (msg.role === 'system') {
+        return { messageIndex: index, isSafe: true };
+    }
+    return { messageIndex: index, isSafe: false, reason: 'Unknown message role' };
+}
+/**
+ * Get the last safe fork point index.
+ */
+function getLastSafeForkPoint(messages) {
+    const points = findSafeForkPoints(messages);
+    for (let i = points.length - 1; i >= 0; i--) {
+        if (points[i].isSafe) {
+            return points[i].messageIndex;
+        }
+    }
+    return -1; // No safe fork point found
+}
+/**
+ * Extract tool_use IDs from a message.
+ */
+function getToolUseIds(msg) {
+    return msg.content
+        .filter((b) => b.type === 'tool_use')
+        .map(b => b.id);
+}
+/**
+ * Extract tool_result IDs from a message.
+ */
+function getToolResultIds(msg) {
+    return msg.content
+        .filter((b) => b.type === 'tool_result')
+        .map(b => b.tool_use_id);
+}
+/**
+ * Serialize messages for persistence.
+ */
+function serializeForResume(messages, options) {
+    return messages.map(msg => serializeMessage(msg, options));
+}
+/**
+ * Serialize a single message.
+ */
+function serializeMessage(msg, options) {
+    const serialized = {
+        role: msg.role,
+        content: [],
+        metadata: msg.metadata,
+    };
+    for (const block of msg.content) {
+        const serializedBlock = serializeBlock(block, options);
+        if (serializedBlock) {
+            serialized.content.push(serializedBlock);
+        }
+    }
+    return serialized;
+}
+/**
+ * Serialize a content block based on options.
+ */
+function serializeBlock(block, options) {
+    // Handle reasoning blocks based on transport
+    if (block.type === 'reasoning') {
+        switch (options.reasoningTransport) {
+            case 'provider':
+                // Keep as-is for providers that support it
+                return block;
+            case 'text':
+                // Convert to text block with <think> tags
+                return {
+                    type: 'text',
+                    text: `<think>${block.reasoning}</think>`,
+                };
+            case 'omit':
+                // Exclude from serialized output
+                return null;
+        }
+    }
+    // All other blocks pass through
+    return block;
+}
+// ============================================================================
+// Provider-Specific Resume Handlers
+// ============================================================================
+/**
+ * Anthropic resume handler.
+ * Preserves thinking blocks with signatures for Claude 4+.
+ */
+exports.anthropicResumeHandler = {
+    prepareForResume(messages) {
+        // Anthropic requires thinking blocks with signatures for Claude 4+
+        // Blocks without signatures will be ignored by the API
+        return messages.map(msg => {
+            if (msg.role !== 'assistant')
+                return msg;
+            // Keep all blocks, including reasoning
+            // The API will verify signatures and ignore invalid ones
+            return msg;
+        });
+    },
+    validateForResume(messages) {
+        const errors = [];
+        const warnings = [];
+        for (let i = 0; i < messages.length; i++) {
+            const msg = messages[i];
+            // Check tool_use has corresponding tool_result
+            if (msg.role === 'assistant') {
+                const toolUses = msg.content.filter(b => b.type === 'tool_use');
+                if (toolUses.length > 0 && i < messages.length - 1) {
+                    const nextMsg = messages[i + 1];
+                    if (nextMsg.role !== 'user') {
+                        errors.push(`Tool use at index ${i} not followed by user message`);
+                    }
+                    else {
+                        const resultIds = getToolResultIds(nextMsg);
+                        const toolUseIds = getToolUseIds(msg);
+                        const missing = toolUseIds.filter(id => !resultIds.includes(id));
+                        if (missing.length > 0) {
+                            errors.push(`Missing tool_results for tool_use IDs: ${missing.join(', ')}`);
+                        }
+                    }
+                }
+            }
+            // Check for reasoning without signatures
+            if (msg.role === 'assistant') {
+                const reasoningBlocks = msg.content.filter(b => b.type === 'reasoning');
+                for (const block of reasoningBlocks) {
+                    if (block.type === 'reasoning' && !block.meta?.signature) {
+                        warnings.push(`Reasoning block at index ${i} has no signature (may be ignored)`);
+                    }
+                }
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    },
+};
+/**
+ * DeepSeek resume handler.
+ * CRITICAL: Must NOT include reasoning_content in message history.
+ */
+exports.deepseekResumeHandler = {
+    prepareForResume(messages) {
+        // DeepSeek returns 400 if reasoning_content is included in next turn
+        // Only include content field (text blocks)
+        return messages.map(msg => {
+            if (msg.role !== 'assistant')
+                return msg;
+            // Filter out reasoning blocks entirely
+            const filteredBlocks = msg.content.filter(b => b.type !== 'reasoning');
+            return { ...msg, content: filteredBlocks };
+        });
+    },
+    validateForResume(messages) {
+        const errors = [];
+        // Check that reasoning is not included in non-last messages
+        for (let i = 0; i < messages.length - 1; i++) {
+            const msg = messages[i];
+            if (msg.role === 'assistant') {
+                const hasReasoning = msg.content.some(b => b.type === 'reasoning');
+                if (hasReasoning) {
+                    errors.push(`DeepSeek: reasoning_content must not be included at index ${i} (returns 400 error)`);
+                }
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    },
+};
+/**
+ * Qwen resume handler.
+ * Similar to DeepSeek - reasoning should be omitted.
+ */
+exports.qwenResumeHandler = {
+    prepareForResume(messages) {
+        // Qwen: Similar to DeepSeek, reasoning_content should be omitted
+        return messages.map(msg => {
+            if (msg.role !== 'assistant')
+                return msg;
+            const filteredBlocks = msg.content.filter(b => b.type !== 'reasoning');
+            return { ...msg, content: filteredBlocks };
+        });
+    },
+    validateForResume(messages) {
+        // Less strict than DeepSeek, but still recommend omitting
+        return { valid: true, errors: [] };
+    },
+};
+/**
+ * OpenAI Chat resume handler.
+ * Reasoning is converted to text with <think> tags.
+ */
+exports.openaiChatResumeHandler = {
+    prepareForResume(messages) {
+        return messages.map(msg => {
+            if (msg.role !== 'assistant')
+                return msg;
+            // Convert reasoning to text with <think> tags
+            const convertedBlocks = msg.content.map(block => {
+                if (block.type === 'reasoning') {
+                    return {
+                        type: 'text',
+                        text: `<think>${block.reasoning}</think>`,
+                    };
+                }
+                return block;
+            });
+            return { ...msg, content: convertedBlocks };
+        });
+    },
+    validateForResume(messages) {
+        return { valid: true, errors: [] };
+    },
+};
+/**
+ * OpenAI Responses API resume handler.
+ * Uses previous_response_id for state persistence.
+ */
+exports.openaiResponsesResumeHandler = {
+    prepareForResume(messages) {
+        // Responses API handles state via previous_response_id
+        // Messages are passed normally
+        return messages;
+    },
+    validateForResume(messages) {
+        // Responses API manages state via previous_response_id
+        // This is typically passed in options, not in message metadata
+        return { valid: true, errors: [] };
+    },
+};
+/**
+ * Gemini resume handler.
+ * Preserves thoughtSignature for function calls.
+ */
+exports.geminiResumeHandler = {
+    prepareForResume(messages) {
+        // Gemini: Preserve thoughtSignature for function call continuation
+        return messages.map(msg => {
+            if (msg.role !== 'assistant')
+                return msg;
+            // Keep reasoning blocks that have thoughtSignature
+            // Others can be omitted or converted
+            const processedBlocks = msg.content.map(block => {
+                if (block.type === 'reasoning') {
+                    // Keep if has signature, otherwise omit
+                    if (block.meta?.thoughtSignature) {
+                        return block;
+                    }
+                    return null;
+                }
+                return block;
+            }).filter((b) => b !== null);
+            return { ...msg, content: processedBlocks };
+        });
+    },
+    validateForResume(messages) {
+        return { valid: true, errors: [] };
+    },
+};
+/**
+ * Get resume handler for a provider.
+ */
+function getResumeHandler(provider) {
+    switch (provider) {
+        case 'anthropic':
+            return exports.anthropicResumeHandler;
+        case 'deepseek':
+            return exports.deepseekResumeHandler;
+        case 'qwen':
+            return exports.qwenResumeHandler;
+        case 'openai':
+        case 'openai-chat':
+            return exports.openaiChatResumeHandler;
+        case 'openai-responses':
+            return exports.openaiResponsesResumeHandler;
+        case 'gemini':
+            return exports.geminiResumeHandler;
+        default:
+            // Default handler - omit reasoning to be safe
+            return {
+                prepareForResume(messages) {
+                    return messages.map(msg => {
+                        if (msg.role !== 'assistant')
+                            return msg;
+                        const filtered = msg.content.filter(b => b.type !== 'reasoning');
+                        return { ...msg, content: filtered };
+                    });
+                },
+                validateForResume() {
+                    return { valid: true, errors: [] };
+                },
+            };
+    }
+}
+/**
+ * Prepare messages for resume with a specific provider.
+ */
+function prepareMessagesForResume(messages, provider) {
+    const handler = getResumeHandler(provider);
+    return handler.prepareForResume(messages);
+}
+/**
+ * Validate messages for resume with a specific provider.
+ */
+function validateMessagesForResume(messages, provider) {
+    const handler = getResumeHandler(provider);
+    return handler.validateForResume(messages);
+}
+/**
+ * Check if a message sequence can be safely forked at a given index.
+ */
+function canForkAt(messages, index) {
+    if (index < 0 || index >= messages.length) {
+        return false;
+    }
+    const points = findSafeForkPoints(messages);
+    return points[index]?.isSafe ?? false;
+}
+/**
+ * Fork messages at a given index.
+ * Returns messages up to and including the fork point.
+ */
+function forkAt(messages, index) {
+    if (!canForkAt(messages, index)) {
+        throw new Error(`Cannot fork at index ${index} - not a safe fork point`);
+    }
+    return messages.slice(0, index + 1);
+}

package/dist/infra/providers/core/index.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Core Provider Module
+ *
+ * Re-exports all core utilities for provider implementations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openaiChatResumeHandler = exports.qwenResumeHandler = exports.deepseekResumeHandler = exports.anthropicResumeHandler = exports.serializeForResume = exports.getLastSafeForkPoint = exports.findSafeForkPoints = exports.generateAuditId = exports.truncateContent = exports.redactSensitive = exports.createProviderLogger = exports.createConsoleLogger = exports.DEFAULT_DEBUG_CONFIG = exports.getRetryDelay = exports.shouldRetry = exports.createRetryWrapper = exports.withRetryAndTimeout = exports.withRetry = exports.AGGRESSIVE_RETRY_CONFIG = exports.DEFAULT_RETRY_CONFIG = exports.formatUsageString = exports.aggregateUsage = exports.normalizeDeepSeekUsage = exports.normalizeGeminiUsage = exports.normalizeOpenAIUsage = exports.normalizeAnthropicUsage = exports.calculateCost = exports.createEmptyUsage = exports.PROVIDER_PRICING = exports.isContentFilterError = exports.isContextLengthError = exports.isAuthError = exports.isRateLimitError = exports.isRetryableError = exports.parseProviderError = exports.ParseError = exports.StreamError = exports.ThinkingSignatureError = exports.ServiceUnavailableError = exports.QuotaExceededError = exports.ModelNotFoundError = exports.ContentFilterError = exports.NetworkError = exports.TimeoutError = exports.ServerError = exports.InvalidRequestError = exports.ContextLengthError = exports.AuthenticationError = exports.RateLimitError = exports.ProviderError = void 0;
+exports.forkAt = exports.canForkAt = exports.validateMessagesForResume = exports.prepareMessagesForResume = exports.getResumeHandler = exports.geminiResumeHandler = exports.openaiResponsesResumeHandler = void 0;
+// Error types and utilities
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "ProviderError", { enumerable: true, get: function () { return errors_1.ProviderError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return errors_1.RateLimitError; } });
+Object.defineProperty(exports, "AuthenticationError", { enumerable: true, get: function () { return errors_1.AuthenticationError; } });
+Object.defineProperty(exports, "ContextLengthError", { enumerable: true, get: function () { return errors_1.ContextLengthError; } });
+Object.defineProperty(exports, "InvalidRequestError", { enumerable: true, get: function () { return errors_1.InvalidRequestError; } });
+Object.defineProperty(exports, "ServerError", { enumerable: true, get: function () { return errors_1.ServerError; } });
+Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return errors_1.TimeoutError; } });
+Object.defineProperty(exports, "NetworkError", { enumerable: true, get: function () { return errors_1.NetworkError; } });
+Object.defineProperty(exports, "ContentFilterError", { enumerable: true, get: function () { return errors_1.ContentFilterError; } });
+Object.defineProperty(exports, "ModelNotFoundError", { enumerable: true, get: function () { return errors_1.ModelNotFoundError; } });
+Object.defineProperty(exports, "QuotaExceededError", { enumerable: true, get: function () { return errors_1.QuotaExceededError; } });
+Object.defineProperty(exports, "ServiceUnavailableError", { enumerable: true, get: function () { return errors_1.ServiceUnavailableError; } });
+Object.defineProperty(exports, "ThinkingSignatureError", { enumerable: true, get: function () { return errors_1.ThinkingSignatureError; } });
+Object.defineProperty(exports, "StreamError", { enumerable: true, get: function () { return errors_1.StreamError; } });
+Object.defineProperty(exports, "ParseError", { enumerable: true, get: function () { return errors_1.ParseError; } });
+Object.defineProperty(exports, "parseProviderError", { enumerable: true, get: function () { return errors_1.parseProviderError; } });
+Object.defineProperty(exports, "isRetryableError", { enumerable: true, get: function () { return errors_1.isRetryableError; } });
+Object.defineProperty(exports, "isRateLimitError", { enumerable: true, get: function () { return errors_1.isRateLimitError; } });
+Object.defineProperty(exports, "isAuthError", { enumerable: true, get: function () { return errors_1.isAuthError; } });
+Object.defineProperty(exports, "isContextLengthError", { enumerable: true, get: function () { return errors_1.isContextLengthError; } });
+Object.defineProperty(exports, "isContentFilterError", { enumerable: true, get: function () { return errors_1.isContentFilterError; } });
+// Usage statistics and cost calculation
+var usage_1 = require("./usage");
+Object.defineProperty(exports, "PROVIDER_PRICING", { enumerable: true, get: function () { return usage_1.PROVIDER_PRICING; } });
+Object.defineProperty(exports, "createEmptyUsage", { enumerable: true, get: function () { return usage_1.createEmptyUsage; } });
+Object.defineProperty(exports, "calculateCost", { enumerable: true, get: function () { return usage_1.calculateCost; } });
+Object.defineProperty(exports, "normalizeAnthropicUsage", { enumerable: true, get: function () { return usage_1.normalizeAnthropicUsage; } });
+Object.defineProperty(exports, "normalizeOpenAIUsage", { enumerable: true, get: function () { return usage_1.normalizeOpenAIUsage; } });
+Object.defineProperty(exports, "normalizeGeminiUsage", { enumerable: true, get: function () { return usage_1.normalizeGeminiUsage; } });
+Object.defineProperty(exports, "normalizeDeepSeekUsage", { enumerable: true, get: function () { return usage_1.normalizeDeepSeekUsage; } });
+Object.defineProperty(exports, "aggregateUsage", { enumerable: true, get: function () { return usage_1.aggregateUsage; } });
+Object.defineProperty(exports, "formatUsageString", { enumerable: true, get: function () { return usage_1.formatUsageString; } });
+// Retry strategy
+var retry_1 = require("./retry");
+Object.defineProperty(exports, "DEFAULT_RETRY_CONFIG", { enumerable: true, get: function () { return retry_1.DEFAULT_RETRY_CONFIG; } });
+Object.defineProperty(exports, "AGGRESSIVE_RETRY_CONFIG", { enumerable: true, get: function () { return retry_1.AGGRESSIVE_RETRY_CONFIG; } });
+Object.defineProperty(exports, "withRetry", { enumerable: true, get: function () { return retry_1.withRetry; } });
+Object.defineProperty(exports, "withRetryAndTimeout", { enumerable: true, get: function () { return retry_1.withRetryAndTimeout; } });
+Object.defineProperty(exports, "createRetryWrapper", { enumerable: true, get: function () { return retry_1.createRetryWrapper; } });
+Object.defineProperty(exports, "shouldRetry", { enumerable: true, get: function () { return retry_1.shouldRetry; } });
+Object.defineProperty(exports, "getRetryDelay", { enumerable: true, get: function () { return retry_1.getRetryDelay; } });
+// Logging and debugging
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "DEFAULT_DEBUG_CONFIG", { enumerable: true, get: function () { return logger_1.DEFAULT_DEBUG_CONFIG; } });
+Object.defineProperty(exports, "createConsoleLogger", { enumerable: true, get: function () { return logger_1.createConsoleLogger; } });
+Object.defineProperty(exports, "createProviderLogger", { enumerable: true, get: function () { return logger_1.createProviderLogger; } });
+Object.defineProperty(exports, "redactSensitive", { enumerable: true, get: function () { return logger_1.redactSensitive; } });
+Object.defineProperty(exports, "truncateContent", { enumerable: true, get: function () { return logger_1.truncateContent; } });
+Object.defineProperty(exports, "generateAuditId", { enumerable: true, get: function () { return logger_1.generateAuditId; } });
+// Fork point detection and resume
+var fork_1 = require("./fork");
+Object.defineProperty(exports, "findSafeForkPoints", { enumerable: true, get: function () { return fork_1.findSafeForkPoints; } });
+Object.defineProperty(exports, "getLastSafeForkPoint", { enumerable: true, get: function () { return fork_1.getLastSafeForkPoint; } });
+Object.defineProperty(exports, "serializeForResume", { enumerable: true, get: function () { return fork_1.serializeForResume; } });
+Object.defineProperty(exports, "anthropicResumeHandler", { enumerable: true, get: function () { return fork_1.anthropicResumeHandler; } });
+Object.defineProperty(exports, "deepseekResumeHandler", { enumerable: true, get: function () { return fork_1.deepseekResumeHandler; } });
+Object.defineProperty(exports, "qwenResumeHandler", { enumerable: true, get: function () { return fork_1.qwenResumeHandler; } });
+Object.defineProperty(exports, "openaiChatResumeHandler", { enumerable: true, get: function () { return fork_1.openaiChatResumeHandler; } });
+Object.defineProperty(exports, "openaiResponsesResumeHandler", { enumerable: true, get: function () { return fork_1.openaiResponsesResumeHandler; } });
+Object.defineProperty(exports, "geminiResumeHandler", { enumerable: true, get: function () { return fork_1.geminiResumeHandler; } });
+Object.defineProperty(exports, "getResumeHandler", { enumerable: true, get: function () { return fork_1.getResumeHandler; } });
+Object.defineProperty(exports, "prepareMessagesForResume", { enumerable: true, get: function () { return fork_1.prepareMessagesForResume; } });
+Object.defineProperty(exports, "validateMessagesForResume", { enumerable: true, get: function () { return fork_1.validateMessagesForResume; } });
+Object.defineProperty(exports, "canForkAt", { enumerable: true, get: function () { return fork_1.canForkAt; } });
+Object.defineProperty(exports, "forkAt", { enumerable: true, get: function () { return fork_1.forkAt; } });

package/dist/infra/providers/core/logger.js

@@ -0,0 +1,191 @@
+"use strict";
+/**
+ * Logging and Debugging Module
+ *
+ * Unified logging interfaces for provider operations,
+ * request/response tracking, and audit trail.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DEBUG_CONFIG = void 0;
+exports.createConsoleLogger = createConsoleLogger;
+exports.createProviderLogger = createProviderLogger;
+exports.redactSensitive = redactSensitive;
+exports.truncateContent = truncateContent;
+exports.generateAuditId = generateAuditId;
+/**
+ * Default debug configuration.
+ */
+exports.DEFAULT_DEBUG_CONFIG = {
+    verbose: false,
+    logRawRequests: false,
+    logRawResponses: false,
+    logThinking: false,
+    logTokenUsage: true,
+    logCache: true,
+    logRetries: true,
+    redactSensitive: true,
+    maxContentLength: 500,
+};
+/**
+ * Create a console-based logger.
+ */
+function createConsoleLogger(context = {}, debugConfig = {}) {
+    const config = { ...exports.DEFAULT_DEBUG_CONFIG, ...debugConfig };
+    const log = (level, message, ctx) => {
+        if (!config.verbose && level === 'debug')
+            return;
+        const entry = {
+            level,
+            message,
+            timestamp: Date.now(),
+            context: { ...context, ...ctx },
+        };
+        const prefix = `[${level.toUpperCase()}]`;
+        const contextStr = Object.keys(entry.context || {}).length > 0
+            ? ` ${JSON.stringify(entry.context)}`
+            : '';
+        const output = `${prefix} ${message}${contextStr}`;
+        switch (level) {
+            case 'debug':
+                console.debug(output);
+                break;
+            case 'info':
+                console.info(output);
+                break;
+            case 'warn':
+                console.warn(output);
+                break;
+            case 'error':
+                console.error(output);
+                break;
+        }
+    };
+    return {
+        debug: (message, ctx) => log('debug', message, ctx),
+        info: (message, ctx) => log('info', message, ctx),
+        warn: (message, ctx) => log('warn', message, ctx),
+        error: (message, ctx) => log('error', message, ctx),
+        child: (childContext) => createConsoleLogger({ ...context, ...childContext }, debugConfig),
+    };
+}
+/**
+ * Create a provider logger with request/response tracking.
+ */
+function createProviderLogger(provider, debugConfig = {}) {
+    const config = { ...exports.DEFAULT_DEBUG_CONFIG, ...debugConfig };
+    const base = createConsoleLogger({ provider }, debugConfig);
+    return {
+        ...base,
+        logRequest(request) {
+            if (!config.verbose)
+                return;
+            base.info('Provider request', {
+                model: request.model,
+                requestId: request.requestId,
+                messageCount: request.messageCount,
+                estimatedTokens: request.estimatedTokens,
+                streaming: request.streaming,
+                toolCount: request.toolCount,
+            });
+        },
+        logResponse(response, durationMs) {
+            if (config.logTokenUsage) {
+                base.info('Provider response', {
+                    model: response.model,
+                    requestId: response.requestId,
+                    inputTokens: response.usage.inputTokens,
+                    outputTokens: response.usage.outputTokens,
+                    durationMs,
+                    stopReason: response.stopReason,
+                });
+            }
+        },
+        logError(error) {
+            base.error('Provider error', {
+                code: error.code,
+                requestId: error.requestId,
+                retryable: error.retryable,
+            });
+        },
+        logStreamStart(requestId) {
+            if (config.verbose) {
+                base.debug('Stream started', { requestId });
+            }
+        },
+        logStreamChunk(requestId, chunkSize) {
+            if (config.verbose) {
+                base.debug('Stream chunk', { requestId, chunkSize });
+            }
+        },
+        logStreamEnd(requestId, totalChunks) {
+            if (config.verbose) {
+                base.debug('Stream ended', { requestId, totalChunks });
+            }
+        },
+        logCacheHit(tokens) {
+            if (config.logCache) {
+                base.info('Cache hit', { tokens });
+            }
+        },
+        logCacheWrite(tokens, ttl) {
+            if (config.logCache) {
+                base.info('Cache write', { tokens, ttl });
+            }
+        },
+        logRetry(attempt, delayMs, error) {
+            if (config.logRetries) {
+                base.warn('Retrying request', {
+                    attempt,
+                    delayMs,
+                    errorCode: error.code,
+                });
+            }
+        },
+        child(childContext) {
+            return createProviderLogger(provider, debugConfig);
+        },
+    };
+}
+/**
+ * Redact sensitive data from an object.
+ */
+function redactSensitive(obj) {
+    const sensitiveKeys = [
+        'apiKey',
+        'api_key',
+        'authorization',
+        'Authorization',
+        'token',
+        'secret',
+        'password',
+        'credential',
+    ];
+    const redacted = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (sensitiveKeys.some(k => key.toLowerCase().includes(k.toLowerCase()))) {
+            redacted[key] = '[REDACTED]';
+        }
+        else if (typeof value === 'object' && value !== null) {
+            redacted[key] = redactSensitive(value);
+        }
+        else {
+            redacted[key] = value;
+        }
+    }
+    return redacted;
+}
+/**
+ * Truncate content for logging.
+ */
+function truncateContent(content, maxLength) {
+    if (content.length <= maxLength) {
+        return content;
+    }
+    return content.slice(0, maxLength) + `... [truncated, ${content.length - maxLength} more chars]`;
+}
+/**
+ * Generate unique audit ID.
+ */
+function generateAuditId() {
+    return `audit_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}