@hileeon/mcc 0.1.0

package/lib/proxy/glmt/pipeline/stream-parser.js

@@ -0,0 +1,234 @@
+"use strict";
+/**
+ * StreamParser - Transform OpenAI streaming deltas to Anthropic SSE events
+ *
+ * Responsibilities:
+ * - Process streaming deltas (reasoning_content, content, tool_calls)
+ * - Coordinate with accumulator for state tracking
+ * - Detect and handle planning loops
+ * - Generate appropriate Anthropic SSE events
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamParser = void 0;
+const response_builder_1 = require("./response-builder");
+const tool_call_handler_1 = require("./tool-call-handler");
+class StreamParser {
+    constructor(config = {}) {
+        this.verbose = config.verbose || false;
+        this.debugMode = config.debugMode || false;
+        this.debugLog = config.debugLog || false;
+        this.responseBuilder = new response_builder_1.ResponseBuilder(this.verbose);
+        this.toolCallHandler = new tool_call_handler_1.ToolCallHandler();
+        this.writeDebugLog = config.writeDebugLog || (() => { });
+    }
+    /**
+     * 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.responseBuilder.createMessageStartEvent(accumulator));
+            accumulator.setMessageStarted(true);
+        }
+        // Role
+        if (delta.role) {
+            accumulator.setRole(delta.role);
+        }
+        // Reasoning content delta
+        if (delta.reasoning_content) {
+            events.push(...this.handleReasoningDelta(delta.reasoning_content, accumulator));
+        }
+        // Text content delta
+        if (delta.content) {
+            events.push(...this.handleContentDelta(delta.content, accumulator));
+        }
+        // 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');
+            events.push(...this.forceFinalization(accumulator));
+            return events;
+        }
+        // Tool calls deltas
+        if (delta.tool_calls && delta.tool_calls.length > 0) {
+            events.push(...this.handleToolCallDeltas(delta.tool_calls, accumulator));
+        }
+        // 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;
+    }
+    /**
+     * Handle reasoning content delta
+     */
+    handleReasoningDelta(reasoningContent, accumulator) {
+        const events = [];
+        const currentBlock = accumulator.getCurrentBlock();
+        if (this.debugMode) {
+            console.error(`[StreamParser] Reasoning delta: ${reasoningContent.length} chars`);
+            console.error(`[StreamParser] 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.responseBuilder.createContentBlockStartEvent(block));
+            if (this.debugMode) {
+                console.error(`[StreamParser] Started new thinking block ${block.index}`);
+            }
+        }
+        accumulator.addDelta(reasoningContent);
+        const currentThinkingBlock = accumulator.getCurrentBlock();
+        if (currentThinkingBlock) {
+            events.push(this.responseBuilder.createThinkingDeltaEvent(currentThinkingBlock, reasoningContent));
+        }
+        return events;
+    }
+    /**
+     * Handle content delta
+     */
+    handleContentDelta(content, accumulator) {
+        const events = [];
+        const currentBlock = accumulator.getCurrentBlock();
+        // Close thinking block if transitioning from thinking to text
+        if (currentBlock && currentBlock.type === 'thinking' && !currentBlock.stopped) {
+            events.push(...this.closeThinkingBlock(currentBlock, accumulator));
+        }
+        if (!accumulator.getCurrentBlock() || accumulator.getCurrentBlock()?.type !== 'text') {
+            // Start text block
+            const block = accumulator.startBlock('text');
+            events.push(this.responseBuilder.createContentBlockStartEvent(block));
+        }
+        accumulator.addDelta(content);
+        const currentTextBlock = accumulator.getCurrentBlock();
+        if (currentTextBlock) {
+            events.push(this.responseBuilder.createTextDeltaEvent(currentTextBlock, content));
+        }
+        return events;
+    }
+    /**
+     * Handle tool call deltas
+     */
+    handleToolCallDeltas(toolCallDeltas, accumulator) {
+        const events = [];
+        if (!toolCallDeltas)
+            return events;
+        const currentBlock = accumulator.getCurrentBlock();
+        if (currentBlock && !currentBlock.stopped && currentBlock.type !== 'tool_use') {
+            if (currentBlock.type === 'thinking') {
+                events.push(...this.closeThinkingBlock(currentBlock, accumulator));
+            }
+            else {
+                events.push(this.responseBuilder.createContentBlockStopEvent(currentBlock));
+                accumulator.stopCurrentBlock();
+            }
+        }
+        events.push(...this.toolCallHandler.processToolCallDeltas(toolCallDeltas, accumulator));
+        return events;
+    }
+    /**
+     * Close thinking block with signature
+     */
+    closeThinkingBlock(block, accumulator) {
+        const events = [];
+        const signatureEvent = this.responseBuilder.createSignatureDeltaEvent(block);
+        if (signatureEvent) {
+            events.push(signatureEvent);
+        }
+        events.push(this.responseBuilder.createContentBlockStopEvent(block));
+        accumulator.stopCurrentBlock();
+        return events;
+    }
+    /**
+     * Force finalization due to loop detection
+     */
+    forceFinalization(accumulator) {
+        const events = [];
+        const unstoppedBlocks = accumulator.getUnstoppedBlocks();
+        for (const block of unstoppedBlocks) {
+            if (block.type === 'thinking') {
+                const signatureEvent = this.responseBuilder.createSignatureDeltaEvent(block);
+                if (signatureEvent) {
+                    events.push(signatureEvent);
+                }
+            }
+            events.push(this.responseBuilder.createContentBlockStopEvent(block));
+            block.stopped = true;
+        }
+        events.push(...this.finalizeDelta(accumulator));
+        return events;
+    }
+    finalizeDelta(accumulator) {
+        if (accumulator.isFinalized()) {
+            return [];
+        }
+        const events = [];
+        const unstoppedBlocks = accumulator.getUnstoppedBlocks();
+        for (const block of unstoppedBlocks) {
+            if (block.type === 'thinking') {
+                const signatureEvent = this.responseBuilder.createSignatureDeltaEvent(block);
+                if (signatureEvent) {
+                    events.push(signatureEvent);
+                }
+            }
+            events.push(this.responseBuilder.createContentBlockStopEvent(block));
+            block.stopped = true;
+        }
+        const stopReason = this.responseBuilder.mapStopReason(accumulator.getFinishReason() || 'stop');
+        events.push(...this.responseBuilder.createFinalizationEvents(accumulator, stopReason));
+        accumulator.setFinalized(true);
+        return events;
+    }
+    /**
+     * Log message if verbose
+     */
+    log(message) {
+        if (this.verbose) {
+            const timestamp = new Date().toTimeString().split(' ')[0]; // HH:MM:SS
+            console.error(`[StreamParser] [${timestamp}] ${message}`);
+        }
+    }
+}
+exports.StreamParser = StreamParser;
+//# sourceMappingURL=stream-parser.js.map

package/lib/proxy/glmt/pipeline/tool-call-handler.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * ToolCallHandler - Handle tool call processing for streaming responses
+ *
+ * Responsibilities:
+ * - Process tool call deltas from OpenAI
+ * - Generate tool_use content blocks for Anthropic format
+ * - Handle input_json_delta events
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolCallHandler = void 0;
+class ToolCallHandler {
+    processToolCalls(toolCalls) {
+        const content = [];
+        for (const toolCall of toolCalls) {
+            let parsedInput;
+            try {
+                parsedInput = JSON.parse(toolCall.function.arguments || '{}');
+            }
+            catch (parseError) {
+                const err = parseError;
+                console.error(`[ToolCallHandler] 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,
+            });
+        }
+        return content;
+    }
+    processToolCallDeltas(toolCallDeltas, accumulator) {
+        const events = [];
+        for (const toolCallDelta of toolCallDeltas) {
+            const isNewToolCall = !accumulator.hasToolCall(toolCallDelta.index);
+            accumulator.addToolCallDelta(toolCallDelta);
+            if (isNewToolCall) {
+                // OpenAI may interleave tool_call fragments across chunks, so blocks must stay open
+                // until the stream finalizes. Closing on a later index truncates earlier tool input.
+                const block = accumulator.startBlock('tool_use');
+                const toolCall = accumulator.getToolCall(toolCallDelta.index);
+                accumulator.setToolCallBlockIndex(toolCallDelta.index, block.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 || '',
+                            input: {},
+                        },
+                    },
+                });
+            }
+            if (toolCallDelta.function?.arguments) {
+                const toolCallBlockIndex = accumulator.getToolCallBlockIndex(toolCallDelta.index);
+                events.push({
+                    event: 'content_block_delta',
+                    data: {
+                        type: 'content_block_delta',
+                        index: toolCallBlockIndex,
+                        delta: {
+                            type: 'input_json_delta',
+                            partial_json: toolCallDelta.function.arguments,
+                        },
+                    },
+                });
+            }
+        }
+        return events;
+    }
+}
+exports.ToolCallHandler = ToolCallHandler;
+//# sourceMappingURL=tool-call-handler.js.map

