langflower 0.1.0 → 0.1.2

package/vendor/server/dist/llm/create-embedding.js

@@ -1,51 +0,0 @@
-import OpenAI from 'openai';
-import { resolveProviderCredentials } from '../config/resolve-provider-credentials.js';
-const requireNonEmpty = (value, label) => {
-    const trimmed = value.trim();
-    if (trimmed.length === 0) {
-        throw new Error(`${label} is required for embeddings`);
-    }
-    return trimmed;
-};
-/**
- * Binds OpenAI-compatible embeddings from `langflower.jsonc` `embedding`.
- * Caller should only inject when `config.embedding` is present; otherwise KB
- * nodes use local hashing.
- */
-export const bindCreateEmbedding = (langflowerConfigService) => {
-    return async (texts) => {
-        const config = await langflowerConfigService.read();
-        const embedding = config.embedding;
-        if (embedding === undefined) {
-            throw new Error('embedding block is not configured in langflower.jsonc');
-        }
-        const providerId = requireNonEmpty(embedding.providerId, 'embedding.providerId');
-        const model = requireNonEmpty(embedding.model, 'embedding.model');
-        const credentials = resolveProviderCredentials(config, providerId);
-        const client = new OpenAI({
-            apiKey: credentials.apiKey ?? 'local-no-key',
-            ...(credentials.baseURL !== undefined
-                ? { baseURL: credentials.baseURL }
-                : {}),
-        });
-        if (texts.length === 0) {
-            return [];
-        }
-        const response = await client.embeddings.create({
-            model,
-            input: [...texts],
-            ...(embedding.dimensions !== undefined
-                ? { dimensions: embedding.dimensions }
-                : {}),
-        });
-        const byIndex = new Map(response.data.map((row) => [row.index, row.embedding]));
-        return texts.map((_, index) => {
-            const values = byIndex.get(index);
-            if (values === undefined) {
-                throw new Error(`embedding response missing index ${index}`);
-            }
-            return Float32Array.from(values);
-        });
-    };
-};
-//# sourceMappingURL=create-embedding.js.map

package/vendor/server/dist/llm/list-provider-models.d.ts

@@ -1,29 +0,0 @@
-import type { LangflowerConfig, ProviderModelEntry } from '@langflower/shared/langflower.js';
-import type { LangflowerConfigService } from '../config/langflower-config.service.js';
-import { type ResolvedProviderCredentials } from '../config/resolve-provider-credentials.js';
-export type ListProviderModelsResult = {
-    readonly models: readonly ProviderModelEntry[];
-    readonly error?: string;
-};
-type OpenAiModelsClient = {
-    readonly models: {
-        readonly list: () => Promise<{
-            readonly data: readonly {
-                readonly id: string;
-                readonly name?: string;
-            }[];
-        }>;
-    };
-};
-type ListProviderModelsDeps = {
-    readonly readConfig?: () => Promise<LangflowerConfig>;
-    readonly createClient?: (credentials: ResolvedProviderCredentials) => OpenAiModelsClient;
-};
-/**
- * Lists models for one provider using the same credential resolve + OpenAI client
- * as chat streaming. Never throws — failures return `{ models: [], error }`.
- */
-export declare const listProviderModelsFromConfig: (config: LangflowerConfig, providerId: string, deps?: ListProviderModelsDeps) => Promise<ListProviderModelsResult>;
-export declare const listProviderModels: (langflowerConfigService: LangflowerConfigService, providerId: string, deps?: ListProviderModelsDeps) => Promise<ListProviderModelsResult>;
-export {};
-//# sourceMappingURL=list-provider-models.d.ts.map

package/vendor/server/dist/llm/list-provider-models.js

