@kaitranntt/ccs 6.7.0 → 6.7.1-dev.1

package/dist/glmt/glmt-transformer.js

@@ -1,19 +1,12 @@
 "use strict";
 /**
- * GlmtTransformer - Convert between Anthropic and OpenAI formats with thinking and tool support
+ * GlmtTransformer - Orchestrator for Anthropic ↔ OpenAI format transformation
  *
- * Features:
- * - Request: Anthropic → OpenAI (inject reasoning params, transform tools)
- * - Response: OpenAI reasoning_content → Anthropic thinking blocks
- * - Tool Support: Anthropic tools ↔ OpenAI function calling (bidirectional)
- * - Streaming: Real-time tool calls with input_json deltas
- * - Debug mode: Log raw data to ~/.ccs/logs/ (CCS_DEBUG=1)
- * - Verbose mode: Console logging with timestamps
- * - Validation: Self-test transformation results
- *
- * Control Tags (in user prompt):
- *   <Thinking:On|Off>        - Enable/disable reasoning
- *   <Effort:Low|Medium|High> - Control reasoning depth
+ * Pipeline Architecture:
+ * - RequestTransformer: Anthropic → OpenAI request conversion
+ * - StreamParser: Delta processing for streaming responses
+ * - ResponseBuilder: SSE event generation
+ * - ToolCallHandler: Tool call processing
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -40,436 +33,132 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GlmtTransformer = void 0;
-const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
-const locale_enforcer_1 = require("./locale-enforcer");
-const reasoning_enforcer_1 = require("./reasoning-enforcer");
+const pipeline_1 = require("./pipeline");
 class GlmtTransformer {
     constructor(config = {}) {
-        this.defaultThinking = config.defaultThinking ?? true;
         this.verbose = config.verbose || false;
-        // CCS_DEBUG controls all debug logging (file + console)
         const debugEnabled = process.env.CCS_DEBUG === '1';
         this.debugLog = config.debugLog ?? debugEnabled;
-        this.debugMode = config.debugMode ?? debugEnabled;
         this.debugLogDir = config.debugLogDir || path.join(os.homedir(), '.ccs', 'logs');
-        this.modelMaxTokens = {
-            'GLM-4.6': 128000,
-            'GLM-4.5': 96000,
-            'GLM-4.5-air': 16000,
-        };
-        // Initialize locale enforcer (always enforce English)
-        this.localeEnforcer = new locale_enforcer_1.LocaleEnforcer();
-        // Initialize reasoning enforcer (enabled by default for all GLMT usage)
-        this.reasoningEnforcer = new reasoning_enforcer_1.ReasoningEnforcer({
-            enabled: config.explicitReasoning ?? true,
+        // Initialize pipeline components
+        this.requestTransformer = new pipeline_1.RequestTransformer({
+            defaultThinking: config.defaultThinking ?? true,
+            verbose: this.verbose,
+            explicitReasoning: config.explicitReasoning ?? true,
+            log: (msg) => this.log(msg),
+        });
+        this.responseBuilder = new pipeline_1.ResponseBuilder(this.verbose);
+        this.toolCallHandler = new pipeline_1.ToolCallHandler();
+        this.contentTransformer = new pipeline_1.ContentTransformer(config.defaultThinking ?? true);
+        this.streamParser = new pipeline_1.StreamParser({
+            verbose: this.verbose,
+            debugMode: config.debugMode ?? debugEnabled,
+            debugLog: this.debugLog,
+            writeDebugLog: (type, data) => this.writeDebugLog(type, data),
         });
     }
-    /**
-     * Transform Anthropic request to OpenAI format
-     */
+    /** Transform Anthropic request to OpenAI format */
     transformRequest(anthropicRequest) {
-        // Log original request
         this.writeDebugLog('request-anthropic', anthropicRequest);
-        try {
-            // 1. Extract thinking control from messages (tags like <Thinking:On|Off>)
-            const thinkingConfig = this.extractThinkingControl(anthropicRequest.messages || []);
-            const hasControlTags = this.hasThinkingTags(anthropicRequest.messages || []);
-            // 2. Detect "think" keywords in user prompts (Anthropic-style)
-            const keywordConfig = this.detectThinkKeywords(anthropicRequest.messages || []);
-            if (keywordConfig && !anthropicRequest.thinking && !hasControlTags) {
-                thinkingConfig.thinking = keywordConfig.thinking;
-                thinkingConfig.effort = keywordConfig.effort;
-                this.log(`Detected think keyword: ${keywordConfig.keyword}, effort=${keywordConfig.effort}`);
-            }
-            // 3. Check anthropicRequest.thinking parameter (takes precedence)
-            if (anthropicRequest.thinking) {
-                if (anthropicRequest.thinking.type === 'enabled') {
-                    thinkingConfig.thinking = true;
-                    this.log('Claude CLI explicitly enabled thinking (overrides budget)');
-                }
-                else if (anthropicRequest.thinking.type === 'disabled') {
-                    thinkingConfig.thinking = false;
-                    this.log('Claude CLI explicitly disabled thinking (overrides budget)');
-                }
-                else {
-                    this.log(`Warning: Unknown thinking type: ${anthropicRequest.thinking.type}`);
-                }
-            }
-            this.log(`Final thinking control: ${JSON.stringify(thinkingConfig)}`);
-            // 3. Map model
-            const glmModel = this.mapModel(anthropicRequest.model);
-            // 4. Inject locale instruction before sanitization
-            const messagesWithLocale = this.localeEnforcer.injectInstruction((anthropicRequest.messages || []));
-            // 4.5. Inject reasoning instruction (if enabled or thinking requested)
-            const messagesWithReasoning = this.reasoningEnforcer.injectInstruction(messagesWithLocale, thinkingConfig);
-            // 5. Convert to OpenAI format
-            const openaiRequest = {
-                model: glmModel,
-                messages: this.sanitizeMessages(messagesWithReasoning),
-                max_tokens: this.getMaxTokens(glmModel),
-                stream: anthropicRequest.stream ?? false,
-            };
-            // 5.5. Transform tools parameter if present
-            if (anthropicRequest.tools && anthropicRequest.tools.length > 0) {
-                openaiRequest.tools = this.transformTools(anthropicRequest.tools);
-                // Always use "auto" as Z.AI doesn't support other modes
-                openaiRequest.tool_choice = 'auto';
-                this.log(`Transformed ${anthropicRequest.tools.length} tools for OpenAI format`);
-            }
-            // 6. Preserve optional parameters
-            if (anthropicRequest.temperature !== undefined) {
-                openaiRequest.temperature = anthropicRequest.temperature;
-            }
-            if (anthropicRequest.top_p !== undefined) {
-                openaiRequest.top_p = anthropicRequest.top_p;
-            }
-            // 7. Handle streaming
-            if (anthropicRequest.stream !== undefined) {
-                openaiRequest.stream = anthropicRequest.stream;
-            }
-            // 8. Inject reasoning parameters
-            this.injectReasoningParams(openaiRequest, thinkingConfig);
-            // Log transformed request
-            this.writeDebugLog('request-openai', openaiRequest);
-            return { openaiRequest, thinkingConfig };
-        }
-        catch (error) {
-            const err = error;
-            console.error('[glmt-transformer] Request transformation error:', err);
-            // Return original request with warning
-            return {
-                openaiRequest: anthropicRequest,
-                thinkingConfig: { thinking: false, effort: 'medium' },
-                error: err.message,
-            };
-        }
+        const result = this.requestTransformer.transform(anthropicRequest);
+        this.writeDebugLog('request-openai', result.openaiRequest);
+        return result;
     }
