@a1hvdy/cc-openclaw 0.5.2 → 0.7.0

package/vendor/openai-compat.js

@@ -1,765 +0,0 @@
-/**
- * OpenAI-compatible /v1/chat/completions endpoint.
- *
- * Bridges OpenAI API format to persistent Claude Code sessions, enabling
- * webchat frontends (ChatGPT-Next-Web, Open WebUI, etc.) to use the plugin
- * as a drop-in backend. Stateful sessions maximize Anthropic prompt caching.
- */
-import * as http from 'node:http';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { randomUUID, createHash } from 'node:crypto';
-import { resolveEngineAndModel } from './models.js';
-import { OPENAI_COMPAT_DEFAULT_MODEL, OPENAI_COMPAT_AUTO_COMPACT_THRESHOLD, OPENAI_COMPAT_SESSION_PREFIX, } from './constants.js';
-import { maybeInlineSkill } from './skill-resolver.js';
-// ─── Session Key Resolution ──────────────────────────────────────────────────
-/**
- * Derive a session key from the request.
- * Priority: X-Session-Id header > user field > sha1(model + systemPrompt) > "default"
- *
- * The system-prompt-hash fallback prevents the bug where every caller without
- * X-Session-Id or `user` collapses onto a single shared "openai-default"
- * plugin session. In multi-caller setups (OpenClaw routing the main agent,
- * cron jobs, and subagents through the same gateway) that previously meant
- * every request serialized against every other and frequently picked up the
- * wrong session's appendSystemPrompt — also a privacy leak across callers.
- *
- * The model is mixed into the hash so that two callers with the same system
- * prompt but different requested models don't collide and silently get
- * responses from the wrong model. Originally diagnosed in PR #40 by
- * @megayounus786.
- */
-export function resolveSessionKey(body, headers) {
-    const headerKey = headers['x-session-id'];
-    if (typeof headerKey === 'string' && headerKey.trim())
-        return headerKey.trim();
-    if (body.user && body.user.trim())
-        return body.user.trim();
-    const sys = (body.messages || [])
-        .filter((m) => m && m.role === 'system')
-        .map((m) => (typeof m.content === 'string' ? m.content : JSON.stringify(m.content)))
-        .join('\n');
-    const modelTag = (body.model || '').toString();
-    if (sys || modelTag) {
-        return ('sys-' +
-            createHash('sha1')
-                .update(modelTag + '\n' + sys)
-                .digest('hex')
-                .slice(0, 12));
-    }
-    return 'default';
-}
-/** Build the full session name from a key */
-export function sessionNameFromKey(key) {
-    return `${OPENAI_COMPAT_SESSION_PREFIX}${key}`;
-}
-// ─── Function Calling Support ────────────────────────────────────────────────
-/**
- * Convert OpenAI tool definitions into a structured prompt block.
- * Injected into the user message so the CLI model sees tool definitions
- * and responds with <tool_calls> tags when it wants to invoke a function.
- */
-export function buildToolPromptBlock(tools) {
-    if (!tools?.length)
-        return '';
-    const toolDefs = tools
-        .map((t) => {
-        const fn = t.function;
-        const params = JSON.stringify(fn.parameters, null, 2);
-        return `### ${fn.name}\n${fn.description}\n\nParameters:\n\`\`\`json\n${params}\n\`\`\``;
-    })
-        .join('\n\n');
-    return ('<available_tools>\n' +
-        'You have access to the following tools. When you need to use a tool, respond with a JSON array wrapped in <tool_calls> tags.\n\n' +
-        'FORMAT:\n' +
-        '<tool_calls>\n' +
-        '[{"name": "tool_name", "arguments": {"param1": "value1"}}]\n' +
-        '</tool_calls>\n\n' +
-        'If you do NOT need any tools, respond normally with text only (no <tool_calls> tags).\n\n' +
-        '## Available Tools\n\n' +
-        toolDefs +
-        '\n</available_tools>');
-}
-/**
- * Parse tool_calls from CLI text output.
- *
- * Looks for <tool_calls>[...]</tool_calls> tags in the response text.
- * Returns both the extracted text content (before/after tags) and any tool calls found.
- */
-export function parseToolCallsFromText(text) {
-    // Match ALL <tool_calls> blocks (model may output multiple)
-    const tagRegex = /<tool_calls>\s*([\s\S]*?)\s*<\/tool_calls>/g;
-    const allCalls = [];
-    let lastIndex = 0;
-    const textParts = [];
-    let m;
-    while ((m = tagRegex.exec(text)) !== null) {
-        // Collect text before this block
-        const before = text.slice(lastIndex, m.index).trim();
-        if (before)
-            textParts.push(before);
-        lastIndex = m.index + m[0].length;
-        try {
-            const parsed = JSON.parse(m[1].trim());
-            const arr = Array.isArray(parsed) ? parsed : [parsed];
-            for (const raw of arr) {
-                const call = raw;
-                if (!call || typeof call !== 'object' || typeof call.name !== 'string')
-                    continue;
-                let args;
-                if (typeof call.arguments === 'string') {
-                    try {
-                        JSON.parse(call.arguments);
-                        args = call.arguments;
-                    }
-                    catch {
-                        args = JSON.stringify({ input: call.arguments });
-                    }
-                }
-                else {
-                    args = JSON.stringify(call.arguments ?? {});
-                }
-                allCalls.push({
-                    id: `call_${randomUUID().replace(/-/g, '').slice(0, 24)}`,
-                    type: 'function',
-                    function: { name: call.name, arguments: args },
-                });
-            }
-        }
-        catch {
-            // One block failed — keep its text as content
-            textParts.push(m[0]);
-        }
-    }
-    // Collect text after last block
-    const after = text.slice(lastIndex).trim();
-    if (after)
-        textParts.push(after);
-    // Strip <tool_result> and <tool_results> tags that the model may echo back
-    // from the serialized tool results we injected earlier.
-    const stripToolResultTags = (s) => s
-        .replace(/<tool_results?>[\s\S]*?<\/tool_results?>/g, '')
-        .replace(/<tool_results?[^>]*>/g, '')
-        .trim();
-    if (allCalls.length > 0) {
-        const raw = textParts.join('\n').trim();
-        const cleaned = raw ? stripToolResultTags(raw) : null;
-        return { textContent: cleaned || null, toolCalls: allCalls };
-    }
-    const cleaned = text ? stripToolResultTags(text) : null;
-    return { textContent: cleaned || null, toolCalls: [] };
-}
-/**
- * Serialize tool result messages into a text block for the CLI model.
- * Converts OpenAI `tool` role messages into <tool_result> tags.
- */
-export function serializeToolResults(messages) {
-    const toolMessages = messages.filter((m) => m.role === 'tool');
-    if (!toolMessages.length)
-        return '';
-    const results = toolMessages
-        .map((m) => {
-        const content = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
-        return `<tool_result tool_call_id="${m.tool_call_id || 'unknown'}">\n${content}\n</tool_result>`;
-    })
-        .join('\n\n');
-    return `<tool_results>\n${results}\n</tool_results>\n\nAbove are the results of the tool calls you requested. Continue your response based on these results.`;
-}
-/**
- * Extract the relevant parts from an OpenAI messages array.
- *
- * Sessions are stateful — we only need the last user message. The tricky
- * question is whether to start a fresh session or append to the existing one.
- *
- * Default mode (no env var): only honor an explicit `X-Session-Reset: 1`
- * header. This is correct for clients that maintain their own conversation
- * transcript and forward only the latest user turn (OpenClaw main agent
- * loop, cron jobs, subagents). The previous heuristic
- * (`nonSystemMessages.length <= 1`) fired on every such request, killing the
- * persistent CLI every turn and preventing Anthropic prompt caching from
- * ever warming. Originally diagnosed in PR #40 by @megayounus786.
- *
- * Legacy mode (`OPENAI_COMPAT_NEW_CONVO_HEURISTIC=1`): restore the old
- * `system + single user ⇒ new conversation` rule, for clients that re-send
- * the full transcript on every turn (ChatGPT-Next-Web, Open WebUI, data
- * labeling tools, etc). They use the transcript shape itself as their only
- * "start a new conversation" signal.
- *
- * The env var is read on every call so ops can flip it via launchctl setenv
- * without restarting the server.
- */
-export function extractUserMessage(messages, headers) {
-    if (!messages || messages.length === 0) {
-        throw new Error('messages array is empty');
-    }
-    // Normalize content from any message: OpenAI API allows content as a string
-    // OR an array of content parts (e.g. multimodal messages with text + images).
-    // We need a string for the CLI, so arrays are joined.
-    const textOf = (m) => {
-        if (typeof m.content === 'string')
-            return m.content;
-        if (Array.isArray(m.content)) {
-            return m.content
-                .map((p) => p.text || '')
-                .filter(Boolean)
-                .join('');
-        }
-        return m.content != null ? String(m.content) : '';
-    };
-    // Extract system prompt if present
-    const systemMessages = messages.filter((m) => m.role === 'system');
-    const systemPrompt = systemMessages.length > 0 ? systemMessages.map(textOf).join('\n') : undefined;
-    // Handle tool result messages — only when the LAST non-system message is
-    // a tool role (meaning we're in an active tool-use cycle). If the last
-    // message is a user role, it's a follow-up in an existing conversation
-    // and the old tool results are already in the CLI's history.
-    const lastNonSystem = [...messages].reverse().find((m) => m.role !== 'system');
-    if (lastNonSystem?.role === 'tool') {
-        const toolResultBlock = serializeToolResults(messages);
-        const userMessages = messages.filter((m) => m.role === 'user');
-        const lastUserText = userMessages.length > 0 ? textOf(userMessages[userMessages.length - 1]) : '';
-        const userMessage = lastUserText ? `${toolResultBlock}\n\n${lastUserText}` : toolResultBlock;
-        return { systemPrompt, userMessage, isNewConversation: false };
-    }
-    // Find user messages — concatenate all of them in order.
-    //
-    // 2026-05-07 fix for OpenClaw 2026.5.6 multi-user-message format:
-    // 5.6 sends TWO user messages — [0]=actual user input as content blocks,
-    // [1]=large system context + sender metadata as a string. The previous
-    // `userMessages[length-1]` extraction picked up the metadata blob and
-    // silently dropped the actual user input, causing bare prompts to appear
-    // as empty questions to Claude (Claude responds with stale/recycled
-    // context like "Good. What's up?" because no real question reached it).
-    //
-    // Fix: concatenate all user messages with double-newline separator. This
-    // ensures the actual user input AND the conversation/runtime context
-    // both reach Claude. The first message (typed text) leads, followed by
-    // the metadata block as additional context.
-    //
-    // Backwards compat: when only one user message exists (older OpenClaw
-    // versions or non-OpenClaw callers), this is identical to the old
-    // single-message extraction.
-    const userMessages = messages.filter((m) => m.role === 'user');
-    if (userMessages.length === 0) {
-        throw new Error('No user message found in messages array');
-    }
-    const userTexts = userMessages.map(textOf).filter((t) => t && t.length > 0);
-    const rawUserMessage = userTexts.length > 1
-        ? userTexts.join('\n\n')
-        : (userTexts[0] || textOf(userMessages[userMessages.length - 1]));
-    // Workspace skill auto-inline: if the user typed /<skillname> [args] and
-    // ~/.openclaw/workspace/skills/*/SKILL.md has a matching `name:` frontmatter,
-    // inline the SKILL.md body so the model has full skill context without
-    // needing the Read tool (which cc-openclaw disables — see line 358).
-    const userMessage = maybeInlineSkill(rawUserMessage) ?? rawUserMessage;
-    // 1. Explicit reset header — honored in both modes. Normalize trim+lowercase
-    //    so callers using `TRUE`, ` 1 `, etc. don't silently fail.
-    const rawReset = headers?.['x-session-reset'];
-    const resetHeader = typeof rawReset === 'string' ? rawReset.trim().toLowerCase() : '';
-    if (resetHeader === 'true' || resetHeader === '1') {
-        return { systemPrompt, userMessage, isNewConversation: true };
-    }
-    // 2. Legacy heuristic — only when explicitly opted in via env var.
-    if (process.env.OPENAI_COMPAT_NEW_CONVO_HEURISTIC === '1') {
-        const nonSystemMessages = messages.filter((m) => m.role !== 'system');
-        return { systemPrompt, userMessage, isNewConversation: nonSystemMessages.length <= 1 };
-    }
-    return { systemPrompt, userMessage, isNewConversation: false };
-}
-// ─── Response Formatting ─────────────────────────────────────────────────────
-export function formatCompletionResponse(id, model, text, tokensIn, tokensOut, toolCalls) {
-    const hasToolCalls = toolCalls && toolCalls.length > 0;
-    return {
-        id,
-        object: 'chat.completion',
-        created: Math.floor(Date.now() / 1000),
-        model,
-        choices: [
-            {
-                index: 0,
-                message: {
-                    role: 'assistant',
-                    content: text || null,
-                    ...(hasToolCalls ? { tool_calls: toolCalls } : {}),
-                },
-                finish_reason: hasToolCalls ? 'tool_calls' : 'stop',
-            },
-        ],
-        usage: {
-            prompt_tokens: tokensIn,
-            completion_tokens: tokensOut,
-            total_tokens: tokensIn + tokensOut,
-        },
-    };
-}
-export function formatCompletionChunk(id, model, delta, finishReason) {
-    return {
-        id,
-        object: 'chat.completion.chunk',
-        created: Math.floor(Date.now() / 1000),
-        model,
-        choices: [{ index: 0, delta, finish_reason: finishReason }],
-    };
-}
-export async function handleChatCompletion(manager, body, headers, res) {
-    // Validate before casting
-    if (!body.messages || !Array.isArray(body.messages) || body.messages.length === 0) {
-        res.writeHead(400, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-            error: { message: 'messages is required and must be a non-empty array', type: 'invalid_request_error' },
-        }));
-        return;
-    }
-    // Safe cast: messages validated above, other fields are optional
-    const request = {
-        messages: body.messages,
-        model: body.model,
-        stream: body.stream,
-        temperature: body.temperature,
-        max_tokens: body.max_tokens,
-        user: body.user,
-        tools: body.tools,
-    };
-    // Validate max_tokens if provided
-    if (request.max_tokens !== undefined && (typeof request.max_tokens !== 'number' || request.max_tokens <= 0)) {
-        res.writeHead(400, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-            error: { message: 'max_tokens must be a positive number', type: 'invalid_request_error' },
-        }));
-        return;
-    }
-    const modelStr = request.model || OPENAI_COMPAT_DEFAULT_MODEL;
-    const { engine, model: resolvedModel } = resolveEngineAndModel(modelStr);
-    const sessionKey = resolveSessionKey(request, headers);
-    const sessionName = sessionNameFromKey(sessionKey);
-    const isStreaming = request.stream === true;
-    let extracted;
-    try {
-        extracted = extractUserMessage(request.messages, headers);
-    }
-    catch (err) {
-        res.writeHead(400, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: { message: err.message, type: 'invalid_request_error' } }));
-        return;
-    }
-    // Check if session exists
-    const existingSessions = manager.listSessions().map((s) => s.name);
-    const sessionExists = existingSessions.includes(sessionName);
-    // If new conversation detected and session exists, stop old one first
-    if (extracted.isNewConversation && sessionExists) {
-        try {
-            await manager.stopSession(sessionName);
-        }
-        catch {
-            /* session may have already been cleaned up */
-        }
-    }
-    // Create session if needed
-    const needsCreate = !sessionExists || extracted.isNewConversation;
-    if (needsCreate) {
-        // OpenAI-compat sessions are API proxies, not coding sessions.
-        // Use a neutral empty temp dir so the CLI doesn't load CLAUDE.md,
-        // git state, or project context from wherever `serve` was started.
-        const sessionCwd = path.join(os.tmpdir(), `openclaw-compat-${sessionName}`);
-        if (!fs.existsSync(sessionCwd))
-            fs.mkdirSync(sessionCwd, { recursive: true });
-        const sessionConfig = {
-            name: sessionName,
-            cwd: sessionCwd,
-            engine,
-            model: resolvedModel,
-            permissionMode: 'bypassPermissions',
-            // skipPersistence: tells SessionManager not to write this session to
-            // the disk registry, preventing auto-resume of stale sessions.
-            // Note: noSessionPersistence (--no-session-persistence) is NOT set
-            // because some CLI forks don't support this flag.
-            skipPersistence: true,
-        };
-        // Phase 2 R5: tool-stream mode flag (mirrors src/openai-compat/openai-compat.ts).
-        // When CC_OPENCLAW_TOOL_STREAM=1 AND caller provides tools[], skip
-        // both the sessionConfig.tools='' defensive clear AND the no-tools
-        // system prompt — Claude CLI tool_use events flow through natively.
-        const toolStreamMode = process.env.CC_OPENCLAW_TOOL_STREAM === '1';
-        const useToolStreamPath = toolStreamMode && request.tools?.length;
-        // Phase 2 R5+R3: tool-stream mode forwards the allowlist of tool names
-        // from request.tools[] so Claude CLI knows which tools the model is
-        // allowed to invoke. Legacy mode clears tools entirely.
-        // v0.4.9 patch: CC_OPENCLAW_ALLOW_BUILTINS=1 short-circuits BOTH paths
-        // so Claude CLI keeps its full built-in tool surface unrestricted.
-        const __ccAllowBuiltinsForTools = process.env.CC_OPENCLAW_ALLOW_BUILTINS === '1';
-        if (engine === 'claude' && !__ccAllowBuiltinsForTools) {
-            if (useToolStreamPath) {
-                const toolNames = request.tools
-                    .map((t) => t?.function?.name)
-                    .filter((n) => typeof n === 'string' && n.length > 0)
-                    .join(',');
-                if (toolNames) sessionConfig.tools = toolNames;
-            }
-            else {
-                sessionConfig.tools = '';
-            }
-        }
-        // System prompt: legacy modes inject the defensive "no tools" or
-        // "pure text" prompt. Tool-stream mode passes the caller's system
-        // prompt through unchanged (Claude CLI gets native tools).
-        // v0.4.9 patch: when CC_OPENCLAW_ALLOW_BUILTINS=1, ALL paths get an
-        // affirmative tool prompt — the legacy "no tools" / "pure text" text
-        // was being hallucinated/quoted by the model verbatim, suppressing
-        // tool use even when the CLI was spawned with full built-ins.
-        if (engine === 'claude') {
-            const __ccAllowBuiltins = process.env.CC_OPENCLAW_ALLOW_BUILTINS === '1';
-            const __ccAffirmation = 'You are an AI assistant with FULL Claude Code CLI tools available natively: Bash, Read, Write, Edit, Glob, Grep, WebFetch, WebSearch, NotebookEdit, plus gh, npm, pm2, openclaw, and any MCP-bridged tools (invoke via Bash). Use tools directly via your normal tool_use mechanism.\n' +
-                'CRITICAL — anti-hallucination: NEVER claim "I have no tools", "I cannot run commands", "I do not have access to this environment", "I am operating as a pure LLM behind an API proxy", or any similar phrasing. Those statements are FALSE in this runtime. If unsure whether a tool is available, ATTEMPT it; the runtime returns a concrete error if not.\n' +
-                'When a request needs action, ACT — do not narrate what you would do. Default to executing.\n' +
-                '\n' +
-                'TURN-END INSIGHT (v0.5.2): For any turn involving reasoning, investigation, fixes, or non-trivial decisions, end your reply with a `★ Insight ─` fenced block summarizing 1–3 key takeaways the user should remember from this turn. Format EXACTLY:\n' +
-                '\n' +
-                '★ Insight ─────────────────────────────────────\n' +
-                '[1–3 short concrete takeaways, one per line, dense and specific to THIS turn — not generic advice]\n' +
-                '─────────────────────────────────────────────────\n' +
-                '\n' +
-                'Skip the block ONLY for trivial turns (greetings, single-fact answers, "/new" greetings, command echoes). When in doubt, include it. The visual fence (★ + dashes) is parsed by the channel adapter to surface the takeaway as the live-card tip — keep the inner content under ~300 chars total so it fits the tip slot. Do NOT add markdown bold/headers inside the block; plain prose wins.';
-            if (__ccAllowBuiltins) {
-                sessionConfig.systemPrompt = extracted.systemPrompt
-                    ? `${__ccAffirmation}\n\n${extracted.systemPrompt}`
-                    : __ccAffirmation;
-            }
-            else if (useToolStreamPath) {
-                if (extracted.systemPrompt) {
-                    sessionConfig.systemPrompt = extracted.systemPrompt;
-                }
-            }
-            else if (request.tools?.length) {
-                const noToolsPrompt = 'You are a helpful AI assistant acting as a pure LLM behind an API proxy.\n' +
-                    'You do NOT have access to any tools such as Bash, Read, Write, Edit, Glob, Grep, or any other built-in tools.\n' +
-                    'Do NOT attempt to call any tools or execute any commands.\n' +
-                    'When you need to perform an action, use ONLY the tools defined in <available_tools> tags in the user message, ' +
-                    'and respond with <tool_calls> tags as instructed there.\n' +
-                    'If no <available_tools> are provided, respond with text only.';
-                sessionConfig.systemPrompt = extracted.systemPrompt
-                    ? `${noToolsPrompt}\n\n${extracted.systemPrompt}`
-                    : noToolsPrompt;
-            }
-            else {
-                const pureTextPrompt = 'You are a helpful AI assistant acting as a pure LLM behind an API proxy.\n' +
-                    'You do NOT have access to any tools. Do NOT attempt to call any tools or execute any commands.\n' +
-                    'Respond with text only.';
-                sessionConfig.systemPrompt = extracted.systemPrompt
-                    ? `${pureTextPrompt}\n\n${extracted.systemPrompt}`
-                    : pureTextPrompt;
-            }
-        }
-        try {
-            await manager.startSession(sessionConfig);
-        }
-        catch (err) {
-            res.writeHead(503, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-                error: { message: `Failed to start session: ${err.message}`, type: 'server_error' },
-            }));
-            return;
-        }
-    }
-    // Auto-compact if context is getting full
-    if (sessionExists && !needsCreate) {
-        try {
-            const status = manager.getStatus(sessionName);
-            if (status.stats.contextPercent > OPENAI_COMPAT_AUTO_COMPACT_THRESHOLD) {
-                await manager.compactSession(sessionName);
-            }
-        }
-        catch {
-            /* best effort — session may not support compact */
-        }
-    }
-    // For non-claude engines (Cursor, Codex, Gemini), their CLIs don't support
-    // --append-system-prompt. Prepend the upstream system prompt to the user
-    // message on EVERY turn so the model sees the caller's identity, tool
-    // definitions, and workspace context. This is done here (not at session
-    // creation) because these engines spawn a fresh CLI process per turn —
-    // there's no persistent session to carry the system prompt forward.
-    let userMessage = extracted.userMessage;
-    if (extracted.systemPrompt && engine !== 'claude') {
-        userMessage = `<system>\n${extracted.systemPrompt}\n</system>\n\n${userMessage}`;
-    }
-    // Inject tool definitions into the user message
-    const hasTools = !!request.tools?.length;
-    if (hasTools) {
-        const toolBlock = buildToolPromptBlock(request.tools);
-        userMessage = `${toolBlock}\n\n${userMessage}`;
-    }
-    const completionId = `chatcmpl-${randomUUID().replace(/-/g, '').slice(0, 29)}`;
-    if (isStreaming) {
-        await handleStreaming(manager, sessionName, resolvedModel, userMessage, completionId, res, hasTools);
-    }
-    else {
-        await handleNonStreaming(manager, sessionName, resolvedModel, userMessage, completionId, res, hasTools);
-    }
-    // Clean up ephemeral sessions immediately after response.
-    // When X-Session-Reset is set, each request creates a fresh session that
-    // should not persist — leaving it alive leaks CLI subprocesses until TTL.
-    if (extracted.isNewConversation) {
-        manager.stopSession(sessionName).catch(() => { });
-    }
-}
-// ─── Status Reporting ───────────────────────────────────────────────────────
-// Push tool/thinking status to an external webhook so a webchat status bar
-// can show what the CLI agent is doing. Best-effort fire-and-forget.
-/**
- * Optional status webhook — set `OPENAI_COMPAT_STATUS_URL` to an HTTP endpoint
- * that accepts `POST { state, activity, tool }`. The bridge will fire-and-forget
- * status updates when the CLI agent uses tools, so an external dashboard (e.g.
- * a webchat status bar) can show real-time progress.
- *
- * Example: `OPENAI_COMPAT_STATUS_URL=http://127.0.0.1:18795/my-app/agent-status`
- */
-function reportStatus(state, activity, tool) {
-    const url = process.env.OPENAI_COMPAT_STATUS_URL;
-    if (!url)
-        return;
-    const payload = JSON.stringify({ state, activity, tool: tool || null });
-    const req = http.request(url, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) },
-        timeout: 2000,
-    }, () => { });
-    req.on('error', () => { });
-    req.write(payload);
-    req.end();
-}
-function getToolDescription(toolName, toolInput) {
-    switch (toolName) {
-        case 'Bash':
-        case 'exec': {
-            const cmd = String(toolInput?.command || '');
-            return `Running: ${cmd.length > 50 ? cmd.slice(0, 50) + '...' : cmd}`;
-        }
-        case 'Read':
-        case 'read':
-            return `Reading: ${String(toolInput?.file_path || toolInput?.path || 'file')
-                .split('/')
-                .pop()}`;
-        case 'Write':
-        case 'write':
-            return `Writing: ${String(toolInput?.file_path || toolInput?.path || 'file')
-                .split('/')
-                .pop()}`;
-        case 'Edit':
-        case 'edit':
-            return `Editing: ${String(toolInput?.file_path || toolInput?.path || 'file')
-                .split('/')
-                .pop()}`;
-        case 'Glob':
-        case 'glob':
-            return `Searching files: ${String(toolInput?.pattern || '')}`;
-        case 'Grep':
-        case 'grep':
-            return `Searching content: ${String(toolInput?.pattern || '')}`;
-        case 'WebSearch':
-            return `Web search: ${String(toolInput?.query || '')}`;
-        case 'Agent':
-            return `Spawning sub-agent...`;
-        default:
-            return `Using tool: ${toolName}`;
-    }
-}
-// ─── Non-Streaming ───────────────────────────────────────────────────────────
-async function handleNonStreaming(manager, sessionName, model, userMessage, completionId, res, hasTools) {
-    try {
-        reportStatus('thinking', 'Processing request...');
-        const result = await manager.sendMessage(sessionName, userMessage, {
-            onEvent: (event) => {
-                if (event.type === 'tool_use' && event.tool?.name) {
-                    const desc = getToolDescription(event.tool.name, event.tool.input);
-                    reportStatus('working', desc, event.tool.name);
-                }
-            },
-        });
-        reportStatus('idle', 'Ready');
-        let tokensIn = 0;
-        let tokensOut = 0;
-        try {
-            const status = manager.getStatus(sessionName);
-            tokensIn = status.stats.tokensIn;
-            tokensOut = status.stats.tokensOut;
-        }
-        catch {
-            /* stats unavailable */
-        }
-        // Parse tool_calls from response text when caller provided tools
-        if (hasTools) {
-            const parsed = parseToolCallsFromText(result.output);
-            const response = formatCompletionResponse(completionId, model, parsed.textContent ?? '', tokensIn, tokensOut, parsed.toolCalls.length > 0 ? parsed.toolCalls : undefined);
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(response));
-        }
-        else {
-            const response = formatCompletionResponse(completionId, model, result.output, tokensIn, tokensOut);
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(response));
-        }
-    }
-    catch (err) {
-        reportStatus('idle', 'Request failed');
-        res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: { message: err.message, type: 'server_error' } }));
-    }
-}
-// ─── Streaming ───────────────────────────────────────────────────────────────
-async function handleStreaming(manager, sessionName, model, userMessage, completionId, res, hasTools) {
-    res.writeHead(200, {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        Connection: 'keep-alive',
-        'X-Accel-Buffering': 'no',
-    });
-    let clientDisconnected = false;
-    res.on('close', () => {
-        clientDisconnected = true;
-    });
-    const writeSSE = (data) => {
-        if (!clientDisconnected) {
-            try {
-                res.write(`data: ${data}\n\n`);
-            }
-            catch {
-                clientDisconnected = true;
-            }
-        }
-    };
-    // Initial chunk with role
-    writeSSE(JSON.stringify(formatCompletionChunk(completionId, model, { role: 'assistant' }, null)));
-    // SSE keepalive heartbeat
-    const heartbeatTimer = setInterval(() => {
-        if (!clientDisconnected) {
-            try {
-                res.write(': keepalive\n\n');
-            }
-            catch {
-                clientDisconnected = true;
-            }
-        }
-    }, 30_000);
-    // When tools are present, buffer the full response to parse for tool_calls.
-    // Without tools, stream text chunks directly for low latency.
-    let bufferedText = '';
-    let streamedAnything = false;
-    try {
-        reportStatus('thinking', 'Processing request...');
-        const sendResult = await manager.sendMessage(sessionName, userMessage, {
-            onChunk: (chunk) => {
-                if (hasTools) {
-                    bufferedText += chunk;
-                }
-                else {
-                    streamedAnything = true;
-                    writeSSE(JSON.stringify(formatCompletionChunk(completionId, model, { content: chunk }, null)));
-                }
-            },
-            onEvent: (event) => {
-                if (event.type === 'tool_use' && event.tool?.name) {
-                    reportStatus('working', getToolDescription(event.tool.name, event.tool.input), event.tool.name);
-                }
-            },
-        });
-        // Fallback: if NOTHING reached the client (no streamed chunks AND no
-        // tools-buffered text) but sendResult has output, emit it. Catches the
-        // case where text comes only via the turn-complete event (e.g. after
-        // internal tool calls) and was never delivered via onChunk.
-        //
-        // Bug fix 2026-04-29: previously this condition was just
-        // `!bufferedText && !hasTools && sendResult.output`, which was
-        // ALWAYS true for no-tools turns (bufferedText is only populated
-        // when hasTools). Result: every no-tools turn re-emitted the full
-        // sendResult.output as a SECOND SSE chunk after the streamed chunks
-        // had already delivered the same text → doubled greeting on /new.
-        // Adding `streamedAnything` to the condition only fires the fallback
-        // when truly nothing reached the client.
-        if (!streamedAnything && !bufferedText && !hasTools && sendResult?.output) {
-            writeSSE(JSON.stringify(formatCompletionChunk(completionId, model, { content: sendResult.output }, null)));
-        }
-        reportStatus('idle', 'Ready');
-        // Get token usage for final chunk
-        let usage;
-        try {
-            const status = manager.getStatus(sessionName);
-            usage = {
-                prompt_tokens: status.stats.tokensIn,
-                completion_tokens: status.stats.tokensOut,
-                total_tokens: status.stats.tokensIn + status.stats.tokensOut,
-            };
-        }
-        catch {
-            /* best effort */
-        }
-        if (hasTools && bufferedText) {
-            const parsed = parseToolCallsFromText(bufferedText);
-            if (parsed.toolCalls.length > 0) {
-                // Emit text content if any
-                if (parsed.textContent) {
-                    writeSSE(JSON.stringify(formatCompletionChunk(completionId, model, { content: parsed.textContent }, null)));
-                }
-                // Emit tool_call chunks
-                for (let i = 0; i < parsed.toolCalls.length; i++) {
-                    const tc = parsed.toolCalls[i];
-                    writeSSE(JSON.stringify({
-                        id: completionId,
-                        object: 'chat.completion.chunk',
-                        created: Math.floor(Date.now() / 1000),
-                        model,
-                        choices: [
-                            {
-                                index: 0,
-                                delta: {
-                                    tool_calls: [
-                                        {
-                                            index: i,
-                                            id: tc.id,
-                                            type: 'function',
-                                            function: { name: tc.function.name, arguments: tc.function.arguments },
-                                        },
-                                    ],
-                                },
-                                finish_reason: null,
-                            },
-                        ],
-                    }));
-                }
-                // Final chunk with tool_calls finish reason
-                const finalChunk = formatCompletionChunk(completionId, model, {}, 'tool_calls');
-                if (usage)
-                    finalChunk.usage = usage;
-                writeSSE(JSON.stringify(finalChunk));
-            }
-            else {
-                // No tool calls — emit buffered text as content
-                writeSSE(JSON.stringify(formatCompletionChunk(completionId, model, { content: bufferedText }, null)));
-                const finalChunk = formatCompletionChunk(completionId, model, {}, 'stop');
-                if (usage)
-                    finalChunk.usage = usage;
-                writeSSE(JSON.stringify(finalChunk));
-            }
-        }
-        else {
-            // No tools — standard finish
-            const finalChunk = formatCompletionChunk(completionId, model, {}, 'stop');
-            if (usage)
-                finalChunk.usage = usage;
-            writeSSE(JSON.stringify(finalChunk));
-        }
-        writeSSE('[DONE]');
-    }
-    catch (err) {
-        reportStatus('idle', 'Request failed');
-        writeSSE(JSON.stringify({ error: { message: err.message, type: 'server_error' } }));
-        writeSSE('[DONE]');
-    }
-    finally {
-        clearInterval(heartbeatTimer);
-    }
-    if (!clientDisconnected) {
-        res.end();
-    }
-}
-//# sourceMappingURL=openai-compat.js.map