@@ -1,55 +0,0 @@
-import OpenAI from 'openai';
-import { resolveProviderCredentials, } from '../config/resolve-provider-credentials.js';
-const SECRET_SUBSTRINGS = ['sk-', 'apiKey', 'api_key', 'authorization'];
-const toSafeErrorMessage = (message) => {
-    const lower = message.toLowerCase();
-    for (const needle of SECRET_SUBSTRINGS) {
-        if (lower.includes(needle.toLowerCase())) {
-            return 'Failed to list models for provider';
-        }
-    }
-    return message;
-};
-const mapModelEntry = (entry) => {
-    const name = 'name' in entry && typeof entry.name === 'string'
-        ? entry.name
-        : undefined;
-    return {
-        id: entry.id,
-        ...(name !== undefined ? { name } : {}),
-    };
-};
-const defaultCreateClient = (credentials) => new OpenAI({
-    apiKey: credentials.apiKey ?? 'local-no-key',
-    ...(credentials.baseURL !== undefined
-        ? { baseURL: credentials.baseURL }
-        : {}),
-});
-/**
- * Lists models for one provider using the same credential resolve + OpenAI client
- * as chat streaming. Never throws — failures return `{ models: [], error }`.
- */
-export const listProviderModelsFromConfig = async (config, providerId, deps) => {
-    try {
-        const credentials = resolveProviderCredentials(config, providerId);
-        const createClient = deps?.createClient ?? defaultCreateClient;
-        const client = createClient(credentials);
-        const page = await client.models.list();
-        return {
-            models: (page.data ?? []).map(mapModelEntry),
-        };
-    }
-    catch (error) {
-        const raw = error instanceof Error ? error.message : String(error);
-        return {
-            models: [],
-            error: toSafeErrorMessage(raw),
-        };
-    }
-};
-export const listProviderModels = async (langflowerConfigService, providerId, deps) => {
-    const readConfig = deps?.readConfig ?? (() => langflowerConfigService.read());
-    const config = await readConfig();
-    return listProviderModelsFromConfig(config, providerId, deps);
-};
-//# sourceMappingURL=list-provider-models.js.map

package/vendor/server/dist/llm/list-provider-models.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=list-provider-models.test.d.ts.map

package/vendor/server/dist/llm/list-provider-models.test.js

@@ -1,97 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { listProviderModels, listProviderModelsFromConfig, } from './list-provider-models.js';
-const mockConfigService = (config) => ({
-    read: async () => config,
-});
-describe('listProviderModelsFromConfig', () => {
-    it('returns ids from mocked models.list()', async () => {
-        const list = vi.fn(async () => ({
-            data: [{ id: 'gpt-4o' }, { id: 'gpt-4o-mini', name: 'Mini' }],
-        }));
-        const result = await listProviderModelsFromConfig({
-            provider: {
-                openai: {
-                    name: 'OpenAI',
-                    options: { apiKey: 'test-key-for-mock' },
-                },
-            },
-        }, 'openai', {
-            createClient: () => ({ models: { list } }),
-        });
-        expect(list).toHaveBeenCalledOnce();
-        expect(result).toEqual({
-            models: [
-                { id: 'gpt-4o' },
-                { id: 'gpt-4o-mini', name: 'Mini' },
-            ],
-        });
-    });
-    it('returns safe error when provider is misconfigured', async () => {
-        const result = await listProviderModelsFromConfig({}, 'missing');
-        expect(result.models).toEqual([]);
-        expect(result.error).toContain('Provider "missing" is not configured');
-        expect(result.error).not.toContain('sk-');
-    });
-    it('does not leak apiKey when env var is missing', async () => {
-        const prior = process.env.MISSING_LF_MODELS_KEY;
-        delete process.env.MISSING_LF_MODELS_KEY;
-        try {
-            const result = await listProviderModelsFromConfig({
-                provider: {
-                    openai: {
-                        name: 'OpenAI',
-                        options: {
-                            apiKey: '{env:MISSING_LF_MODELS_KEY}',
-                        },
-                    },
-                },
-            }, 'openai');
-            expect(result.models).toEqual([]);
-            expect(result.error).toMatch(/Environment variable MISSING_LF_MODELS_KEY is not set/);
-            expect(result.error).not.toContain('sk-');
-        }
-        finally {
-            if (prior !== undefined) {
-                process.env.MISSING_LF_MODELS_KEY = prior;
-            }
-        }
-    });
-    it('sanitizes errors that may contain secret substrings', async () => {
-        const result = await listProviderModelsFromConfig({
-            provider: {
-                openai: {
-                    name: 'OpenAI',
-                    options: { apiKey: 'sk-leaked-in-config' },
-                },
-            },
-        }, 'openai', {
-            createClient: () => ({
-                models: {
-                    list: async () => {
-                        throw new Error('401 Invalid apiKey sk-leaked-in-config');
-                    },
-                },
-            }),
-        });
-        expect(result.models).toEqual([]);
-        expect(result.error).toBe('Failed to list models for provider');
-        expect(result.error).not.toContain('sk-leaked');
-    });
-});
-describe('listProviderModels', () => {
-    it('reads config from LangflowerConfigService', async () => {
-        const list = vi.fn(async () => ({ data: [{ id: 'local-model' }] }));
-        const result = await listProviderModels(mockConfigService({
-            provider: {
-                lmstudio: {
-                    name: 'LM Studio',
-                    options: { baseURL: 'http://127.0.0.1:1234/v1' },
-                },
-            },
-        }), 'lmstudio', {
-            createClient: () => ({ models: { list } }),
-        });
-        expect(result.models).toEqual([{ id: 'local-model' }]);
-    });
-});
-//# sourceMappingURL=list-provider-models.test.js.map

