@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/filters/types.d.ts

@@ -0,0 +1,68 @@
+export type JsonObject = Record<string, unknown>;
+export type FilterStage = 'request_pre' | 'request_map' | 'request_post' | 'request_finalize' | 'response_pre' | 'response_map' | 'response_post' | 'response_finalize';
+export interface FilterContext {
+    requestId?: string;
+    model?: string;
+    endpoint?: string;
+    provider?: string;
+    profile?: string;
+    stage: FilterStage;
+    stream?: boolean;
+    toolFilterHints?: ToolFilterHints;
+    debug?: {
+        emit?: (event: string, data: unknown) => void;
+    };
+}
+export interface FilterResult<T = JsonObject> {
+    ok: boolean;
+    data: T;
+    warnings?: string[];
+    metrics?: Record<string, unknown>;
+}
+export interface Filter<T = JsonObject> {
+    readonly name: string;
+    readonly stage: FilterStage;
+    apply(input: T, ctx: FilterContext): Promise<FilterResult<T>> | FilterResult<T>;
+}
+export type ToolFilterAction = 'allow' | 'block' | 'rewrite';
+export interface ToolFilterDecision {
+    name: string;
+    action: ToolFilterAction;
+    reason?: string;
+    category?: string;
+}
+export interface ToolFilterHints {
+    requestedDecisions?: ToolFilterDecision[];
+    categories?: {
+        vision?: boolean;
+        mcp?: boolean;
+        webSearch?: boolean;
+        codeExecution?: boolean;
+        fileSearch?: boolean;
+        dataAnalysis?: boolean;
+    };
+    categoryOverrides?: {
+        vision?: 'allow' | 'block' | 'require_content';
+        mcp?: 'allow' | 'block';
+    };
+    decided?: ToolFilterDecision[];
+}
+export interface FieldMapRule {
+    sourcePath: string;
+    targetPath: string;
+    type?: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    transform?: string;
+}
+export interface FieldMapConfig {
+    request?: FieldMapRule[];
+    response?: FieldMapRule[];
+}
+export interface WhitelistConfig {
+    allow: string[];
+}
+export interface BlacklistConfig {
+    deny: string[];
+}
+export interface AddFieldsConfig {
+    fields: Record<string, unknown>;
+}

package/vendor/llmswitch-core/dist/filters/types.js

@@ -0,0 +1,3 @@
+// Filter architecture: types and contracts (V2)
+// This module defines a minimal, composable filter pipeline for request/response shaping.
+export {};

package/vendor/llmswitch-core/dist/filters/utils/fieldmap-loader.d.ts

@@ -0,0 +1,2 @@
+import type { FieldMapConfig } from '../types.js';
+export declare function loadFieldMapConfig(relativeJsonPath: string): Promise<FieldMapConfig | null>;

package/vendor/llmswitch-core/dist/filters/utils/fieldmap-loader.js

@@ -0,0 +1,16 @@
+import * as fsp from 'node:fs/promises';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export async function loadFieldMapConfig(relativeJsonPath) {
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        const p = path.resolve(__dirname, '..', 'config', relativeJsonPath);
+        const text = await fsp.readFile(p, 'utf-8');
+        const obj = JSON.parse(text);
+        return obj;
+    }
+    catch {
+        return null;
+    }
+}

package/vendor/llmswitch-core/dist/filters/utils/snapshot-writer.d.ts

@@ -0,0 +1,10 @@
+import type { FilterStage } from '../types.js';
+export declare function writeFilterSnapshot(options: {
+    requestId?: string;
+    endpoint?: string;
+    profile?: string;
+    stage: FilterStage;
+    name?: string;
+    tag?: string;
+    data: unknown;
+}): Promise<void>;

package/vendor/llmswitch-core/dist/filters/utils/snapshot-writer.js