package/lib/proxy/glmt/pipeline/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Pipeline Types - Shared types for GLMT transformation pipeline
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/lib/proxy/glmt/reasoning-enforcer.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * ReasoningEnforcer - Inject explicit reasoning instructions into prompts
+ *
+ * Purpose: Force GLM models to use structured reasoning output format (<reasoning_content>)
+ * This complements API parameters (reasoning: true) with explicit prompt instructions.
+ *
+ * Strategy:
+ *   1. If system prompt exists: Prepend reasoning instruction
+ *   2. If no system prompt: Prepend to first user message
+ *   3. Select prompt template based on effort level (low/medium/high/max)
+ *   4. Preserve message structure (string vs array content)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReasoningEnforcer = void 0;
+class ReasoningEnforcer {
+    constructor(options = {}) {
+        this.enabled = options.enabled ?? false; // Opt-in by default
+        this.prompts = options.prompts || this.getDefaultPrompts();
+    }
+    /**
+     * Inject reasoning instruction into messages
+     * @param messages - Messages array to modify
+     * @param thinkingConfig - { thinking: boolean, effort: string }
+     * @returns Modified messages array
+     */
+    injectInstruction(messages, thinkingConfig = {}) {
+        // Only inject if enabled or thinking explicitly requested
+        if (!this.enabled && !thinkingConfig.thinking) {
+            return messages;
+        }
+        // Clone messages to avoid mutation
+        const modifiedMessages = JSON.parse(JSON.stringify(messages));
+        // Select prompt based on effort level
+        const effort = (thinkingConfig.effort?.toLowerCase() || 'medium');
+        const prompt = this.selectPrompt(effort);
+        // Strategy 1: Inject into system prompt (preferred)
+        const systemIndex = modifiedMessages.findIndex((m) => m.role === 'system');
+        if (systemIndex >= 0) {
+            const systemMsg = modifiedMessages[systemIndex];
+            if (typeof systemMsg.content === 'string') {
+                systemMsg.content = `${prompt}\n\n${systemMsg.content}`;
+            }
+            else if (Array.isArray(systemMsg.content)) {
+                systemMsg.content.unshift({
+                    type: 'text',
+                    text: prompt,
+                });
+            }
+            return modifiedMessages;
+        }
+        // Strategy 2: Prepend to first user message
+        const userIndex = modifiedMessages.findIndex((m) => m.role === 'user');
+        if (userIndex >= 0) {
+            const userMsg = modifiedMessages[userIndex];
+            if (typeof userMsg.content === 'string') {
+                userMsg.content = `${prompt}\n\n${userMsg.content}`;
+            }
+            else if (Array.isArray(userMsg.content)) {
+                userMsg.content.unshift({
+                    type: 'text',
+                    text: prompt,
+                });
+            }
+            return modifiedMessages;
+        }
+        // No system or user messages found (edge case)
+        return modifiedMessages;
+    }
+    /**
+     * Select prompt template based on effort level
+     */
+    selectPrompt(effort) {
+        return this.prompts[effort] || this.prompts.medium;
+    }
+    /**
+     * Get default prompt templates
+     */
+    getDefaultPrompts() {
+        return {
+            low: `You are an expert reasoning model using GLM-4.6 architecture.
+
+CRITICAL: Before answering, write 2-3 sentences of reasoning in <reasoning_content> tags.
+
+OUTPUT FORMAT:
+<reasoning_content>
+(Brief analysis: what is the problem? what's the approach?)
+</reasoning_content>
+
+(Write your final answer here)`,
+            medium: `You are an expert reasoning model using GLM-4.6 architecture.
+
+CRITICAL REQUIREMENTS:
+1. Always think step-by-step before answering
+2. Write your reasoning process explicitly in <reasoning_content> tags
+3. Never skip your chain of thought, even for simple problems
+
+OUTPUT FORMAT:
+<reasoning_content>
+(Write your detailed thinking here: analyze the problem, explore approaches,
+evaluate trade-offs, and arrive at a conclusion)
+</reasoning_content>
+
+(Write your final answer here based on your reasoning above)`,
+            high: `You are an expert reasoning model using GLM-4.6 architecture.
+
+CRITICAL REQUIREMENTS:
+1. Think deeply and systematically before answering
+2. Write comprehensive reasoning in <reasoning_content> tags
+3. Explore multiple approaches and evaluate trade-offs
+4. Show all steps in your problem-solving process
+
+OUTPUT FORMAT:
+<reasoning_content>
+(Write exhaustive analysis here:
+ - Problem decomposition
+ - Multiple approach exploration
+ - Trade-off analysis for each approach
+ - Edge case consideration
+ - Final conclusion with justification)
+</reasoning_content>
+
+(Write your final answer here based on your systematic reasoning above)`,
+            max: `You are an expert reasoning model using GLM-4.6 architecture.
+
+CRITICAL REQUIREMENTS:
+1. Think exhaustively from first principles
+2. Write extremely detailed reasoning in <reasoning_content> tags
+3. Analyze ALL possible angles, approaches, and edge cases
+4. Challenge your own assumptions and explore alternatives
+5. Provide rigorous justification for every claim
+
+OUTPUT FORMAT:
+<reasoning_content>
+(Write comprehensive analysis here:
+ - First principles breakdown
+ - Exhaustive approach enumeration
+ - Comparative analysis of all approaches
+ - Edge case and failure mode analysis
+ - Assumption validation
+ - Counter-argument consideration
+ - Final conclusion with rigorous justification)
+</reasoning_content>
+
+(Write your final answer here based on your exhaustive reasoning above)`,
+        };
+    }
+}
+exports.ReasoningEnforcer = ReasoningEnforcer;
+exports.default = ReasoningEnforcer;
+//# sourceMappingURL=reasoning-enforcer.js.map