package/vendor/server/dist/mcp/create-mcp-runtime.d.ts

@@ -1,21 +0,0 @@
-import type { BuiltinToolRegistration, ToolInvokeCall, ToolInvokeResult } from '@langflower/node-definitions';
-import type { LangflowerMcpConfig, LangflowerPermissionConfig } from '@langflower/shared/langflower.js';
-import { type PermissionAskRequest, type PermissionDecision } from '@langflower/tools/permission';
-export type McpRuntime = {
-    readonly listRegistrations: (serverIds: readonly string[]) => readonly BuiltinToolRegistration[];
-    readonly invoke: (call: ToolInvokeCall) => Promise<ToolInvokeResult>;
-    readonly close: () => Promise<void>;
-};
-/**
- * Connect allowlisted MCP servers from project config.
- * Trust model: missing/empty `allowlist` → no spawn; unknown ids skipped.
- */
-export declare const createMcpRuntime: (options: {
-    readonly projectRoot: string;
-    readonly mcp?: LangflowerMcpConfig;
-    readonly permission?: LangflowerPermissionConfig;
-    readonly requestPermission?: (request: PermissionAskRequest) => Promise<PermissionDecision>;
-}) => Promise<McpRuntime>;
-/** Empty runtime when MCP is unset / allowlist empty. */
-export declare const emptyMcpRuntime: () => McpRuntime;
-//# sourceMappingURL=create-mcp-runtime.d.ts.map

package/vendor/server/dist/mcp/create-mcp-runtime.js