@@ -0,0 +1,85 @@
+import path from 'node:path';
+import * as fsp from 'node:fs/promises';
+import { resolveRccPath } from '../../runtime/user-data-paths.js';
+function mapEndpointToFolder(ep) {
+    const e = String(ep || '').trim().toLowerCase();
+    if (e.includes('/v1/responses') || e.includes('/responses.submit'))
+        return 'openai-responses';
+    if (e.includes('/v1/messages'))
+        return 'anthropic-messages';
+    return 'openai-chat';
+}
+function isSnapshotEnabled() {
+    const v = String(process?.env?.RCC_FILTER_SNAPSHOT || process?.env?.RCC_HOOKS_VERBOSITY || '').toLowerCase();
+    return v === '1' || v === 'true' || v === 'verbose';
+}
+function sanitizeToken(value, fallback) {
+    if (typeof value !== 'string') {
+        return fallback;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return fallback;
+    }
+    return trimmed.replace(/[^A-Za-z0-9_.-]/g, '_') || fallback;
+}
+function toErrorCode(error) {
+    if (!error || typeof error !== 'object') {
+        return undefined;
+    }
+    const code = error.code;
+    return typeof code === 'string' && code.trim() ? code : undefined;
+}
+async function writeUniqueFile(dir, baseName, contents) {
+    const parsed = path.parse(baseName);
+    const ext = parsed.ext || '.json';
+    const stem = parsed.name || 'snapshot';
+    for (let i = 0; i < 64; i += 1) {
+        const name = i === 0 ? `${stem}${ext}` : `${stem}_${i}${ext}`;
+        try {
+            await fsp.writeFile(path.join(dir, name), contents, { encoding: 'utf-8', flag: 'wx' });
+            return;
+        }
+        catch (error) {
+            if (toErrorCode(error) === 'EEXIST') {
+                continue;
+            }
+            throw error;
+        }
+    }
+    const fallback = `${stem}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}${ext}`;
+    await fsp.writeFile(path.join(dir, fallback), contents, 'utf-8');
+}
+export async function writeFilterSnapshot(options) {
+    try {
+        if (!isSnapshotEnabled())
+            return;
+        const rid = sanitizeToken(options.requestId || '', `req_${Date.now()}`);
+        const baseOverride = process?.env?.RCC_SNAPSHOT_DIR;
+        const base = baseOverride && baseOverride.trim()
+            ? baseOverride.trim()
+            : resolveRccPath('codex-samples');
+        const folder = mapEndpointToFolder(options.endpoint);
+        const provider = sanitizeToken(options.profile || '', '__pending__');
+        const dir = path.join(base, folder, provider, rid);
+        await fsp.mkdir(dir, { recursive: true });
+        const parts = ['filters', options.stage.replace(/\s+/g, ''), options.tag || (options.name ? `after_${options.name}` : 'after')]
+            .filter(Boolean)
+            .join('_');
+        const file = `${sanitizeToken(parts, 'filters')}.json`;
+        const payload = {
+            meta: {
+                requestId: rid,
+                stage: options.stage,
+                name: options.name,
+                tag: options.tag,
+                profile: options.profile,
+                endpoint: options.endpoint,
+                ts: new Date().toISOString()
+            },
+            data: options.data
+        };
+        await writeUniqueFile(dir, file, JSON.stringify(payload, null, 2));
+    }
+    catch { /* ignore snapshot errors */ }
+}

package/vendor/llmswitch-core/dist/guidance/index.d.ts

@@ -0,0 +1,3 @@
+export declare function augmentOpenAITools(tools: unknown[]): unknown[];
+export declare function augmentAnthropicTools(tools: unknown[]): unknown[];
+export declare function buildSystemToolGuidance(): string;

package/vendor/llmswitch-core/dist/guidance/index.js