package/lib/proxy/glmt/sse-parser.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * SSEParser - Parse Server-Sent Events (SSE) stream
+ *
+ * Handles:
+ * - Incomplete events across chunks
+ * - Multiple events in single chunk
+ * - Malformed data (skip gracefully)
+ * - [DONE] marker
+ *
+ * Usage:
+ *   const parser = new SSEParser();
+ *   stream.on('data', chunk => {
+ *     const events = parser.parse(chunk);
+ *     events.forEach(event => { ... });
+ *   });
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSEParser = void 0;
+class SSEParser {
+    constructor(options = {}) {
+        this.buffer = '';
+        this.eventCount = 0;
+        this.maxBufferSize = options.maxBufferSize || 1024 * 1024; // 1MB default
+        this.throwOnMalformedJson = options.throwOnMalformedJson === true;
+    }
+    /**
+     * Parse chunk and extract SSE events
+     * @param chunk - Data chunk from stream
+     * @returns Array of parsed events
+     */
+    parse(chunk) {
+        this.buffer += chunk.toString().replace(/\r\n?/g, '\n');
+        // C-01 Fix: Prevent unbounded buffer growth (DoS protection)
+        if (this.buffer.length > this.maxBufferSize) {
+            throw new Error(`SSE buffer exceeded ${this.maxBufferSize} bytes (DoS protection)`);
+        }
+        const events = [];
+        const segments = this.buffer.split('\n\n');
+        this.buffer = segments.pop() || '';
+        for (const segment of segments) {
+            const lines = segment.split('\n');
+            const currentEvent = { event: 'message', data: '' };
+            const dataLines = [];
+            for (const rawLine of lines) {
+                const line = rawLine.trimEnd();
+                if (!line || line.startsWith(':')) {
+                    continue;
+                }
+                if (line.startsWith('event: ')) {
+                    currentEvent.event = line.substring(7).trim();
+                    continue;
+                }
+                if (line.startsWith('data:')) {
+                    dataLines.push(line.substring(5).trimStart());
+                    continue;
+                }
+                if (line.startsWith('id: ')) {
+                    currentEvent.id = line.substring(4).trim();
+                    continue;
+                }
+                if (line.startsWith('retry: ')) {
+                    currentEvent.retry = parseInt(line.substring(7), 10);
+                }
+            }
+            const data = dataLines.join('\n');
+            if (!data) {
+                continue;
+            }
+            if (data === '[DONE]') {
+                this.eventCount++;
+                events.push({ event: 'done', data: null, index: this.eventCount });
+                continue;
+            }
+            try {
+                currentEvent.data = JSON.parse(data);
+                this.eventCount++;
+                currentEvent.index = this.eventCount;
+                events.push({ ...currentEvent });
+            }
+            catch (e) {
+                if (typeof console !== 'undefined' && console.error) {
+                    console.error('[SSEParser] Malformed JSON event:', e.message, 'Data:', data.substring(0, 100));
+                }
+                if (this.throwOnMalformedJson) {
+                    throw new Error(`Malformed SSE JSON event: ${e.message}`);
+                }
+            }
+        }
+        return events;
+    }
+    /**
+     * Reset parser state (for reuse)
+     */
+    reset() {
+        this.buffer = '';
+        this.eventCount = 0;
+    }
+}
+exports.SSEParser = SSEParser;
+//# sourceMappingURL=sse-parser.js.map

package/lib/proxy/services/logging.js

@@ -0,0 +1,13 @@
+/**
+ * Stub for CCS services/logging - provides no-op logger
+ */
+function createLogger(_name) {
+  return {
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {},
+    stage: () => {},
+  };
+}
+module.exports = { createLogger };