@@ -1,167 +0,0 @@
-import path from 'node:path';
-import { DEFAULT_PERMISSION_CONFIG, grantKeyForCall, permissionAskSummary, resolvePermission, } from '@langflower/tools/permission';
-import { connectMcpStdioClient, } from './mcp-stdio-client.js';
-import { encodeMcpToolId, isValidMcpServerId, parseMcpToolId, } from './mcp-tool-id.js';
-const resolveEnvPlaceholders = (env) => {
-    if (env === undefined) {
-        return undefined;
-    }
-    const resolved = {};
-    for (const [key, value] of Object.entries(env)) {
-        const match = /^\{env:([A-Za-z_][A-Za-z0-9_]*)\}$/.exec(value);
-        resolved[key] =
-            match !== null ? (process.env[match[1] ?? ''] ?? '') : value;
-    }
-    return resolved;
-};
-const deniedResult = (toolId, detail) => ({
-    ok: false,
-    text: `Permission denied for ${toolId}${detail.length > 0 ? ` (${detail})` : ''}.`,
-});
-/**
- * Connect allowlisted MCP servers from project config.
- * Trust model: missing/empty `allowlist` → no spawn; unknown ids skipped.
- */
-export const createMcpRuntime = async (options) => {
-    const allowlist = options.mcp?.allowlist ?? [];
-    const servers = options.mcp?.servers ?? {};
-    const permission = {
-        ...DEFAULT_PERMISSION_CONFIG,
-        ...(options.permission ?? {}),
-    };
-    const grants = new Set();
-    const allowedIds = allowlist
-        .map((id) => id.trim())
-        .filter((id) => id.length > 0 && isValidMcpServerId(id))
-        .filter((id) => servers[id] !== undefined);
-    const connected = [];
-    for (const serverId of allowedIds) {
-        const config = servers[serverId];
-        if (config === undefined) {
-            continue;
-        }
-        const cwd = config.cwd !== undefined && config.cwd.trim().length > 0
-            ? path.resolve(options.projectRoot, config.cwd)
-            : options.projectRoot;
-        try {
-            const resolvedEnv = resolveEnvPlaceholders(config.env);
-            const client = await connectMcpStdioClient({
-                command: config.command,
-                cwd,
-                ...(config.args !== undefined ? { args: config.args } : {}),
-                ...(resolvedEnv !== undefined ? { env: resolvedEnv } : {}),
-            });
-            const listed = await client.listTools();
-            const toolNameById = new Map();
-            const registrations = listed.flatMap((tool) => {
-                const toolId = encodeMcpToolId(serverId, tool.name);
-                if (toolId.length === 0) {
-                    return [];
-                }
-                toolNameById.set(toolId, tool.name);
-                return [
-                    {
-                        toolId,
-                        name: toolId,
-                        description: (tool.description ?? '').trim().length > 0
-                            ? `${tool.description} (MCP:${serverId})`
-                            : `MCP tool «${tool.name}» from server «${serverId}»`,
-                        inputSchema: tool.inputSchema !== undefined &&
-                            typeof tool.inputSchema === 'object'
-                            ? tool.inputSchema
-                            : { type: 'object', properties: {} },
-                    },
-                ];
-            });
-            connected.push({
-                serverId,
-                client,
-                registrations,
-                toolNameById,
-            });
-        }
-        catch {
-            /* Fail closed per server — do not abort the run for one bad MCP. */
-        }
-    }
-    const byServerId = new Map(connected.map((entry) => [entry.serverId, entry]));
-    const gate = async (toolId) => {
-        const detail = 'mcp';
-        const key = grantKeyForCall(toolId, detail);
-        if (grants.has(key)) {
-            return 'allow';
-        }
-        // MCP tools are absent from builtin defaults → ask unless configured.
-        const decision = options.permission?.[toolId] !== undefined
-            ? resolvePermission(permission, toolId, detail)
-            : 'ask';
-        if (decision === 'allow') {
-            return 'allow';
-        }
-        if (decision === 'deny') {
-            return 'deny';
-        }
-        if (options.requestPermission === undefined) {
-            return 'deny';
-        }
-        const reply = await options.requestPermission({
-            toolId,
-            detail,
-            summary: permissionAskSummary(toolId, detail),
-        });
-        if (reply === 'allow') {
-            grants.add(key);
-            return 'allow';
-        }
-        return 'deny';
-    };
-    return {
-        listRegistrations: (serverIds) => {
-            const wanted = new Set(serverIds.map((id) => id.trim()).filter((id) => id.length > 0));
-            return connected.flatMap((entry) => wanted.has(entry.serverId) ? entry.registrations : []);
-        },
-        invoke: async (call) => {
-            const parsed = parseMcpToolId(call.toolId);
-            if (parsed === null) {
-                return {
-                    ok: false,
-                    text: `Not an MCP tool id: «${call.toolId}».`,
-                };
-            }
-            const server = byServerId.get(parsed.serverId);
-            if (server === undefined) {
-                return {
-                    ok: false,
-                    text: `MCP server «${parsed.serverId}» is not connected (check mcp.allowlist).`,
-                };
-            }
-            const remoteName = server.toolNameById.get(call.toolId);
-            if (remoteName === undefined) {
-                return {
-                    ok: false,
-                    text: `Unknown MCP tool «${call.toolId}» on server «${parsed.serverId}».`,
-                };
-            }
-            const access = await gate(call.toolId);
-            if (access === 'deny') {
-                return deniedResult(call.toolId, 'mcp');
-            }
-            return server.client.callTool(remoteName, call.args);
-        },
-        close: async () => {
-            await Promise.all(connected.map((entry) => entry.client.close()));
-            connected.length = 0;
-            byServerId.clear();
-        },
-    };
-};
-/** Empty runtime when MCP is unset / allowlist empty. */
-export const emptyMcpRuntime = () => ({
-    listRegistrations: () => [],
-    invoke: async (call) => ({
-        ok: false,
-        text: `MCP is not configured; cannot invoke «${call.toolId}».`,
-    }),
-    close: async () => undefined,
-});
-//# sourceMappingURL=create-mcp-runtime.js.map