@@ -0,0 +1,299 @@
+// Tool guidance augmentation utilities (OpenAI + Anthropic shapes)
+// Standalone module to keep guidance policy centralized and easy to evolve.
+function isObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+function ensureObjectSchema(obj) {
+    const o = (obj && typeof obj === 'object') ? obj : {};
+    if (typeof o.type !== 'string')
+        o.type = 'object';
+    if (!isObject(o.properties))
+        o.properties = {};
+    if (typeof o.additionalProperties !== 'boolean')
+        o.additionalProperties = true;
+    return o;
+}
+function appendOnce(desc, guidance, marker) {
+    const base = (typeof desc === 'string') ? desc : '';
+    if (base.includes(marker))
+        return base;
+    return base ? `${base}\n\n${guidance}` : guidance;
+}
+function buildApplyPatchGuidanceText() {
+    const marker = '[Codex ApplyPatch Guidance]';
+    const text = [
+        marker,
+        'Send ONLY patch text (do not describe tools in prose).',
+        '',
+        '✅ Supported patch text formats:',
+        '  A) Internal patch format: "*** Begin Patch" / "*** End Patch" + "*** Update/Add/Delete File"',
+        '  B) GNU unified diff: "diff --git", "---/+++", "@@" hunks, /dev/null for new files',
+        '',
+        '✅ Create vs update:',
+        '  - "*** Update File" MUST target an existing file (no implicit create).',
+        '  - To create a file, use "*** Add File:" (or GNU diff with --- /dev/null).',
+        '',
+        '✅ Common pitfalls:',
+        '  - In "*** Add File", EVERY content line must start with "+".',
+        '  - In "*** Update File" hunks, EVERY line must start with one of: " " (context), "-" (remove), "+" (add), or "@@" (hunk header).',
+        '',
+        '✅ Minimal examples (patch text):',
+        '',
+        '1) Create a new file',
+        '```patch',
+        '*** Begin Patch',
+        '*** Add File: path/to/new.txt',
+        '+Line 1',
+        '+Line 2',
+        '*** End Patch',
+        '```',
+        '',
+        '2) Replace one line in an existing file (keep surrounding context)',
+        '```patch',
+        '*** Begin Patch',
+        '*** Update File: path/to/existing.txt',
+        '@@',
+        ' Line 1',
+        '-Line 2',
+        '+Modified Line 2',
+        ' Line 3',
+        '*** End Patch',
+        '```',
+        '',
+        '3) Delete a file',
+        '```patch',
+        '*** Begin Patch',
+        '*** Delete File: path/to/obsolete.txt',
+        '*** End Patch',
+        '```',
+        '',
+        'Paths must be workspace-relative ONLY (no leading "/" or drive letters). Absolute paths will be rejected by the sandbox.'
+    ].join('\n');
+    return { marker, text };
+}
+function augmentExecCommand(fn) {
+    const marker = '[Codex ExecCommand Guidance]';
+    const guidance = [
+        marker,
+        'FORBIDDEN: Do NOT call apply_patch via exec_command/shell. Use apply_patch tool directly.',
+        'If you need to edit files, call apply_patch with patch text only.',
+        'exec_command is only for shell commands that are NOT apply_patch.',
+        '禁止通过 exec_command/shell 嵌套调用 apply_patch；修改文件必须直接调用 apply_patch 工具。'
+    ].join('\n');
+    fn.description = appendOnce(fn.description, guidance, marker);
+}
+function augmentShell(fn) {
+    const marker = '[Codex Shell Guidance]';
+    const guidance = [
+        marker,
+        'Execute shell commands. Two accepted forms:',
+        '  1) argv tokens: ["ls","-la"]',
+        '  2) bash -lc with a single string: ["bash","-lc","<single command string>"] (required for complex/multi-line/pipe/&&/||/here-doc to interpreter).',
+        'The 3rd arg of bash -lc MUST be exactly one string. Do not split meta-operators (|, >, &&, ||) into separate elements.',
+        'Do not invent extra keys. File writes are FORBIDDEN via shell (no redirection, here-doc to files, sed -i, ed -s, tee). Use apply_patch to edit files.',
+        'Examples: ["ls","-la","Obsidian"]; ["bash","-lc","cd Obsidian && ls -la"]; ["bash","-lc","python3 - <<\'PY\'\\nprint(\\"ok\\")\\nPY"]',
+        'If arguments are invalid (e.g., bash -lc without a single string), return a structured error as the tool result (role=tool, same tool_call_id) and continue the conversation.',
+        'Prefer ripgrep (rg) when available. Keep explanations in assistant text; do not mix narration into tool arguments.'
+    ].join('\n');
+    const params = ensureObjectSchema(fn.parameters);
+    const props = params.properties;
+    // 强约束：仅允许数组形态。分支A：严格 bash -lc 3 元组；分支B：纯 argv（无强校验，运行时由 governor 处理元字符）。
+    props.command = {
+        description: 'Shell command. Use argv tokens OR ["bash","-lc","<single command string>"] for complex commands.',
+        oneOf: [
+            {
+                type: 'array',
+                minItems: 3,
+                maxItems: 3,
+                items: [
+                    { const: 'bash' },
+                    { const: '-lc' },
+                    { type: 'string' }
+                ]
+            },
+            {
+                type: 'array',
+                items: { type: 'string' }
+            }
+        ]
+    };
+    params.additionalProperties = false;
+    fn.parameters = params;
+    fn.description = appendOnce(fn.description, guidance, marker);
+}
+function augmentApplyPatch(fn) {
+    const { marker, text: guidance } = buildApplyPatchGuidanceText();
+    const params = ensureObjectSchema(fn.parameters);
+    const props = params.properties;
+    props.patch = {
+        type: 'string',
+        description: 'Patch text. Supports "*** Begin Patch" format or GNU unified diff. Paths must be workspace-relative (absolute paths are rejected).'
+    };
+    props.input = {
+        type: 'string',
+        description: 'Alias of patch (patch text). Prefer using patch.'
+    };
+    params.required = Array.isArray(params.required) ? params.required : [];
+    if (!params.required.includes('patch')) {
+        params.required.push('patch');
+    }
+    params.additionalProperties = false;
+    fn.parameters = params;
+    fn.description = appendOnce(fn.description, guidance, marker);
+}
+function augmentUpdatePlan(fn) {
+    const marker = '[Codex Plan Guidance]';
+    const guidance = [
+        marker,
+        'Maintain a short stepwise plan. Exactly one step should be in_progress; others pending/completed.'
+    ].join('\n');
+    fn.description = appendOnce(fn.description, guidance, marker);
+}
+function augmentViewImage(fn) {
+    const marker = '[Codex ViewImage Guidance]';
+    const guidance = [
+        marker,
+        'Attach a local image only. Path must point to an existing image file (.png .jpg .jpeg .gif .webp .bmp .svg .tif .tiff .ico .heic .jxl).',
+        'Never use view_image to read text documents (e.g., .md/.ts/.js/.json). For text content, use shell: {"command":["cat","<path>"]}.'
+    ].join('\n');
+    const params = ensureObjectSchema(fn.parameters);
+    const props = params.properties;
+    if (!isObject(props.path)) {
+        props.path = { type: 'string', description: 'Local filesystem path to an image file' };
+    }
+    params.additionalProperties = false;
+    fn.parameters = params;
+    fn.description = appendOnce(fn.description, guidance, marker);
+}
+function augmentMCP(fn, toolName) {
+    const marker = `[Codex MCP Guidance:${toolName}]`;
+    const guidance = [
+        marker,
+        'Use MCP resources sparingly. Provide only required fields; avoid unnecessary large reads.',
+        'Do not call MCP resource tools unless you actually need MCP resources (not MCP tools).',
+        'If list_mcp_resources returns an empty list or a "Method not found" error (-32601), do not retry; assume no MCP resources are available in this session.',
+        'If you need MCP resources but do not know the MCP server label, call list_mcp_resources({}) once and reuse the returned server labels.',
+        'Note: arguments.server is an MCP server label (NOT a tool name like shell/exec_command/apply_patch).'
+    ].join('\n');
+    fn.description = appendOnce(fn.description, guidance, marker);
+}
+// For OpenAI tool shape: { type:'function', function:{ name, description?, parameters } }
+export function augmentOpenAITools(tools) {
+    if (!Array.isArray(tools))
+        return tools;
+    const out = [];
+    for (const t of tools) {
+        if (!t || typeof t !== 'object') {
+            out.push(t);
+            continue;
+        }
+        const copy = JSON.parse(JSON.stringify(t));
+        const fn = isObject(copy.function) ? copy.function : null;
+        const name = fn && typeof fn.name === 'string' ? String(fn.name) : undefined;
+        if (fn && name) {
+            const n = name.trim();
+            try {
+                if (n === 'shell')
+                    augmentShell(fn);
+                else if (n === 'exec_command')
+                    augmentExecCommand(fn);
+                else if (n === 'apply_patch') {
+                    const { marker, text } = buildApplyPatchGuidanceText();
+                    fn.description = appendOnce(fn.description, text, marker);
+                    augmentApplyPatch(fn);
+                }
+                else if (n === 'update_plan')
+                    augmentUpdatePlan(fn);
+                else if (n === 'view_image')
+                    augmentViewImage(fn);
+                else if (n === 'list_mcp_resources' || n === 'read_mcp_resource' || n === 'list_mcp_resource_templates')
+                    augmentMCP(fn, n);
+            }
+            catch { /* ignore */ }
+        }
+        out.push(copy);
+    }
+    return out;
+}
+// For Anthropic tool shape: { name, description?, input_schema }
+export function augmentAnthropicTools(tools) {
+    if (!Array.isArray(tools))
+        return tools;
+    const out = [];
+    for (const t of tools) {
+        if (!t || typeof t !== 'object') {
+            out.push(t);
+            continue;
+        }
+        const copy = JSON.parse(JSON.stringify(t));
+        const name = typeof copy.name === 'string' ? String(copy.name) : undefined;
+        const desc = typeof copy.description === 'string' ? String(copy.description) : undefined;
+        const schema = ensureObjectSchema(copy.input_schema);
+        if (name) {
+            const n = name.trim();
+            try {
+                if (n === 'exec_command') {
+                    augmentExecCommand(copy);
+                }
+                if (n === 'apply_patch') {
+                    schema.properties.patch = {
+                        type: 'string',
+                        description: 'Patch text (*** Begin Patch / *** End Patch or GNU unified diff).'
+                    };
+                    schema.properties.input = {
+                        type: 'string',
+                        description: 'Alias of patch (patch text). Prefer patch.'
+                    };
+                    if (!Array.isArray(schema.required))
+                        schema.required = [];
+                    if (!schema.required.includes('patch'))
+                        schema.required.push('patch');
+                    schema.additionalProperties = false;
+                    copy.input_schema = schema;
+                    const marker = '[Codex ApplyPatch Guidance]';
+                    const guidance = buildApplyPatchGuidanceText().text;
+                    copy.description = appendOnce(desc, guidance, marker);
+                }
+                if (n === 'shell') {
+                    const marker = '[Codex Shell Guidance]';
+                    const guidance = [marker, 'Execute commands via argv tokens only (no redirection).'].join('\n');
+                    copy.description = appendOnce(desc, guidance, marker);
+                }
+                if (n === 'update_plan') {
+                    const marker = '[Codex Plan Guidance]';
+                    const guidance = [marker, 'Maintain a short plan; one in_progress step only.'].join('\n');
+                    copy.description = appendOnce(desc, guidance, marker);
+                }
+                if (n === 'view_image' || n === 'list_mcp_resources' || n === 'read_mcp_resource' || n === 'list_mcp_resource_templates') {
+                    const marker = `[Codex MCP Guidance:${n}]`;
+                    const guidance = [marker, 'Use minimally; avoid unnecessary large reads.'].join('\n');
+                    copy.description = appendOnce(desc, guidance, marker);
+                }
+            }
+            catch { /* ignore */ }
+        }
+        out.push(copy);
+    }
+    return out;
+}
+// Build a minimal, consistent system tool guidance string (OpenAI tool_calls model)
+export function buildSystemToolGuidance() {
+    const bullet = (s) => `- ${s}`;
+    const lines = [];
+    lines.push('Tool usage guidance (OpenAI tool_calls) / 工具使用指引（OpenAI 标准）');
+    lines.push(bullet('Always use assistant.tool_calls[].function.{name,arguments}; never embed tool calls in plain text. / 一律通过 tool_calls 调用工具，不要把工具调用写进普通文本。'));
+    lines.push(bullet('function.arguments must be a single JSON string. / arguments 必须是单个 JSON 字符串。'));
+    lines.push(bullet('shell: Place ALL intent into the command argv array only; do not invent extra keys. / shell 所有意图写入 command 数组，不要添加额外键名。'));
+    lines.push(bullet('File writes are FORBIDDEN via shell (no redirection, no here-doc, no sed -i, no ed -s, no tee). Use apply_patch ONLY. / 通过 shell 写文件一律禁止（不得使用重定向、heredoc、sed -i、ed -s、tee）；必须使用 apply_patch。'));
+    lines.push(bullet('NEVER wrap apply_patch inside exec_command/shell. Direct apply_patch tool call only. / 严禁在 exec_command/shell 中嵌套 apply_patch，必须直接调用 apply_patch。'));
+    lines.push(bullet('apply_patch: Before writing, always read the target file first and compute changes against the latest content using appropriate tools. / apply_patch 在写入前必须先通过合适的工具读取目标文件最新内容，并基于该内容生成变更。'));
+    lines.push(bullet('apply_patch: Send patch text only. Supported formats: "*** Begin Patch" OR GNU unified diff. "*** Update File" never implicitly creates files—use "*** Add File:" (or /dev/null diff). / apply_patch：仅发送补丁文本，支持 "*** Begin Patch" 或 GNU diff；"*** Update File" 不会隐式创建文件。'));
+    lines.push(bullet('apply_patch: For a given file, prefer one contiguous change block per call; if you need to touch non-adjacent regions, split them into multiple apply_patch calls. / apply_patch 修改同一文件时尽量只提交一段连续补丁，多个不相邻位置请拆成多次调用。'));
+    lines.push(bullet('update_plan: Keep exactly one step in_progress; others pending/completed. / 仅一个 in_progress 步骤。'));
+    lines.push(bullet('view_image: Path must be an image file (.png .jpg .jpeg .gif .webp .bmp .svg). / 仅图片路径。'));
+    lines.push(bullet('Do NOT use view_image for text files (.md/.ts/.js/.json). Use shell: {"command":["cat","<path>"]}. / 文本文件请用 shell: cat。'));
+    // Preamble alignment with harness: keep a single concise preamble, but no tool-call meta narration.
+    lines.push(bullet('Preamble: Before making tool calls, send ONE brief sentence about immediate next steps (skip for trivial reads); then emit tool_calls. Do not narrate tool-call meta (e.g., “工具调用已生成”). / 预叙：调用工具前可发送一句简短计划（琐碎读取可省略），随后直接生成 tool_calls；不要叙述“已生成工具调用”等元信息。'));
+    return lines.join('\n');
+}
+// 注意：我们不再提供"精炼/替换"已有 system 提示词的能力。

