@jsonstudio/llms 0.4.2

package/dist/conversion/conversion-v3/adapters/v3-to-standard-adapter.d.ts

@@ -0,0 +1,38 @@
+import type { PipelineNode as LegacyPipelineNode } from '../types/index.js';
+import type { PipelineContext, PipelineNode as StandardPipelineNode, PipelineNodeKind, NodeCapabilities, ContextAdapterOptions, NodeContextSeed, ContextMergeOptions } from '../standards/index.js';
+/**
+ * V3 Node → 标准 PipelineNode 适配器
+ *
+ * 将现有 V3 NodeContext 语义包装成标准 PipelineNode，
+ * 以便在 Phase 2 逐步替换节点实现。
+ */
+export interface V3ToStandardAdapterOptions {
+    kind?: PipelineNodeKind;
+    implementation?: string;
+    description?: string;
+    options?: Record<string, unknown>;
+    capabilities?: NodeCapabilities;
+    context?: ContextAdapterOptions & {
+        seed?: NodeContextSeed;
+    };
+    mergeOptions?: ContextMergeOptions;
+}
+export declare class V3ToStandardNodeAdapter implements StandardPipelineNode {
+    private readonly node;
+    readonly id: string;
+    readonly kind: PipelineNodeKind;
+    readonly implementation: string;
+    readonly options?: Record<string, unknown>;
+    readonly capabilities?: NodeCapabilities;
+    readonly description?: string;
+    private readonly contextOptions?;
+    private readonly mergeOptions?;
+    constructor(node: LegacyPipelineNode, adapterOptions?: V3ToStandardAdapterOptions);
+    execute(context: PipelineContext): Promise<PipelineContext>;
+    validate(config: Record<string, unknown>): Promise<boolean>;
+    cleanup(): Promise<void>;
+    /**
+     * legacy NodeType → PipelineNodeKind 映射
+     */
+    private static mapKind;
+}

package/dist/conversion/conversion-v3/adapters/v3-to-standard-adapter.js

@@ -0,0 +1,55 @@
+import { NodeType } from '../types/index.js';
+import { ContextAdapter } from '../standards/index.js';
+export class V3ToStandardNodeAdapter {
+    node;
+    id;
+    kind;
+    implementation;
+    options;
+    capabilities;
+    description;
+    contextOptions;
+    mergeOptions;
+    constructor(node, adapterOptions = {}) {
+        this.node = node;
+        this.id = node.id;
+        this.kind = adapterOptions.kind ?? V3ToStandardNodeAdapter.mapKind(node.type);
+        this.implementation = adapterOptions.implementation ?? node.constructor.name;
+        this.options = adapterOptions.options ?? node.config?.options;
+        this.capabilities = adapterOptions.capabilities;
+        this.description = adapterOptions.description ?? node.name;
+        this.contextOptions = adapterOptions.context;
+        this.mergeOptions = adapterOptions.mergeOptions;
+    }
+    async execute(context) {
+        const nodeContext = ContextAdapter.toNodeContext(context, this.contextOptions?.seed);
+        const result = await this.node.execute(nodeContext);
+        return ContextAdapter.mergeNodeResult(context, nodeContext, result, this.mergeOptions ?? { hookPhase: this.contextOptions?.hookPhase });
+    }
+    async validate(config) {
+        if (typeof this.node.validate === 'function') {
+            const legacyResult = await this.node.validate(config);
+            return legacyResult.valid;
+        }
+        return true;
+    }
+    async cleanup() {
+        if (typeof this.node.cleanup === 'function') {
+            await this.node.cleanup();
+        }
+    }
+    /**
+     * legacy NodeType → PipelineNodeKind 映射
+     */
+    static mapKind(nodeType) {
+        switch (nodeType) {
+            case NodeType.INPUT:
+                return 'input';
+            case NodeType.OUTPUT:
+                return 'output';
+            case NodeType.PROCESS:
+            default:
+                return 'process';
+        }
+    }
+}

package/dist/conversion/conversion-v3/compatibility/compatibility-profiles.d.ts