-    /**
-     * Transform OpenAI response to Anthropic format
-     */
+    /** Transform OpenAI response to Anthropic format */
     transformResponse(openaiResponse, _thinkingConfig = { thinking: false, effort: 'medium' }) {
-        // Log original response
         this.writeDebugLog('response-openai', openaiResponse);
         try {
             const choice = openaiResponse.choices?.[0];
-            if (!choice) {
+            if (!choice)
                 throw new Error('No choices in OpenAI response');
-            }
             const message = choice.message;
             const content = [];
-            // Add thinking block if reasoning_content exists
             if (message.reasoning_content) {
-                const length = message.reasoning_content.length;
-                const lineCount = message.reasoning_content.split('\n').length;
-                const preview = message.reasoning_content.substring(0, 100).replace(/\n/g, ' ').trim();
-                this.log(`Detected reasoning_content:`);
-                this.log(`  Length: ${length} characters`);
-                this.log(`  Lines: ${lineCount}`);
-                this.log(`  Preview: ${preview}...`);
+                this.log(`Detected reasoning_content: ${message.reasoning_content.length} chars`);
                 content.push({
                     type: 'thinking',
                     thinking: message.reasoning_content,
-                    signature: this.generateThinkingSignature(message.reasoning_content),
+                    signature: this.responseBuilder.generateThinkingSignature(message.reasoning_content),
                 });
             }
-            else {
-                this.log('No reasoning_content in OpenAI response');
-                this.log('Note: This is expected if thinking not requested or model cannot reason');
-            }
-            // Add text content
             if (message.content) {
-                content.push({
-                    type: 'text',
-                    text: message.content,
-                });
+                content.push({ type: 'text', text: message.content });
             }
-            // Handle tool_calls if present
-            if (message.tool_calls && message.tool_calls.length > 0) {
-                message.tool_calls.forEach((toolCall) => {
-                    let parsedInput;
-                    try {
-                        parsedInput = JSON.parse(toolCall.function.arguments || '{}');
-                    }
-                    catch (parseError) {
-                        const err = parseError;
-                        this.log(`Warning: Invalid JSON in tool arguments: ${err.message}`);
-                        parsedInput = { _error: 'Invalid JSON', _raw: toolCall.function.arguments };
-                    }
-                    content.push({
-                        type: 'tool_use',
-                        id: toolCall.id,
-                        name: toolCall.function.name,
-                        input: parsedInput,
-                    });
-                });
+            if (message.tool_calls?.length) {
+                content.push(...this.toolCallHandler.processToolCalls(message.tool_calls));
             }
             const anthropicResponse = {
                 id: openaiResponse.id || 'msg_' + Date.now(),
                 type: 'message',
                 role: 'assistant',
-                content: content,
+                content,
                 model: openaiResponse.model || 'glm-4.6',
-                stop_reason: this.mapStopReason(choice.finish_reason || 'stop'),
+                stop_reason: this.responseBuilder.mapStopReason(choice.finish_reason || 'stop'),
                 usage: {
                     input_tokens: openaiResponse.usage?.prompt_tokens || 0,
                     output_tokens: openaiResponse.usage?.completion_tokens || 0,
                 },
             };
-            // Validate transformation in verbose mode
-            if (this.verbose) {
-                const validation = this.validateTransformation(anthropicResponse);
-                this.log(`Transformation validation: ${validation.passed}/${validation.total} checks passed`);
-                if (!validation.valid) {
-                    this.log(`Failed checks: ${JSON.stringify(validation.checks, null, 2)}`);
-                }
-            }
-            // Log transformed response
             this.writeDebugLog('response-anthropic', anthropicResponse);
             return anthropicResponse;
         }
         catch (error) {
             const err = error;
             console.error('[glmt-transformer] Response transformation error:', err);
-            // Return minimal valid response
             return {
                 id: 'msg_error_' + Date.now(),
                 type: 'message',
                 role: 'assistant',
-                content: [
-                    {
-                        type: 'text',
-                        text: '[Transformation Error] ' + err.message,
-                    },
-                ],
+                content: [{ type: 'text', text: '[Transformation Error] ' + err.message }],
                 model: 'glm-4.6',
                 stop_reason: 'end_turn',
                 usage: { input_tokens: 0, output_tokens: 0 },
             };
         }
     }
-    /**
-     * Sanitize messages for OpenAI API compatibility
-     */
-    sanitizeMessages(messages) {
-        const result = [];
-        for (const msg of messages) {
-            // If content is a string, add as-is
-            if (typeof msg.content === 'string') {
-                result.push(msg);
-                continue;
-            }
-            // If content is an array, process blocks
-            if (Array.isArray(msg.content)) {
-                // Separate tool_result blocks from other content
-                const toolResults = msg.content.filter((block) => block.type === 'tool_result');
-                const textBlocks = msg.content.filter((block) => block.type === 'text');
-                // const toolUseBlocks = msg.content.filter(block => block.type === 'tool_use');
-                // CRITICAL: Tool messages must come BEFORE user text in OpenAI API
-                for (const toolResult of toolResults) {
-                    result.push({
-                        role: 'tool',
-                        content: typeof toolResult.content === 'string'
-                            ? toolResult.content
-                            : JSON.stringify(toolResult.content),
-                    });
-                }
-                // Add text content as user/assistant message AFTER tool messages
-                if (textBlocks.length > 0) {
-                    const textContent = textBlocks.length === 1
-                        ? textBlocks[0].text || ''
-                        : textBlocks.map((b) => b.text || '').join('\n');
-                    result.push({
-                        role: msg.role,
-                        content: textContent,
-                    });
-                }
-                // If no content at all, add empty message
-                if (textBlocks.length === 0 && toolResults.length === 0) {
-                    result.push({
-                        role: msg.role,
-                        content: '',
-                    });
-                }
-                continue;
-            }
-            // Fallback: return message as-is
-            result.push(msg);
-        }
-        return result;
-    }
-    /**
-     * Transform Anthropic tools to OpenAI tools format
-     */
-    transformTools(anthropicTools) {
-        return anthropicTools.map((tool) => ({
-            type: 'function',
-            function: {
-                name: tool.name,
-                description: tool.description,
-                parameters: tool.input_schema || {},
-            },
-        }));
-    }
-    /**
-     * Check if messages contain thinking control tags
-     */
-    hasThinkingTags(messages) {
-        for (const msg of messages) {
-            if (msg.role !== 'user')
-                continue;
-            const content = msg.content;
-            if (typeof content !== 'string')
-                continue;
-            // Check for control tags
-            if (/<Thinking:(On|Off)>/i.test(content) || /<Effort:(Low|Medium|High)>/i.test(content)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Extract thinking control tags from user messages
-     */
-    extractThinkingControl(messages) {
-        const config = {
-            thinking: this.defaultThinking,
-            effort: 'medium',
-        };
-        // Scan user messages for control tags
-        for (const msg of messages) {
-            if (msg.role !== 'user')
-                continue;
-            const content = msg.content;
-            if (typeof content !== 'string')
-                continue;
-            // Check for <Thinking:On|Off>
-            const thinkingMatch = content.match(/<Thinking:(On|Off)>/i);
-            if (thinkingMatch) {
-                config.thinking = thinkingMatch[1].toLowerCase() === 'on';
-            }
-            // Check for <Effort:Low|Medium|High>
-            const effortMatch = content.match(/<Effort:(Low|Medium|High)>/i);
-            if (effortMatch) {
-                config.effort = effortMatch[1].toLowerCase();
-            }
-        }
-        return config;
-    }
-    /**
-     * Generate thinking signature for Claude Code UI
-     */
-    generateThinkingSignature(thinking) {
-        // Generate signature hash
-        const hash = crypto.createHash('sha256').update(thinking).digest('hex').substring(0, 16);
-        return {
-            type: 'thinking_signature',
-            hash: hash,
-            length: thinking.length,
-            timestamp: Date.now(),
-        };
-    }
-    /**
-     * Detect Anthropic-style "think" keywords in user prompts
-     */
-    detectThinkKeywords(messages) {
-        if (!messages || messages.length === 0)
-            return null;
-        // Extract text from user messages
-        const text = messages
-            .filter((m) => m.role === 'user')
-            .map((m) => {
-            if (typeof m.content === 'string')
-                return m.content;
-            if (Array.isArray(m.content)) {
-                return m.content
-                    .filter((block) => block.type === 'text')
-                    .map((block) => block.text || '')
-                    .join(' ');
-            }
-            return '';
-        })
-            .join(' ');
-        // Priority: ultrathink > think harder > think hard > think
-        if (/\bultrathink\b/i.test(text)) {
-            return { thinking: true, effort: 'max', keyword: 'ultrathink' };
-        }
-        if (/\bthink\s+harder\b/i.test(text)) {
-            return { thinking: true, effort: 'high', keyword: 'think harder' };
-        }
-        if (/\bthink\s+hard\b/i.test(text)) {
-            return { thinking: true, effort: 'medium', keyword: 'think hard' };
-        }
-        if (/\bthink\b/i.test(text)) {
-            return { thinking: true, effort: 'low', keyword: 'think' };
-        }
-        return null; // No keywords detected
-    }
-    /**
-     * Inject reasoning parameters into OpenAI request
-     */
-    injectReasoningParams(openaiRequest, thinkingConfig) {
-        // Always enable sampling for temperature/top_p to work
-        openaiRequest.do_sample = true;
-        // Add thinking-specific parameters if enabled
-        if (thinkingConfig.thinking) {
-            openaiRequest.reasoning = true;
-            openaiRequest.reasoning_effort = thinkingConfig.effort;
-        }
-    }
-    /**
-     * Map Anthropic model to GLM model
-     */
-    mapModel(_anthropicModel) {
-        // Default to GLM-4.6 (latest and most capable)
-        return 'GLM-4.6';
-    }
-    /**
-     * Get max tokens for model
-     */
-    getMaxTokens(model) {
-        return this.modelMaxTokens[model] || 128000;
+    /** Transform streaming delta (delegates to StreamParser) */
+    transformDelta(openaiEvent, accumulator) {
+        return this.streamParser.transformDelta(openaiEvent, accumulator);
     }
-    /**
-     * Map OpenAI stop reason to Anthropic stop reason
-     */
-    mapStopReason(openaiReason) {
-        const mapping = {
-            stop: 'end_turn',
-            length: 'max_tokens',
-            tool_calls: 'tool_use',
-            content_filter: 'stop_sequence',
-        };
-        return mapping[openaiReason] || 'end_turn';
+    /** Finalize streaming (delegates to StreamParser) */
+    finalizeDelta(accumulator) {
+        return this.streamParser.finalizeDelta(accumulator);
     }
-    /**
-     * Write debug log to file
-     */
     writeDebugLog(type, data) {
         if (!this.debugLog)
             return;
         try {
             const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('.')[0];
-            const filename = `${timestamp}-${type}.json`;
-            const filepath = path.join(this.debugLogDir, filename);
-            // Ensure directory exists
+            const filepath = path.join(this.debugLogDir, `${timestamp}-${type}.json`);
             fs.mkdirSync(this.debugLogDir, { recursive: true });
-            // Write file (pretty-printed)
             fs.writeFileSync(filepath, JSON.stringify(data, null, 2) + '\n', 'utf8');
-            if (this.verbose) {
-                this.log(`Debug log written: ${filepath}`);
-            }
         }
         catch (error) {
-            const err = error;
-            console.error(`[glmt-transformer] Failed to write debug log: ${err.message}`);
+            console.error(`[glmt-transformer] Debug log error: ${error.message}`);
+        }
+    }
+    log(message) {
+        if (this.verbose) {
+            console.error(`[glmt-transformer] [${new Date().toTimeString().split(' ')[0]}] ${message}`);
         }
     }
-    /**
-     * Validate transformed Anthropic response
-     */
+    // ========== Backwards-compatible public methods ==========
+    /** Generate thinking signature (delegates to ResponseBuilder) */
+    generateThinkingSignature(thinking) {
+        return this.responseBuilder.generateThinkingSignature(thinking);
+    }
+    /** Map stop reason (delegates to ResponseBuilder) */
+    mapStopReason(openaiReason) {
+        return this.responseBuilder.mapStopReason(openaiReason);
+    }
+    /** Detect think keywords (delegates to ContentTransformer) */
+    detectThinkKeywords(messages) {
+        return this.contentTransformer.detectThinkKeywords(messages);
+    }
+    /** Validate transformation result */
     validateTransformation(anthropicResponse) {
         const checks = {
             hasContent: Boolean(anthropicResponse.content && anthropicResponse.content.length > 0),
@@ -482,350 +171,6 @@ class GlmtTransformer {
         const total = Object.keys(checks).length;
         return { checks, passed, total, valid: passed === total };
     }
-    /**
-     * Transform OpenAI streaming delta to Anthropic events
-     */
-    transformDelta(openaiEvent, accumulator) {
-        const events = [];
-        // Debug logging for streaming deltas
-        if (this.debugLog && openaiEvent.data) {
-            this.writeDebugLog('delta-openai', openaiEvent.data);
-        }
-        // Handle [DONE] marker
-        if (openaiEvent.event === 'done') {
-            if (!accumulator.isFinalized()) {
-                return this.finalizeDelta(accumulator);
-            }
-            return []; // Already finalized
-        }
-        // Usage update (appears in final chunk, may be before choice data)
-        if (openaiEvent.data?.usage) {
-            accumulator.updateUsage(openaiEvent.data.usage);
-            // If we have both usage AND finish_reason, finalize immediately
-            if (accumulator.getFinishReason()) {
-                events.push(...this.finalizeDelta(accumulator));
-                return events;
-            }
-        }
-        const choice = openaiEvent.data?.choices?.[0];
-        if (!choice)
-            return events;
-        const delta = choice.delta;
-        if (!delta)
-            return events;
-        // Message start
-        if (!accumulator.isMessageStarted()) {
-            if (openaiEvent.data?.model) {
-                accumulator.setModel(openaiEvent.data.model);
-            }
-            events.push(this.createMessageStartEvent(accumulator));
-            accumulator.setMessageStarted(true);
-        }
-        // Role
-        if (delta.role) {
-            accumulator.setRole(delta.role);
-        }
-        // Reasoning content delta
-        if (delta.reasoning_content) {
-            const currentBlock = accumulator.getCurrentBlock();
-            if (this.debugMode) {
-                console.error(`[GLMT-DEBUG] Reasoning delta: ${delta.reasoning_content.length} chars`);
-                console.error(`[GLMT-DEBUG] Current block: ${currentBlock?.type || 'none'}, index: ${currentBlock?.index ?? 'N/A'}`);
-            }
-            if (!currentBlock || currentBlock.type !== 'thinking') {
-                // Start thinking block
-                const block = accumulator.startBlock('thinking');
-                events.push(this.createContentBlockStartEvent(block));
-                if (this.debugMode) {
-                    console.error(`[GLMT-DEBUG] Started new thinking block ${block.index}`);
-                }
-            }
-            accumulator.addDelta(delta.reasoning_content);
-            const currentThinkingBlock = accumulator.getCurrentBlock();
-            if (currentThinkingBlock) {
-                events.push(this.createThinkingDeltaEvent(currentThinkingBlock, delta.reasoning_content));
-            }
-        }
-        // Text content delta
-        if (delta.content) {
-            const currentBlock = accumulator.getCurrentBlock();
-            // Close thinking block if transitioning from thinking to text
-            if (currentBlock && currentBlock.type === 'thinking' && !currentBlock.stopped) {
-                const signatureEvent = this.createSignatureDeltaEvent(currentBlock);
-                if (signatureEvent) {
-                    events.push(signatureEvent);
-                }
-                events.push(this.createContentBlockStopEvent(currentBlock));
-                accumulator.stopCurrentBlock();
-            }
-            if (!accumulator.getCurrentBlock() || accumulator.getCurrentBlock()?.type !== 'text') {
-                // Start text block
-                const block = accumulator.startBlock('text');
-                events.push(this.createContentBlockStartEvent(block));
-            }
-            accumulator.addDelta(delta.content);
-            const currentTextBlock = accumulator.getCurrentBlock();
-            if (currentTextBlock) {
-                events.push(this.createTextDeltaEvent(currentTextBlock, delta.content));
-            }
-        }
-        // Check for planning loop
-        if (accumulator.checkForLoop()) {
-            this.log('WARNING: Planning loop detected - 3 consecutive thinking blocks with no tool calls');
-            this.log('Forcing early finalization to prevent unbounded planning');
-            // Close current block if any
-            const currentBlock = accumulator.getCurrentBlock();
-            if (currentBlock && !currentBlock.stopped) {
-                if (currentBlock.type === 'thinking') {
-                    const signatureEvent = this.createSignatureDeltaEvent(currentBlock);
-                    if (signatureEvent) {
-                        events.push(signatureEvent);
-                    }
-                }
-                events.push(this.createContentBlockStopEvent(currentBlock));
-                accumulator.stopCurrentBlock();
-            }
-            // Force finalization
-            events.push(...this.finalizeDelta(accumulator));
-            return events;
-        }
-        // Tool calls deltas
-        if (delta.tool_calls && delta.tool_calls.length > 0) {
-            // Close current content block ONCE before processing any tool calls
-            const currentBlock = accumulator.getCurrentBlock();
-            if (currentBlock && !currentBlock.stopped) {
-                if (currentBlock.type === 'thinking') {
-                    const signatureEvent = this.createSignatureDeltaEvent(currentBlock);
-                    if (signatureEvent) {
-                        events.push(signatureEvent);
-                    }
-                }
-                events.push(this.createContentBlockStopEvent(currentBlock));
-                accumulator.stopCurrentBlock();
-            }
-            // Process each tool call delta
-            for (const toolCallDelta of delta.tool_calls) {
-                // Track tool call state
-                const isNewToolCall = !accumulator.hasToolCall(toolCallDelta.index);
-                accumulator.addToolCallDelta(toolCallDelta);
-                // Emit tool use events (start + input_json deltas)
-                if (isNewToolCall) {
-                    // Start new tool_use block in accumulator
-                    const block = accumulator.startBlock('tool_use');
-                    const toolCall = accumulator.getToolCall(toolCallDelta.index);
-                    events.push({
-                        event: 'content_block_start',
-                        data: {
-                            type: 'content_block_start',
-                            index: block.index,
-                            content_block: {
-                                type: 'tool_use',
-                                id: toolCall?.id || `tool_${toolCallDelta.index}`,
-                                name: toolCall?.function?.name || '',
-                            },
-                        },
-                    });
-                }
-                // Emit input_json delta if arguments present
-                if (toolCallDelta.function?.arguments) {
-                    const currentToolBlock = accumulator.getCurrentBlock();
-                    if (currentToolBlock && currentToolBlock.type === 'tool_use') {
-                        events.push({
-                            event: 'content_block_delta',
-                            data: {
-                                type: 'content_block_delta',
-                                index: currentToolBlock.index,
-                                delta: {
-                                    type: 'input_json_delta',
-                                    partial_json: toolCallDelta.function.arguments,
-                                },
-                            },
-                        });
-                    }
-                }
-            }
-        }
-        // Finish reason
-        if (choice.finish_reason) {
-            accumulator.setFinishReason(choice.finish_reason);
-            // If we have both finish_reason AND usage, finalize immediately
-            if (accumulator.hasUsageReceived()) {
-                events.push(...this.finalizeDelta(accumulator));
-            }
-        }
-        // Debug logging for generated events
-        if (this.debugLog && events.length > 0) {
-            this.writeDebugLog('delta-anthropic-events', {
-                events,
-                accumulator: accumulator.getSummary(),
-            });
-        }
-        return events;
-    }
-    /**
-     * Finalize streaming and generate closing events
-     */
-    finalizeDelta(accumulator) {
-        if (accumulator.isFinalized()) {
-            return []; // Already finalized
-        }
-        const events = [];
-        // Close current content block if any
-        const currentBlock = accumulator.getCurrentBlock();
-        if (currentBlock && !currentBlock.stopped) {
-            if (currentBlock.type === 'thinking') {
-                const signatureEvent = this.createSignatureDeltaEvent(currentBlock);
-                if (signatureEvent) {
-                    events.push(signatureEvent);
-                }
-            }
-            events.push(this.createContentBlockStopEvent(currentBlock));
-            accumulator.stopCurrentBlock();
-        }
-        // Message delta (stop reason + usage)
-        events.push({
-            event: 'message_delta',
-            data: {
-                type: 'message_delta',
-                delta: {
-                    stop_reason: this.mapStopReason(accumulator.getFinishReason() || 'stop'),
-                },
-                usage: {
-                    input_tokens: accumulator.getInputTokens(),
-                    output_tokens: accumulator.getOutputTokens(),
-                },
-            },
-        });
-        // Message stop
-        events.push({
-            event: 'message_stop',
-            data: {
-                type: 'message_stop',
-            },
-        });
-        accumulator.setFinalized(true);
-        return events;
-    }
-    /**
-     * Create message_start event
-     */
-    createMessageStartEvent(accumulator) {
-        return {
-            event: 'message_start',
-            data: {
-                type: 'message_start',
-                message: {
-                    id: accumulator.getMessageId(),
-                    type: 'message',
-                    role: accumulator.getRole(),
-                    content: [],
-                    model: accumulator.getModel() || 'glm-4.6',
-                    stop_reason: null,
-                    usage: {
-                        input_tokens: accumulator.getInputTokens(),
-                        output_tokens: 0,
-                    },
-                },
-            },
-        };
-    }
-    /**
-     * Create content_block_start event
-     */
-    createContentBlockStartEvent(block) {
-        return {
-            event: 'content_block_start',
-            data: {
-                type: 'content_block_start',
-                index: block.index,
-                content_block: {
-                    type: block.type,
-                    [block.type]: '',
-                },
-            },
-        };
-    }
-    /**
-     * Create thinking_delta event
-     */
-    createThinkingDeltaEvent(block, delta) {
-        return {
-            event: 'content_block_delta',
-            data: {
-                type: 'content_block_delta',
-                index: block.index,
-                delta: {
-                    type: 'thinking_delta',
-                    thinking: delta,
-                },
-            },
-        };
-    }
-    /**
-     * Create text_delta event
-     */
-    createTextDeltaEvent(block, delta) {
-        return {
-            event: 'content_block_delta',
-            data: {
-                type: 'content_block_delta',
-                index: block.index,
-                delta: {
-                    type: 'text_delta',
-                    text: delta,
-                },
-            },
-        };
-    }
-    /**
-     * Create thinking signature delta event
-     */
-    createSignatureDeltaEvent(block) {
-        // FIX: Guard against empty content (signature timing race)
-        if (!block.content || block.content.length === 0) {
-            if (this.verbose) {
-                this.log(`WARNING: Skipping signature for empty thinking block ${block.index}`);
-                this.log(`This indicates a race condition - signature requested before content accumulated`);
-            }
-            return null;
-        }
-        const signature = this.generateThinkingSignature(block.content);
-        if (this.verbose) {
-            this.log(`Generating signature for block ${block.index}: ${block.content.length} chars`);
-        }
-        return {
-            event: 'content_block_delta',
-            data: {
-                type: 'content_block_delta',
-                index: block.index,
-                delta: {
-                    type: 'thinking_signature_delta',
-                    signature: signature,
-                },
-            },
-        };
-    }
-    /**
-     * Create content_block_stop event
-     */
-    createContentBlockStopEvent(block) {
-        return {
-            event: 'content_block_stop',
-            data: {
-                type: 'content_block_stop',
-                index: block.index,
-            },
-        };
-    }
-    /**
-     * Log message if verbose
-     */
-    log(message) {
-        if (this.verbose) {
-            const timestamp = new Date().toTimeString().split(' ')[0]; // HH:MM:SS
-            console.error(`[glmt-transformer] [${timestamp}] ${message}`);
-        }
-    }
 }
 exports.GlmtTransformer = GlmtTransformer;
 exports.default = GlmtTransformer;