package/vendor/llmswitch-core/dist/http/sse-response.d.ts

@@ -0,0 +1,22 @@
+import type { ServerResponse } from 'node:http';
+import type { Readable } from 'node:stream';
+type AnyObj = Record<string, unknown>;
+/**
+ * Pipe an SSE Readable to Node http.ServerResponse
+ */
+export declare function sendNodeSSE(res: ServerResponse, stream: Readable): void;
+/**
+ * Express response variant (duck-typed): res.set, res.write, res.end
+ */
+export declare function sendExpressSSE(res: AnyObj, stream: Readable): void;
+/**
+ * Fastify reply variant: reply.raw is ServerResponse
+ */
+export declare function sendFastifySSE(reply: AnyObj, stream: Readable): void;
+/**
+ * If the given payload contains __sse_responses or sseStream, stream it via the provided response object.
+ * Otherwise, send JSON.
+ * - Supported responders: Node ServerResponse, Express res, Fastify reply
+ */
+export declare function sendSSEOrJSON(resOrReply: AnyObj, payload: AnyObj): any;
+export {};

package/vendor/llmswitch-core/dist/http/sse-response.js

@@ -0,0 +1,103 @@
+function isReadable(v) {
+    return !!v && typeof v.pipe === 'function';
+}
+function setSSEHeadersRaw(res) {
+    res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
+    res.setHeader('Cache-Control', 'no-cache, no-transform');
+    res.setHeader('Connection', 'keep-alive');
+}
+/**
+ * Pipe an SSE Readable to Node http.ServerResponse
+ */
+export function sendNodeSSE(res, stream) {
+    setSSEHeadersRaw(res);
+    // Write initial comment to establish stream in some proxies
+    try {
+        res.write(': ok\n\n');
+    }
+    catch { /* ignore */ }
+    stream.on('data', (chunk) => {
+        res.write(typeof chunk === 'string' ? chunk : chunk.toString());
+    });
+    stream.on('end', () => {
+        try {
+            res.write(':\n\n');
+        }
+        catch { /* ignore */ }
+        res.end();
+    });
+    stream.on('error', (err) => {
+        try {
+            res.write(`event: error\n`);
+            res.write(`data: ${JSON.stringify({ message: String(err?.message || 'sse_error') })}\n\n`);
+        }
+        catch { /* ignore */ }
+        res.end();
+    });
+}
+/**
+ * Express response variant (duck-typed): res.set, res.write, res.end
+ */
+export function sendExpressSSE(res, stream) {
+    if (typeof res.set === 'function') {
+        res.set('Content-Type', 'text/event-stream; charset=utf-8');
+        res.set('Cache-Control', 'no-cache, no-transform');
+        res.set('Connection', 'keep-alive');
+    }
+    else if (typeof res.setHeader === 'function') {
+        setSSEHeadersRaw(res);
+    }
+    try {
+        res.write(': ok\n\n');
+    }
+    catch { /* ignore */ }
+    stream.on('data', (chunk) => res.write(typeof chunk === 'string' ? chunk : chunk.toString()));
+    stream.on('end', () => res.end());
+    stream.on('error', (err) => {
+        try {
+            res.write(`event: error\n`);
+            res.write(`data: ${JSON.stringify({ message: String(err?.message || 'sse_error') })}\n\n`);
+        }
+        catch { /* ignore */ }
+        res.end();
+    });
+}
+/**
+ * Fastify reply variant: reply.raw is ServerResponse
+ */
+export function sendFastifySSE(reply, stream) {
+    const raw = (reply && reply.raw);
+    if (raw)
+        return sendNodeSSE(raw, stream);
+    // fallback to express-like
+    return sendExpressSSE(reply, stream);
+}
+/**
+ * If the given payload contains __sse_responses or sseStream, stream it via the provided response object.
+ * Otherwise, send JSON.
+ * - Supported responders: Node ServerResponse, Express res, Fastify reply
+ */
+export function sendSSEOrJSON(resOrReply, payload) {
+    const stream = payload.__sse_responses || payload.sseStream;
+    if (isReadable(stream)) {
+        // detect responder flavor
+        if (typeof resOrReply.raw !== 'undefined')
+            return sendFastifySSE(resOrReply, stream);
+        if (typeof resOrReply.setHeader === 'function')
+            return sendNodeSSE(resOrReply, stream);
+        return sendExpressSSE(resOrReply, stream);
+    }
+    // Fallback JSON
+    const jsonTxt = JSON.stringify(payload);
+    if (typeof resOrReply.json === 'function')
+        return resOrReply.json(payload);
+    if (typeof resOrReply.send === 'function')
+        return resOrReply.send(jsonTxt);
+    if (typeof resOrReply.end === 'function') {
+        try {
+            resOrReply.setHeader?.('Content-Type', 'application/json; charset=utf-8');
+        }
+        catch { /* ignore */ }
+        return resOrReply.end(jsonTxt);
+    }
+}