@@ -0,0 +1,22 @@
+import type { ProcessedRequest } from '../types/index.js';
+export interface CompatibilityProfile {
+    requestStages?: string[];
+    responseStages?: string[];
+    description?: string;
+}
+export declare function registerCompatibilityProfile(name: string, profile: CompatibilityProfile): void;
+export declare function registerCompatibilityProfiles(batch: Record<string, CompatibilityProfile>): void;
+export declare function getCompatibilityProfile(name: string): CompatibilityProfile | undefined;
+export declare function listCompatibilityProfiles(): Record<string, CompatibilityProfile>;
+export declare function resetCompatibilityProfiles(): void;
+export type CompatibilityStageHandler = (request: ProcessedRequest, context: CompatibilityStageContext) => Promise<ProcessedRequest> | ProcessedRequest;
+export interface CompatibilityStageContext {
+    direction: 'request' | 'response';
+    requestId?: string;
+    endpoint?: string;
+    profile?: string;
+    provider?: string;
+    providerType?: string;
+    providerProtocol?: string;
+    metadata?: Record<string, unknown>;
+}

package/dist/conversion/conversion-v3/compatibility/compatibility-profiles.js

@@ -0,0 +1,84 @@
+const profiles = new Map();
+export function registerCompatibilityProfile(name, profile) {
+    if (!name || typeof name !== 'string')
+        return;
+    const normalized = name.trim().toLowerCase();
+    if (!normalized)
+        return;
+    profiles.set(normalized, {
+        requestStages: Array.isArray(profile.requestStages)
+            ? [...profile.requestStages]
+            : undefined,
+        responseStages: Array.isArray(profile.responseStages)
+            ? [...profile.responseStages]
+            : undefined,
+        description: profile.description
+    });
+}
+export function registerCompatibilityProfiles(batch) {
+    for (const [key, value] of Object.entries(batch || {})) {
+        registerCompatibilityProfile(key, value);
+    }
+}
+export function getCompatibilityProfile(name) {
+    if (!name)
+        return undefined;
+    const normalized = name.trim().toLowerCase();
+    if (!normalized)
+        return undefined;
+    const profile = profiles.get(normalized);
+    if (!profile)
+        return undefined;
+    return {
+        requestStages: profile.requestStages ? [...profile.requestStages] : undefined,
+        responseStages: profile.responseStages ? [...profile.responseStages] : undefined,
+        description: profile.description
+    };
+}
+export function listCompatibilityProfiles() {
+    const out = {};
+    for (const [key, profile] of profiles.entries()) {
+        out[key] = {
+            requestStages: profile.requestStages ? [...profile.requestStages] : undefined,
+            responseStages: profile.responseStages ? [...profile.responseStages] : undefined,
+            description: profile.description
+        };
+    }
+    return out;
+}
+export function resetCompatibilityProfiles() {
+    profiles.clear();
+}
+// Default profiles registered on module load
+resetCompatibilityProfiles();
+registerCompatibilityProfiles({
+    default: {
+        requestStages: ['compat/common/ensure-tool-schema', 'compat/responses/request'],
+        responseStages: ['compat/common/ensure-response-tools'],
+        description: 'Baseline tool schema normalization'
+    },
+    glm: {
+        requestStages: [
+            'compat/common/ensure-tool-schema',
+            'compat/responses/request',
+            'compat/glm/request'
+        ],
+        responseStages: [
+            'compat/common/ensure-response-tools',
+            'compat/glm/response'
+        ],
+        description: 'GLM-specific compatibility adjustments'
+    },
+    lmstudio: {
+        requestStages: [
+            'compat/common/ensure-tool-schema',
+            'compat/responses/request',
+            'compat/lmstudio/request'
+        ],
+        responseStages: [
+            'compat/common/ensure-response-tools',
+            'compat/lmstudio/response'
+        ],
+        description: 'LM Studio compatibility with tool calling support'
+    }
+});

package/dist/conversion/conversion-v3/compatibility/compatibility-stages.d.ts

@@ -0,0 +1,4 @@
+import type { CompatibilityStageHandler } from './compatibility-profiles.js';
+export declare function registerCompatibilityStage(name: string, handler: CompatibilityStageHandler): void;
+export declare function getCompatibilityStage(name: string): CompatibilityStageHandler | undefined;
+export declare function listCompatibilityStages(): string[];

