@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/conversion/config/sample-config.json

@@ -0,0 +1,314 @@
+{
+    "version": "1.0.0",
+    "description": "LLM Switch Conversion 配置文件",
+    "lastModified": "2024-11-13T00:00:00.000Z",
+    "httpserver": {
+        "port": 5520,
+        "host": "0.0.0.0",
+        "timeout": 30000,
+        "cors": {
+            "enabled": true,
+            "origin": "*",
+            "methods": ["GET", "POST", "PUT", "DELETE", "OPTIONS"]
+        }
+    },
+    "virtualrouter": {
+        "inputProtocol": "openai",
+        "outputProtocol": "openai",
+        "providers": {
+            "chat-provider-1": {
+                "id": "chat-provider-1",
+                "enabled": true,
+                "type": "openai",
+                "name": "Generic Chat Provider",
+                "description": "Example chat-completions provider",
+                "baseUrl": "https://api.example.com/chat",
+                "apiVersion": "v1",
+                "compatibility": {
+                    "type": "openai",
+                    "features": ["streaming", "function-calling"]
+                },
+                "models": {
+                    "chat-model-a": {
+                        "displayName": "Chat-Model-A",
+                        "description": "Latest chat model with improved reasoning",
+                        "supportsStreaming": true,
+                        "maxTokens": 128000,
+                        "contextWindow": 128000,
+                        "capabilities": ["text", "code", "reasoning", "tool-use"],
+                        "pricing": {
+                            "input": "0.001",
+                            "output": "0.002",
+                            "currency": "CNY"
+                        },
+                        "compatibility": {
+                            "type": "openai",
+                            "moduleConfig": {
+                                "policy": {
+                                    "preflight": true
+                                }
+                            }
+                        }
+                    },
+                    "chat-model-b": {
+                        "displayName": "Chat-Model-B",
+                        "description": "Lightweight chat model for faster responses",
+                        "supportsStreaming": true,
+                        "maxTokens": 8192,
+                        "contextWindow": 8192,
+                        "capabilities": ["text", "code", "basic-tool-use"],
+                        "pricing": {
+                            "input": "0.0005",
+                            "output": "0.001",
+                            "currency": "CNY"
+                        },
+                        "compatibility": {
+                            "type": "openai",
+                            "moduleConfig": {
+                                "policy": {
+                                    "preflight": false
+                                }
+                            }
+                        }
+                    },
+                    "chat-model-c": {
+                        "displayName": "Chat-Model-C",
+                        "description": "Ultra-fast chat model for quick responses",
+                        "supportsStreaming": false,
+                        "maxTokens": 4096,
+                        "contextWindow": 4096,
+                        "capabilities": ["text", "code"],
+                        "pricing": {
+                            "input": "0.0002",
+                            "output": "0.0004",
+                            "currency": "CNY"
+                        },
+                        "compatibility": {
+                            "type": "openai",
+                            "moduleConfig": {
+                                "policy": {
+                                    "preflight": false
+                                }
+                            }
+                        }
+                    }
+                },
+                "apiKey": [
+                    "your-api-key-here"
+                ],
+                "auth": {
+                    "type": "apikey",
+                    "apiKey": "your-api-key-here"
+                },
+                "rateLimit": {
+                    "requestsPerMinute": 60,
+                    "tokensPerMinute": 6000,
+                    "concurrent": 5
+                },
+                "healthCheck": {
+                    "enabled": true,
+                    "endpoint": "/health",
+                    "interval": 30000
+                }
+            },
+            "openai": {
+                "id": "openai",
+                "enabled": false,
+                "type": "openai",
+                "name": "OpenAI Provider",
+                "description": "Official OpenAI provider",
+                "baseUrl": "https://api.openai.com/v1",
+                "apiVersion": "v1",
+                "models": {
+                    "gpt-4": {
+                        "displayName": "GPT-4",
+                        "supportsStreaming": true,
+                        "maxTokens": 8192,
+                        "contextWindow": 8192
+                    },
+                    "gpt-4-turbo": {
+                        "displayName": "GPT-4 Turbo",
+                        "supportsStreaming": true,
+                        "maxTokens": 4096,
+                        "contextWindow": 4096
+                    },
+                    "gpt-3.5-turbo": {
+                        "displayName": "GPT-3.5 Turbo",
+                        "supportsStreaming": true,
+                        "maxTokens": 4096,
+                        "contextWindow": 16384
+                    }
+                },
+                "apiKey": [],
+                "auth": {
+                    "type": "apikey"
+                },
+                "rateLimit": {
+                    "requestsPerMinute": 3500,
+                    "tokensPerMinute": 90000,
+                    "concurrent": 100
+                }
+            },
+            "anthropic": {
+                "id": "anthropic",
+                "enabled": false,
+                "type": "anthropic",
+                "name": "Anthropic Claude Provider",
+                "description": "Anthropic Claude provider",
+                "baseUrl": "https://api.anthropic.com",
+                "apiVersion": "2023-06-01",
+                "models": {
+                    "claude-3-sonnet": {
+                        "displayName": "Claude 3 Sonnet",
+                        "supportsStreaming": true,
+                        "maxTokens": 200000,
+                        "contextWindow": 200000
+                    },
+                    "claude-3-haiku": {
+                        "displayName": "Claude 3 Haiku",
+                        "supportsStreaming": false,
+                        "maxTokens": 200000,
+                        "contextWindow": 200000
+                    }
+                },
+                "apiKey": [],
+                "auth": {
+                    "type": "apikey"
+                },
+                "rateLimit": {
+                    "requestsPerMinute": 1000,
+                    "tokensPerMinute": 40000,
+                    "concurrent": 5
+                }
+            }
+        },
+        "routing": {
+            "default": ["chat-provider-1.chat-model-a"],
+            "coding": ["chat-provider-1.chat-model-a"],
+            "longcontext": ["chat-provider-1.chat-model-a"],
+            "thinking": ["chat-provider-1.chat-model-a", "chat-model-b"],
+            "fast": ["chat-model-c"],
+            "vision": [],
+            "search": [],
+            "background": [],
+            "fallback": ["chat-provider-1.chat-model-b"]
+        },
+        "rules": {
+            "inputValidation": {
+                "enabled": true,
+                "strict": false,
+                "maxMessageLength": 100000,
+                "maxToolCount": 50
+            },
+            "outputValidation": {
+                "enabled": true,
+                "strict": false,
+                "maxResponseLength": 100000
+            },
+            "contentFiltering": {
+                "enabled": true,
+                "blockedWords": [],
+                "blockedPatterns": []
+            },
+            "rateLimiting": {
+                "enabled": true,
+                "perUser": {
+                    "requestsPerMinute": 10,
+                    "tokensPerMinute": 1000
+                },
+                "perProvider": {
+                    "chat-provider-1": { "requestsPerMinute": 60, "tokensPerMinute": 6000 },
+                    "openai": { "requestsPerMinute": 3500, "tokensPerMinute": 90000 },
+                    "anthropic": { "requestsPerMinute": 1000, "tokensPerMinute": 40000 }
+                }
+            }
+        }
+    },
+    "serverTools": {
+        "replace": {
+            "web_fetch": {
+                "enabled": true,
+                "timeout": 30000,
+                "maxResponseSize": 1000000,
+                "allowedDomains": ["*"],
+                "blockedDomains": []
+            }
+        },
+        "custom": {
+            "enabled": false,
+            "tools": []
+        },
+        "enabled": true
+    },
+    "monitoring": {
+        "enabled": true,
+        "metrics": {
+            "requestCount": true,
+            "responseTime": true,
+            "errorRate": true,
+            "tokenUsage": true,
+            "providerPerformance": true
+        },
+        "logging": {
+            "level": "info",
+            "maxFileSize": "10MB",
+            "rotate": true,
+            "keepFiles": 7
+        },
+        "alerts": {
+            "errorRateThreshold": 0.05,
+            "responseTimeThreshold": 5000,
+            "tokenUsageThreshold": 10000
+        }
+    },
+    "conversion": {
+        "defaultVersion": "v2",
+        "passthrough": {
+            "enabled": true,
+            "criteria": {
+                "sameProtocol": true,
+                "sameProvider": true,
+                "minimalProcessing": true
+            }
+        },
+        "optimization": {
+            "enabled": true,
+            "caching": {
+                "enabled": true,
+                "maxSize": "100MB",
+                "ttl": 300000
+            },
+            "batching": {
+                "enabled": true,
+                "maxBatchSize": 10,
+                "maxBatchWaitTime": 100
+            }
+        }
+    },
+    "security": {
+        "apiKeyEncryption": {
+            "enabled": true,
+            "algorithm": "AES-256-GCM"
+        },
+        "requestValidation": {
+            "enabled": true,
+            "maxRequestSize": "10MB",
+            "allowedOrigins": ["*"],
+            "rateLimit": {
+                "enabled": true,
+                "requestsPerMinute": 1000,
+                "tokensPerMinute": 50000
+            }
+        },
+        "contentFiltering": {
+            "enabled": false,
+            "blockedContent": {
+                "profanity": false,
+                "personalData": false,
+                "malware": true,
+                "spam": true
+            },
+            "customFilters": []
+        }
+    }
+}