package/vendor/server/dist/mcp/create-mcp-runtime.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=create-mcp-runtime.test.d.ts.map

package/vendor/server/dist/mcp/create-mcp-runtime.test.js

@@ -1,69 +0,0 @@
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { createMcpRuntime } from './create-mcp-runtime.js';
-import { encodeMcpToolId } from './mcp-tool-id.js';
-const echoServerPath = path.resolve(fileURLToPath(new URL('.', import.meta.url)), '../../../../tests/fixtures/mcp/echo-server.mjs');
-describe('createMcpRuntime', () => {
-    let projectDir;
-    beforeEach(async () => {
-        projectDir = await fs.mkdtemp(path.join(os.tmpdir(), 'lf-mcp-'));
-    });
-    afterEach(async () => {
-        await fs.rm(projectDir, { recursive: true, force: true });
-    });
-    it('connects allowlisted fixture and invokes echo via mapped tool id', async () => {
-        const toolId = encodeMcpToolId('echo', 'echo');
-        const runtime = await createMcpRuntime({
-            projectRoot: projectDir,
-            mcp: {
-                allowlist: ['echo'],
-                servers: {
-                    echo: {
-                        command: process.execPath,
-                        args: [echoServerPath],
-                    },
-                },
-            },
-            permission: {
-                [toolId]: { '*': 'allow' },
-            },
-        });
-        try {
-            const registrations = runtime.listRegistrations(['echo']);
-            expect(registrations.map((row) => row.toolId)).toContain(toolId);
-            const result = await runtime.invoke({
-                toolId,
-                args: { message: 'ping-42' },
-            });
-            expect(result.ok).toBe(true);
-            expect(result.text).toContain('echo:ping-42');
-        }
-        finally {
-            await runtime.close();
-        }
-    });
-    it('does not spawn servers outside allowlist', async () => {
-        const runtime = await createMcpRuntime({
-            projectRoot: projectDir,
-            mcp: {
-                allowlist: [],
-                servers: {
-                    echo: {
-                        command: process.execPath,
-                        args: [echoServerPath],
-                    },
-                },
-            },
-        });
-        try {
-            expect(runtime.listRegistrations(['echo'])).toEqual([]);
-        }
-        finally {
-            await runtime.close();
-        }
-    });
-});
-//# sourceMappingURL=create-mcp-runtime.test.js.map

package/vendor/server/dist/mcp/mcp-stdio-client.d.ts

@@ -1,32 +0,0 @@
-/**
- * Minimal MCP JSON-RPC client over stdio (tools/list + tools/call only).
- * Avoids pulling `@modelcontextprotocol/sdk` into the monorepo until needed.
- */
-type McpListedTool = {
-    readonly name: string;
-    readonly description?: string;
-    readonly inputSchema?: object;
-};
-type McpCallResult = {
-    readonly ok: boolean;
-    readonly text: string;
-};
-export type McpStdioClientOptions = {
-    readonly command: string;
-    readonly args?: readonly string[];
-    readonly cwd?: string;
-    readonly env?: Readonly<Record<string, string>>;
-    readonly clientName?: string;
-    readonly clientVersion?: string;
-};
-export type McpStdioClient = {
-    readonly listTools: () => Promise<readonly McpListedTool[]>;
-    readonly callTool: (name: string, args: Readonly<Record<string, unknown>>) => Promise<McpCallResult>;
-    readonly close: () => Promise<void>;
-};
-/**
- * Spawn an MCP server process and complete the initialize handshake.
- */
-export declare const connectMcpStdioClient: (options: McpStdioClientOptions) => Promise<McpStdioClient>;
-export {};
-//# sourceMappingURL=mcp-stdio-client.d.ts.map