package/vendor/llmswitch-core/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * RouteCodex hub entry exports.
+ *
+ * Expose hub pipeline + conversion helpers + router bootstrap so consumers no longer
+ * have to depend on the removed LLMSwitch V2 engine.
+ */
+export * from './conversion/index.js';
+export * from './router/virtual-router/bootstrap.js';
+export * from './router/virtual-router/types.js';
+export * from './telemetry/stats-center.js';
+export declare const VERSION = "0.4.0";

package/vendor/llmswitch-core/dist/index.js

@@ -0,0 +1,11 @@
+/**
+ * RouteCodex hub entry exports.
+ *
+ * Expose hub pipeline + conversion helpers + router bootstrap so consumers no longer
+ * have to depend on the removed LLMSwitch V2 engine.
+ */
+export * from './conversion/index.js';
+export * from './router/virtual-router/bootstrap.js';
+export * from './router/virtual-router/types.js';
+export * from './telemetry/stats-center.js';
+export const VERSION = '0.4.0';

package/vendor/llmswitch-core/dist/quota/apikey-reset.d.ts

@@ -0,0 +1,17 @@
+export type DailyResetParseResult = {
+    ok: true;
+    kind: 'local' | 'utc';
+    hour: number;
+    minute: number;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function parseDailyResetTime(input: string | null | undefined): DailyResetParseResult;
+export declare function computeNextDailyResetAtMs(args: {
+    nowMs: number;
+    resetTime?: string | null;
+}): {
+    resetAtMs: number;
+    resetTimeNormalized: string;
+};