package/vendor/llmswitch-core/dist/conversion/config/version-switch.json

@@ -0,0 +1,150 @@
+{
+    "defaultVersion": "v2",
+    "envVarName": "LLMSWITCH_CONVERTER_VERSION",
+    "allowRuntimeSwitch": true,
+    "versionPriority": {
+        "v2": 1,
+        "v3": 2,
+        "auto": 0
+    },
+    "versionSettings": {
+        "v2": {
+            "description": "Legacy conversion-core implementation",
+            "stability": "stable",
+            "features": [
+                "proven_stability",
+                "comprehensive_coverage",
+                "extensive_testing"
+            ],
+            "performance": "baseline",
+            "recommendedFor": [
+                "production",
+                "legacy_compatibility",
+                "maximum_stability"
+            ]
+        },
+        "v3": {
+            "description": "New node-based pipeline architecture",
+            "stability": "beta",
+            "features": [
+                "intelligent_passthrough",
+                "node_based_processing",
+                "automatic_optimization",
+                "zero_config"
+            ],
+            "performance": "optimized",
+            "recommendedFor": [
+                "development",
+                "performance_critical",
+                "new_features"
+            ]
+        },
+        "auto": {
+            "description": "Automatically select best version based on request",
+            "stability": "dynamic",
+            "features": [
+                "smart_selection",
+                "performance_optimization",
+                "adaptive_behavior"
+            ],
+            "performance": "variable",
+            "recommendedFor": [
+                "testing",
+                "benchmarking",
+                "a_b_testing"
+            ]
+        }
+    },
+    "switchingRules": {
+        "autoSelection": {
+            "simpleRequests": {
+                "conditions": {
+                    "messageCount": "<= 5",
+                    "toolCount": 0,
+                    "streaming": false
+                },
+                "preferredVersion": "v3",
+                "reason": "Simple requests benefit from v3 passthrough optimization"
+            },
+            "complexRequests": {
+                "conditions": {
+                    "messageCount": "> 20",
+                    "toolCount": "> 10",
+                    "hasStreaming": true
+                },
+                "preferredVersion": "v2",
+                "reason": "Complex requests benefit from v2 stability"
+            },
+            "toolHeavyRequests": {
+                "conditions": {
+                    "toolCount": "> 5",
+                    "hasComplexTools": true
+                },
+                "preferredVersion": "v3",
+                "reason": "V3 has better tool processing architecture"
+            }
+        },
+        "fallbackRules": {
+            "v3FallbackToV2": {
+                "conditions": [
+                    "conversion_error",
+                    "timeout",
+                    "unsupported_endpoint"
+                ],
+                "retryCount": 3
+            },
+            "v2FallbackToV3": {
+                "conditions": [
+                    "performance_degradation",
+                    "memory_pressure"
+                ],
+                "retryCount": 1
+            }
+        }
+    },
+    "monitoring": {
+        "enabled": true,
+        "metrics": [
+            "conversion_success_rate",
+            "average_latency",
+            "passthrough_rate",
+            "error_rate_by_version",
+            "performance_comparison"
+        ],
+        "alertThresholds": {
+            "errorRate": 0.05,
+            "latencyIncrease": 2.0,
+            "successRateDrop": 0.1
+        }
+    },
+    "hooks": {
+        "beforeSwitch": {
+            "logLevel": "info",
+            "metrics": true
+        },
+        "afterSwitch": {
+            "logLevel": "info",
+            "metrics": true,
+            "validate": true
+        },
+        "onError": {
+            "logLevel": "error",
+            "metrics": true,
+            "escalate": true
+        }
+    },
+    "testing": {
+        "enabled": false,
+        "canaryDeployment": {
+            "percentage": 0.1,
+            "version": "v3"
+        },
+        "abTesting": {
+            "enabled": false,
+            "split": {
+                "v2": 0.5,
+                "v3": 0.5
+            }
+        }
+    }
+}