package/dist/conversion/conversion-v3/compatibility/compatibility-stages.js

@@ -0,0 +1,285 @@
+const stages = new Map();
+export function registerCompatibilityStage(name, handler) {
+    if (!name || typeof name !== 'string' || typeof handler !== 'function')
+        return;
+    stages.set(name.trim(), handler);
+}
+export function getCompatibilityStage(name) {
+    return stages.get(name.trim());
+}
+export function listCompatibilityStages() {
+    return Array.from(stages.keys());
+}
+function ensureToolSchema(req) {
+    if (!Array.isArray(req.tools)) {
+        return req;
+    }
+    const normalized = [];
+    for (const tool of req.tools) {
+        if (!tool || typeof tool !== 'object')
+            continue;
+        const fn = tool.function || {};
+        const name = typeof fn.name === 'string' ? fn.name.trim() : '';
+        if (!name)
+            continue;
+        const paramsSource = fn.parameters && typeof fn.parameters === 'object'
+            ? fn.parameters
+            : undefined;
+        const parameters = {
+            type: 'object',
+            properties: (paramsSource && typeof paramsSource.properties === 'object')
+                ? { ...paramsSource.properties }
+                : {},
+            required: Array.isArray(paramsSource?.required)
+                ? [...paramsSource.required]
+                : undefined,
+            additionalProperties: typeof paramsSource?.additionalProperties === 'boolean'
+                ? paramsSource.additionalProperties
+                : true
+        };
+        const description = typeof fn.description === 'string' && fn.description.trim()
+            ? fn.description.trim()
+            : `Function ${name}`;
+        normalized.push({
+            type: 'function',
+            function: {
+                name,
+                description,
+                parameters,
+                strict: fn.strict === true ? true : undefined
+            }
+        });
+    }
+    req.tools = normalized.length ? normalized : undefined;
+    if (!req.tools && req.parameters?.tool_choice) {
+        // Remove tool_choice when no tools available to avoid provider errors
+        try {
+            delete req.parameters['tool_choice'];
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return req;
+}
+function ensureResponseToolSchema(req) {
+    if (!Array.isArray(req.messages))
+        return req;
+    for (const message of req.messages) {
+        if (!message || typeof message !== 'object')
+            continue;
+        if (message.role !== 'assistant' || !Array.isArray(message.tool_calls))
+            continue;
+        message.tool_calls = message.tool_calls.map(tc => {
+            if (!tc || typeof tc !== 'object')
+                return tc;
+            const fn = tc.function || { name: '', arguments: '' };
+            const name = typeof fn.name === 'string' && fn.name.trim() ? fn.name.trim() : 'unknown';
+            let args;
+            if (typeof fn.arguments === 'string') {
+                args = fn.arguments;
+            }
+            else {
+                try {
+                    args = JSON.stringify(fn.arguments ?? {});
+                }
+                catch {
+                    args = '{}';
+                }
+            }
+            return {
+                id: typeof tc.id === 'string' && tc.id.trim() ? tc.id : `tool_${Math.random().toString(36).slice(2)}`,
+                type: 'function',
+                function: {
+                    name,
+                    arguments: args
+                }
+            };
+        });
+    }
+    return req;
+}
+function applyResponsesRequestAdjustments(req) {
+    if (!req.parameters || typeof req.parameters !== 'object')
+        return req;
+    const params = req.parameters;
+    if ('max_tokens' in params) {
+        delete params.max_tokens;
+    }
+    if ('maxTokens' in params) {
+        delete params.maxTokens;
+    }
+    return req;
+}
+function applyGLMRequestAdjustments(req) {
+    if (!Array.isArray(req.tools))
+        return req;
+    for (const tool of req.tools) {
+        if (!tool || typeof tool !== 'object')
+            continue;
+        const fn = tool.function;
+        if (fn) {
+            if (fn.strict) {
+                delete fn.strict;
+            }
+            if (fn.description && typeof fn.description === 'string') {
+                fn.description = fn.description.trim() || `Function ${fn.name}`;
+            }
+            if (fn.parameters) {
+                if (typeof fn.parameters.additionalProperties !== 'boolean') {
+                    fn.parameters.additionalProperties = true;
+                }
+            }
+            else {
+                fn.parameters = {
+                    type: 'object',
+                    properties: {},
+                    additionalProperties: true
+                };
+            }
+        }
+    }
+    return req;
+}
+function applyGLMResponseAdjustments(req) {
+    if (req.processingMetadata?.toolCalls) {
+        for (const call of req.processingMetadata.toolCalls) {
+            if (call && typeof call === 'object' && call.status === 'pending') {
+                call.status = 'success';
+            }
+        }
+    }
+    return req;
+}
+registerCompatibilityStage('compat/common/ensure-tool-schema', (req) => ensureToolSchema(req));
+registerCompatibilityStage('compat/common/ensure-response-tools', (req) => ensureResponseToolSchema(req));
+registerCompatibilityStage('compat/responses/request', (req, ctx) => {
+    if (!isResponsesContext(ctx) || ctx?.direction !== 'request')
+        return req;
+    return applyResponsesRequestAdjustments(req);
+});
+registerCompatibilityStage('compat/glm/request', (req, ctx) => {
+    if (!isGLMContext(ctx))
+        return req;
+    return applyGLMRequestAdjustments(req);
+});
+registerCompatibilityStage('compat/glm/response', (req, ctx) => {
+    if (!isGLMContext(ctx))
+        return req;
+    return applyGLMResponseAdjustments(req);
+});
+function isGLMContext(ctx) {
+    if (!ctx)
+        return false;
+    if (ctx.profile && ctx.profile.toLowerCase() === 'glm')
+        return true;
+    if (ctx.providerType && ctx.providerType.toLowerCase() === 'glm')
+        return true;
+    const provider = ctx.provider?.toLowerCase() || '';
+    if (provider.includes('glm'))
+        return true;
+    const proto = ctx.providerProtocol?.toLowerCase() || '';
+    return proto.includes('glm');
+}
+// LM Studio 兼容性处理
+function applyLMStudioRequestAdjustments(req) {
+    // LM Studio 特有的 tool_choice 规范化
+    if (req.parameters?.tool_choice && typeof req.parameters.tool_choice === 'object') {
+        const toolChoice = req.parameters.tool_choice;
+        // LM Studio 需要将 tool_choice 对象转换为字符串格式
+        if (toolChoice.type === 'function') {
+            req.parameters.tool_choice = 'required';
+        }
+    }
+    // LM Studio 字段映射
+    if (req.parameters?.max_tokens) {
+        // 有些 LM Studio 版本使用 maxToken 而不是 max_tokens
+        req.parameters.maxToken = req.parameters.max_tokens;
+    }
+    // 确保 LM Studio 支持的工具格式
+    if (Array.isArray(req.tools)) {
+        req.tools = req.tools.map(tool => {
+            if (tool.type === 'function' && tool.function) {
+                return {
+                    type: 'function',
+                    function: {
+                        name: tool.function.name,
+                        description: tool.function.description || `Function ${tool.function.name}`,
+                        parameters: tool.function.parameters || {
+                            type: 'object',
+                            properties: {},
+                            required: [],
+                            additionalProperties: true
+                        }
+                    }
+                };
+            }
+            return tool;
+        });
+    }
+    return req;
+}
+function applyLMStudioResponseAdjustments(req) {
+    // LM Studio 响应适配
+    if (req.processingMetadata?.toolCalls) {
+        req.processingMetadata.toolCalls = req.processingMetadata.toolCalls.map(call => {
+            if (call && typeof call === 'object') {
+                const toolCall = call;
+                return {
+                    ...call,
+                    type: 'function',
+                    function: {
+                        name: toolCall.function?.name || 'unknown',
+                        arguments: typeof toolCall.function?.arguments === 'string'
+                            ? toolCall.function.arguments
+                            : JSON.stringify(toolCall.function?.arguments || {})
+                    }
+                };
+            }
+            return call;
+        });
+    }
+    return req;
+}
+// 注册 LM Studio 兼容性阶段
+registerCompatibilityStage('compat/lmstudio/request', (req, ctx) => {
+    if (!isLMStudioContext(ctx))
+        return req;
+    return applyLMStudioRequestAdjustments(req);
+});
+registerCompatibilityStage('compat/lmstudio/response', (req, ctx) => {
+    if (!isLMStudioContext(ctx))
+        return req;
+    return applyLMStudioResponseAdjustments(req);
+});
+function isLMStudioContext(ctx) {
+    if (!ctx)
+        return false;
+    // 检查 profile 配置
+    if (ctx.profile && ctx.profile.toLowerCase() === 'lmstudio')
+        return true;
+    if (ctx.providerType && ctx.providerType.toLowerCase() === 'lmstudio')
+        return true;
+    // 检查 provider ID 匹配
+    const provider = ctx.provider?.toLowerCase() || '';
+    if (provider.includes('lmstudio'))
+        return true;
+    // 检查 provider 协议匹配
+    const proto = ctx.providerProtocol?.toLowerCase() || '';
+    if (proto.includes('lmstudio'))
+        return true;
+    return false;
+}
+function isResponsesContext(ctx) {
+    if (!ctx)
+        return false;
+    if (ctx.providerType && ctx.providerType.toLowerCase() === 'responses')
+        return true;
+    const provider = ctx.provider?.toLowerCase() || '';
+    if (provider.includes('responses'))
+        return true;
+    const proto = ctx.providerProtocol?.toLowerCase() || '';
+    if (proto.includes('responses'))
+        return true;
+    return false;
+}

package/dist/conversion/conversion-v3/compatibility/index.d.ts

@@ -0,0 +1,3 @@
+export { registerCompatibilityProfile, registerCompatibilityProfiles, getCompatibilityProfile, listCompatibilityProfiles, resetCompatibilityProfiles } from './compatibility-profiles.js';
+export type { CompatibilityProfile, CompatibilityStageContext, CompatibilityStageHandler } from './compatibility-profiles.js';
+export { registerCompatibilityStage, getCompatibilityStage, listCompatibilityStages } from './compatibility-stages.js';

package/dist/conversion/conversion-v3/compatibility/index.js

@@ -0,0 +1,2 @@
+export { registerCompatibilityProfile, registerCompatibilityProfiles, getCompatibilityProfile, listCompatibilityProfiles, resetCompatibilityProfiles } from './compatibility-profiles.js';
+export { registerCompatibilityStage, getCompatibilityStage, listCompatibilityStages } from './compatibility-stages.js';

package/dist/conversion/conversion-v3/config/default-configs.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 默认配置文件
+ *
+ * 提供开箱即用的默认配置，无需用户配置即可使用
+ */
+import type { NodeConfig, PipelineConfig } from '../types/index.js';
+import type { PipelineConfigDocument } from './pipeline-config-manager.js';
+/**
+ * 默认节点配置
+ */
+export declare const DEFAULT_NODE_CONFIGS: Record<string, NodeConfig>;
+/**
+ * 默认流水线配置
+ */
+export declare const DEFAULT_PIPELINE_CONFIGS: Record<string, PipelineConfig>;
+/**
+ * 端点到流水线的默认映射
+ */
+export declare const DEFAULT_ENDPOINT_MAPPINGS: Record<string, string>;
+/**
+ * JSON-schema 驱动的默认流水线配置
+ */
+export declare const DEFAULT_PIPELINE_DOCUMENT: PipelineConfigDocument;
+/**
+ * 获取默认节点配置
+ *
+ * @param nodeId 节点ID
+ * @returns 节点配置
+ */
+export declare function getDefaultNodeConfig(nodeId: string): NodeConfig | undefined;
+/**
+ * 获取默认流水线配置
+ *
+ * @param pipelineId 流水线ID
+ * @returns 流水线配置
+ */
+export declare function getDefaultPipelineConfig(pipelineId: string): PipelineConfig | undefined;
+/**
+ * 根据端点获取默认流水线配置
+ *
+ * @param endpoint 端点路径
+ * @returns 流水线配置
+ */
+export declare function getAllDefaultConfigs(): {
+    nodes: Record<string, NodeConfig>;
+    pipelines: Record<string, PipelineConfig>;
+    endpointMappings: Record<string, string>;
+};