package/vendor/llmswitch-core/dist/conversion/hub/config/types.d.ts

@@ -0,0 +1,26 @@
+export type MappingDirection = 'inbound' | 'outbound';
+export interface FieldMapping {
+    readonly id: string;
+    readonly target: string;
+    readonly path: string;
+    readonly description: string;
+    readonly required?: boolean;
+    readonly transformNotes?: string;
+}
+export interface FormatMappingConfig {
+    readonly description: string;
+    readonly inbound: readonly FieldMapping[];
+    readonly outbound: readonly FieldMapping[];
+}
+export interface SemanticRule {
+    readonly id: string;
+    readonly appliesTo: MappingDirection | 'both';
+    readonly description: string;
+    readonly notes?: string;
+}
+export interface ProtocolConfigDocument {
+    readonly protocol: string;
+    readonly specReference: string;
+    readonly format: FormatMappingConfig;
+    readonly semanticRules: readonly SemanticRule[];
+}

package/vendor/llmswitch-core/dist/conversion/hub/config/types.js

@@ -0,0 +1 @@
+export {};

package/vendor/llmswitch-core/dist/conversion/hub/core/detour-registry.d.ts

@@ -0,0 +1,11 @@
+import type { DetourEntry, DetourState } from '../types/chat-schema.js';
+import type { HubDirection } from './hub-context.js';
+import type { NativeReqInboundSemanticLiftApplyInput } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+export type DetourRegistryNativeEnvelope = NativeReqInboundSemanticLiftApplyInput['chatEnvelope'];
+export declare class DetourRegistry {
+    private readonly inbound;
+    private readonly outbound;
+    add(direction: HubDirection, entry: DetourEntry): void;
+    snapshot(): DetourState;
+    drain(direction: HubDirection): readonly DetourEntry[];
+}

package/vendor/llmswitch-core/dist/conversion/hub/core/detour-registry.js

@@ -0,0 +1,23 @@
+export class DetourRegistry {
+    inbound = [];
+    outbound = [];
+    add(direction, entry) {
+        if (direction === 'inbound') {
+            this.inbound.push(entry);
+            return;
+        }
+        this.outbound.push(entry);
+    }
+    snapshot() {
+        return {
+            inbound: [...this.inbound],
+            outbound: [...this.outbound]
+        };
+    }
+    drain(direction) {
+        if (direction === 'inbound') {
+            return [...this.inbound];
+        }
+        return [...this.outbound];
+    }
+}

package/vendor/llmswitch-core/dist/conversion/hub/core/hub-context.d.ts

@@ -0,0 +1,23 @@
+import type { JsonObject, JsonValue } from '../types/json.js';
+import type { NativeProviderProtocolToken } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+export type HubDirection = 'inbound' | 'outbound';
+export type HubNativeProtocolToken = NativeProviderProtocolToken;
+export interface HubContext {
+    readonly requestId: string;
+    readonly protocol: HubNativeProtocolToken;
+    readonly direction: HubDirection;
+    readonly routeId?: string;
+    readonly providerId?: string;
+    readonly profileId?: string;
+    readonly endpoint?: string;
+    readonly metadata?: JsonObject;
+}
+export interface StageSnapshot {
+    readonly stage: string;
+    readonly protocol: string;
+    readonly direction: HubDirection;
+    readonly payload: JsonValue;
+}
+export interface StageSnapshotRecorder {
+    record(snapshot: StageSnapshot): void;
+}

package/vendor/llmswitch-core/dist/conversion/hub/core/hub-context.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+export * from './hub-context.js';
+export * from './detour-registry.js';
+export * from './stage-driver.js';
+export type { NativeReqInboundSemanticLiftApplyInput as HubCoreNativeReqInboundSemanticLiftApplyInput } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';

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

@@ -0,0 +1,3 @@
+export * from './hub-context.js';
+export * from './detour-registry.js';
+export * from './stage-driver.js';

package/vendor/llmswitch-core/dist/conversion/hub/core/stage-driver.d.ts

@@ -0,0 +1,30 @@
+import { DetourRegistry } from './detour-registry.js';
+import type { HubContext, HubDirection, StageSnapshotRecorder } from './hub-context.js';
+import type { JsonValue } from '../types/json.js';
+export type HubStageKind = 'format' | 'semantic' | 'config';
+export interface HubStageRuntime {
+    readonly context: HubContext;
+    readonly detours: DetourRegistry;
+}
+export interface HubStageDefinition {
+    readonly name: string;
+    readonly kind: HubStageKind;
+    readonly direction: HubDirection;
+    readonly execute: (input: JsonValue, runtime: HubStageRuntime) => Promise<JsonValue> | JsonValue;
+}
+export interface HubPlan {
+    readonly protocol: string;
+    readonly direction: HubDirection;
+    readonly passthrough?: {
+        readonly mode: 'identity' | 'clone';
+    };
+    readonly stages: readonly HubStageDefinition[];
+}
+export interface RunHubPlanOptions {
+    readonly plan: HubPlan;
+    readonly context: HubContext;
+    readonly initialInput: JsonValue;
+    readonly recorder?: StageSnapshotRecorder;
+    readonly detours?: DetourRegistry;
+}
+export declare function runHubPlan(options: RunHubPlanOptions): Promise<JsonValue>;

package/vendor/llmswitch-core/dist/conversion/hub/core/stage-driver.js

@@ -0,0 +1,33 @@
+import { DetourRegistry } from './detour-registry.js';
+import { jsonClone } from '../types/json.js';
+import { normalizeProviderProtocolTokenWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+function recordSnapshot(recorder, stage, ctx, payload) {
+    if (!recorder)
+        return;
+    recorder.record({
+        stage,
+        protocol: ctx.protocol,
+        direction: ctx.direction,
+        payload: jsonClone(payload)
+    });
+}
+export async function runHubPlan(options) {
+    const { plan, context, initialInput, recorder } = options;
+    normalizeProviderProtocolTokenWithNative(plan.protocol || context.protocol);
+    if (!plan.stages?.length && !plan.passthrough) {
+        throw new Error(`Hub plan for ${plan.protocol} has neither stages nor passthrough`);
+    }
+    const detours = options.detours ?? new DetourRegistry();
+    if (plan.passthrough) {
+        const payload = plan.passthrough.mode === 'clone' ? jsonClone(initialInput) : initialInput;
+        recordSnapshot(recorder, 'passthrough', context, payload);
+        return payload;
+    }
+    let cursor = initialInput;
+    const runtime = { context, detours };
+    for (const stage of plan.stages) {
+        cursor = await stage.execute(cursor, runtime);
+        recordSnapshot(recorder, stage.name, context, cursor);
+    }
+    return cursor;
+}

package/vendor/llmswitch-core/dist/conversion/hub/format-adapters/anthropic-format-adapter.d.ts

@@ -0,0 +1,16 @@
+import type { FormatAdapter } from './index.js';
+import type { AdapterContext } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+import type { JsonObject, JsonValue } from '../types/json.js';
+interface AnthropicFormatPayload extends JsonObject {
+    messages?: JsonValue[];
+    tools?: JsonValue[];
+}
+export declare class AnthropicFormatAdapter implements FormatAdapter {
+    readonly protocol = "anthropic-messages";
+    parseRequest(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<AnthropicFormatPayload>>;
+    buildRequest(format: FormatEnvelope<AnthropicFormatPayload>, _ctx: AdapterContext): Promise<AnthropicFormatPayload>;
+    parseResponse(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<AnthropicFormatPayload>>;
+    buildResponse(format: FormatEnvelope<AnthropicFormatPayload>, _ctx: AdapterContext): Promise<AnthropicFormatPayload>;
+}
+export {};