langflower 0.1.0 → 0.1.2

package/vendor/server/dist/config/langflower-config.service.js

@@ -1,390 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { DIVIDER_MIN_COMPOSER_HEIGHT, DIVIDER_MIN_LEFT_WIDTH, DIVIDER_MIN_RIGHT_WIDTH, clampDividerSize, isValidMcpServerId, mergeLangflowerConfigLayers, } from '@langflower/shared/langflower.js';
-import { parseJsonc } from '../utils/parse-jsonc.js';
-import { resolveGlobalLangflowerConfigPath } from './resolve-global-langflower-config-path.js';
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-const isPermissionDecision = (value) => value === 'allow' || value === 'ask' || value === 'deny';
-const parsePermissionToolConfig = (raw) => {
-    if (isPermissionDecision(raw)) {
-        return raw;
-    }
-    if (!isRecord(raw)) {
-        return undefined;
-    }
-    const entries = Object.entries(raw).filter((entry) => isPermissionDecision(entry[1]));
-    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
-};
-const parsePermission = (raw) => {
-    if (!isRecord(raw)) {
-        return undefined;
-    }
-    const entries = Object.entries(raw).flatMap(([toolId, value]) => {
-        const parsed = parsePermissionToolConfig(value);
-        return parsed === undefined ? [] : [[toolId, parsed]];
-    });
-    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
-};
-const parseHarness = (raw) => {
-    if (!isRecord(raw)) {
-        return undefined;
-    }
-    const denyPaths = Array.isArray(raw.denyPaths) &&
-        raw.denyPaths.every((entry) => typeof entry === 'string')
-        ? raw.denyPaths
-        : undefined;
-    if (denyPaths === undefined) {
-        return undefined;
-    }
-    return { denyPaths };
-};
-const parseProviderModels = (raw) => {
-    if (Array.isArray(raw) && raw.every((model) => typeof model === 'string')) {
-        return raw;
-    }
-    if (isRecord(raw)) {
-        const ids = Object.keys(raw);
-        return ids.length > 0 ? ids : undefined;
-    }
-    return undefined;
-};
-function parseProviders(raw) {
-    if (!isRecord(raw)) {
-        return undefined;
-    }
-    const entries = Object.entries(raw).flatMap(([id, value]) => {
-        if (!isRecord(value) || typeof value.name !== 'string') {
-            return [];
-        }
-        const models = parseProviderModels(value.models);
-        return [
-            [
-                id,
-                {
-                    ...value,
-                    name: value.name,
-                    ...(models !== undefined ? { models } : {}),
-                },
-            ],
-        ];
-    });
-    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
-}
-function parseTools(raw) {
-    if (!Array.isArray(raw)) {
-        return undefined;
-    }
-    const tools = raw.filter((entry) => isRecord(entry) &&
-        typeof entry.id === 'string' &&
-        typeof entry.name === 'string');
-    return tools.length > 0 ? tools : undefined;
-}
-const parseMcpServer = (raw) => {
-    if (!isRecord(raw) || typeof raw.kind !== 'string') {
-        return undefined;
-    }
-    const toolNames = typeof raw.toolNames === 'string' && raw.toolNames.trim().length > 0
-        ? raw.toolNames.trim()
-        : undefined;
-    if (raw.kind === 'stdio') {
-        const command = typeof raw.command === 'string' ? raw.command.trim() : '';
-        if (command.length === 0) {
-            return undefined;
-        }
-        return {
-            kind: 'stdio',
-            command,
-            ...(toolNames !== undefined ? { toolNames } : {}),
-        };
-    }
-    if (raw.kind === 'http') {
-        const url = typeof raw.url === 'string' ? raw.url.trim() : '';
-        if (url.length === 0) {
-            return undefined;
-        }
-        const command = typeof raw.command === 'string' && raw.command.trim().length > 0
-            ? raw.command.trim()
-            : undefined;
-        return {
-            kind: 'http',
-            url,
-            ...(command !== undefined ? { command } : {}),
-            ...(toolNames !== undefined ? { toolNames } : {}),
-        };
-    }
-    return undefined;
-};
-const parseMcp = (raw) => {
-    if (!isRecord(raw) || !isRecord(raw.servers)) {
-        return undefined;
-    }
-    const servers = Object.fromEntries(Object.entries(raw.servers).flatMap(([id, value]) => {
-        if (!isValidMcpServerId(id)) {
-            return [];
-        }
-        const parsed = parseMcpServer(value);
-        return parsed === undefined ? [] : [[id, parsed]];
-    }));
-    if (Object.keys(servers).length === 0) {
-        return undefined;
-    }
-    return { servers };
-};
-function parseLangflowerConfig(raw) {
-    if (!isRecord(raw)) {
-        return {};
-    }
-    const providers = parseProviders(raw.provider);
-    const tools = parseTools(raw.tools);
-    const permission = parsePermission(raw.permission);
-    const harness = parseHarness(raw.harness);
-    const mcp = parseMcp(raw.mcp);
-    return {
-        ...(typeof raw.currentWorkflowId === 'string' &&
-            raw.currentWorkflowId.length > 0
-            ? { currentWorkflowId: raw.currentWorkflowId }
-            : {}),
-        ...(typeof raw.model === 'string' ? { model: raw.model } : {}),
-        ...(typeof raw.embedding === 'string'
-            ? { embedding: raw.embedding }
-            : {}),
-        ...(typeof raw.serverLogs === 'boolean'
-            ? { serverLogs: raw.serverLogs }
-            : {}),
-        ...(providers !== undefined ? { provider: providers } : {}),
-        ...(tools !== undefined ? { tools } : {}),
-        ...(permission !== undefined ? { permission } : {}),
-        ...(harness !== undefined ? { harness } : {}),
-        ...(mcp !== undefined ? { mcp } : {}),
-        ...parseDividerPositions(raw.dividerPositions),
-        ...(typeof raw.paletteVisible === 'boolean'
-            ? { paletteVisible: raw.paletteVisible }
-            : {}),
-    };
-}
-function parseDividerPositions(raw) {
-    if (!isRecord(raw)) {
-        return {};
-    }
-    const leftWidth = typeof raw.leftWidth === 'number' && Number.isFinite(raw.leftWidth)
-        ? clampDividerSize(raw.leftWidth, DIVIDER_MIN_LEFT_WIDTH)
-        : undefined;
-    const rightWidth = typeof raw.rightWidth === 'number' && Number.isFinite(raw.rightWidth)
-        ? clampDividerSize(raw.rightWidth, DIVIDER_MIN_RIGHT_WIDTH)
-        : undefined;
-    const composerHeight = typeof raw.composerHeight === 'number' &&
-        Number.isFinite(raw.composerHeight)
-        ? clampDividerSize(raw.composerHeight, DIVIDER_MIN_COMPOSER_HEIGHT)
-        : undefined;
-    if (leftWidth === undefined &&
-        rightWidth === undefined &&
-        composerHeight === undefined) {
-        return {};
-    }
-    return {
-        dividerPositions: {
-            ...(leftWidth !== undefined ? { leftWidth } : {}),
-            ...(rightWidth !== undefined ? { rightWidth } : {}),
-            ...(composerHeight !== undefined ? { composerHeight } : {}),
-        },
-    };
-}
-function mergeLangflowerConfig(existing, patch) {
-    const merged = isRecord(existing)
-        ? { ...existing }
-        : {};
-    if ('currentWorkflowId' in patch) {
-        if (patch.currentWorkflowId === undefined) {
-            delete merged.currentWorkflowId;
-        }
-        else {
-            merged.currentWorkflowId = patch.currentWorkflowId;
-        }
-    }
-    if (patch.model !== undefined) {
-        if (patch.model.trim().length === 0) {
-            delete merged.model;
-        }
-        else {
-            merged.model = patch.model;
-        }
-    }
-    if (patch.embedding !== undefined) {
-        if (patch.embedding.trim().length === 0) {
-            delete merged.embedding;
-        }
-        else {
-            merged.embedding = patch.embedding;
-        }
-    }
-    if ('serverLogs' in patch) {
-        if (patch.serverLogs === undefined) {
-            delete merged.serverLogs;
-        }
-        else {
-            merged.serverLogs = patch.serverLogs;
-        }
-    }
-    if (patch.provider !== undefined) {
-        merged.provider = patch.provider;
-    }
-    if (patch.dividerPositions !== undefined) {
-        merged.dividerPositions = patch.dividerPositions;
-    }
-    if (patch.paletteVisible !== undefined) {
-        merged.paletteVisible = patch.paletteVisible;
-    }
-    return merged;
-}
-function serializeLangflowerConfig(merged) {
-    return `${JSON.stringify(merged, null, '\t')}\n`;
-}
-const stripBridgeOnlyProviderFields = (provider) => {
-    const { hasApiKey: _hasApiKey, ...rest } = provider;
-    return rest;
-};
-const mergeProviderOptionsForSave = (formProvider, existingRaw, apiKeyInput) => {
-    const cleaned = stripBridgeOnlyProviderFields(formProvider);
-    const existing = isRecord(existingRaw) ? existingRaw : {};
-    const existingOptions = isRecord(existing.options) ? existing.options : {};
-    const formOptions = isRecord(cleaned.options) ? cleaned.options : {};
-    const { apiKey: _formKey, hasApiKey: _has, ...safeFormOptions } = formOptions;
-    const trimmedKey = apiKeyInput?.trim();
-    const apiKey = trimmedKey !== undefined && trimmedKey.length > 0
-        ? trimmedKey
-        : typeof existingOptions.apiKey === 'string'
-            ? existingOptions.apiKey
-            : undefined;
-    const options = {
-        ...safeFormOptions,
-        ...(apiKey !== undefined ? { apiKey } : {}),
-    };
-    const { options: _drop, ...withoutOptions } = cleaned;
-    return {
-        ...withoutOptions,
-        name: cleaned.name,
-        ...(cleaned.models !== undefined ? { models: cleaned.models } : {}),
-        ...(Object.keys(options).length > 0 ? { options } : {}),
-    };
-};
-export class LangflowerConfigService {
-    projectDir;
-    globalConfigPath;
-    constructor(projectDir, globalPath = resolveGlobalLangflowerConfigPath()) {
-        this.projectDir = projectDir;
-        this.globalConfigPath = globalPath;
-    }
-    globalPath() {
-        return this.globalConfigPath;
-    }
-    projectConfigPath() {
-        return path.join(this.projectDir, '.langflower', 'langflower.jsonc');
-    }
-    async readRawAt(filePath) {
-        try {
-            const raw = await fs.readFile(filePath, 'utf8');
-            return parseJsonc(raw);
-        }
-        catch {
-            return {};
-        }
-    }
-    async writeRawAt(filePath, merged) {
-        await fs.mkdir(path.dirname(filePath), { recursive: true });
-        await fs.writeFile(filePath, serializeLangflowerConfig(merged), 'utf8');
-    }
-    async readProject() {
-        return parseLangflowerConfig(await this.readRawAt(this.projectConfigPath()));
-    }
-    async readGlobal() {
-        return parseLangflowerConfig(await this.readRawAt(this.globalConfigPath));
-    }
-    async readLayers() {
-        const [project, global] = await Promise.all([
-            this.readProject(),
-            this.readGlobal(),
-        ]);
-        return { project, global };
-    }
-    /** Effective config: project > global merge. */
-    async read() {
-        const layers = await this.readLayers();
-        return mergeLangflowerConfigLayers(layers.global, layers.project);
-    }
-    async write(config) {
-        const merged = mergeLangflowerConfig(await this.readRawAt(this.projectConfigPath()), {
-            ...(config.currentWorkflowId !== undefined
-                ? { currentWorkflowId: config.currentWorkflowId }
-                : {}),
-            ...(config.model !== undefined ? { model: config.model } : {}),
-            ...(config.embedding !== undefined
-                ? { embedding: config.embedding }
-                : {}),
-            ...(config.provider !== undefined
-                ? { provider: config.provider }
-                : {}),
-        });
-        await this.writeRawAt(this.projectConfigPath(), merged);
-    }
-    /**
-     * Persist Settings Save for one scope. Preserves existing apiKey when the
-     * corresponding `providerApiKeys` entry is empty/missing.
-     */
-    async writeSettings(input) {
-        const filePath = input.scope === 'global'
-            ? this.globalConfigPath
-            : this.projectConfigPath();
-        const existingRaw = await this.readRawAt(filePath);
-        const existingProviders = isRecord(existingRaw)
-            ? isRecord(existingRaw.provider)
-                ? existingRaw.provider
-                : {}
-            : {};
-        const provider = input.provider === undefined
-            ? undefined
-            : Object.fromEntries(Object.entries(input.provider).map(([id, entry]) => [
-                id,
-                mergeProviderOptionsForSave(entry, existingProviders[id], input.providerApiKeys?.[id]),
-            ]));
-        const patch = {
-            ...(input.model !== undefined ? { model: input.model } : {}),
-            ...(input.embedding !== undefined
-                ? { embedding: input.embedding }
-                : {}),
-            ...(provider !== undefined ? { provider } : {}),
-            ...('serverLogs' in input
-                ? {
-                    serverLogs: input.serverLogs === null
-                        ? undefined
-                        : input.serverLogs,
-                }
-                : {}),
-        };
-        const merged = mergeLangflowerConfig(existingRaw, patch);
-        await this.writeRawAt(filePath, merged);
-        return this.readLayers();
-    }
-    async setCurrentWorkflowId(workflowId) {
-        const merged = mergeLangflowerConfig(await this.readRawAt(this.projectConfigPath()), {
-            currentWorkflowId: workflowId,
-        });
-        await this.writeRawAt(this.projectConfigPath(), merged);
-        return parseLangflowerConfig(merged);
-    }
-    async setDividerPositions(positions) {
-        const merged = mergeLangflowerConfig(await this.readRawAt(this.projectConfigPath()), {
-            dividerPositions: positions,
-        });
-        await this.writeRawAt(this.projectConfigPath(), merged);
-        return parseLangflowerConfig(merged);
-    }
-    async setPaletteVisible(visible) {
-        const merged = mergeLangflowerConfig(await this.readRawAt(this.projectConfigPath()), {
-            paletteVisible: visible,
-        });
-        await this.writeRawAt(this.projectConfigPath(), merged);
-        return parseLangflowerConfig(merged);
-    }
-}

package/vendor/server/dist/config/langflower-config.service.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=langflower-config.service.test.d.ts.map

package/vendor/server/dist/config/langflower-config.service.test.js

@@ -1,111 +0,0 @@
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { LangflowerConfigService } from './langflower-config.service.js';
-describe('LangflowerConfigService', () => {
-    let projectDir;
-    let service;
-    beforeEach(async () => {
-        projectDir = await fs.mkdtemp(path.join(os.tmpdir(), 'lf-lf-config-'));
-        service = new LangflowerConfigService(projectDir);
-    });
-    afterEach(async () => {
-        await fs.rm(projectDir, { recursive: true, force: true });
-    });
-    it('returns empty config when langflower.jsonc is missing', async () => {
-        await expect(service.read()).resolves.toEqual({});
-    });
-    it('parses known fields from langflower.jsonc', async () => {
-        const configPath = path.join(projectDir, '.langflower', 'langflower.jsonc');
-        await fs.mkdir(path.dirname(configPath), { recursive: true });
-        await fs.writeFile(configPath, `${JSON.stringify({
-            currentWorkflowId: 'example',
-            model: 'openai/gpt-4o-mini',
-            provider: { openai: { name: 'OpenAI' } },
-            permission: {
-                bash: { '*': 'deny', 'npm test': 'ask' },
-                read: 'allow',
-            },
-            harness: { denyPaths: ['.env'] },
-        }, null, '\t')}\n`, 'utf8');
-        await expect(service.read()).resolves.toEqual({
-            currentWorkflowId: 'example',
-            model: 'openai/gpt-4o-mini',
-            provider: { openai: { name: 'OpenAI' } },
-            permission: {
-                bash: { '*': 'deny', 'npm test': 'ask' },
-                read: 'allow',
-            },
-            harness: { denyPaths: ['.env'] },
-        });
-    });
-    it('preserves unknown keys on setCurrentWorkflowId', async () => {
-        const configPath = path.join(projectDir, '.langflower', 'langflower.jsonc');
-        await fs.mkdir(path.dirname(configPath), { recursive: true });
-        await fs.writeFile(configPath, `${JSON.stringify({
-            $schema: 'https://opencode.ai/config.json',
-            provider: {},
-        }, null, '\t')}\n`, 'utf8');
-        await service.setCurrentWorkflowId('example');
-        const raw = JSON.parse(await fs.readFile(configPath, 'utf8'));
-        expect(raw.$schema).toBe('https://opencode.ai/config.json');
-        expect(raw.currentWorkflowId).toBe('example');
-        expect(raw.provider).toEqual({});
-    });
-    it('clears currentWorkflowId when set to undefined', async () => {
-        await service.setCurrentWorkflowId('example');
-        await service.setCurrentWorkflowId(undefined);
-        await expect(service.read()).resolves.toEqual({});
-    });
-    it('ignores invalid currentWorkflowId values when reading', async () => {
-        const configPath = path.join(projectDir, '.langflower', 'langflower.jsonc');
-        await fs.mkdir(path.dirname(configPath), { recursive: true });
-        await fs.writeFile(configPath, `${JSON.stringify({ currentWorkflowId: '' })}\n`, 'utf8');
-        await expect(service.read()).resolves.toEqual({});
-    });
-    it('parses OpenCode object models to string ids', async () => {
-        const configPath = path.join(projectDir, '.langflower', 'langflower.jsonc');
-        await fs.mkdir(path.dirname(configPath), { recursive: true });
-        await fs.writeFile(configPath, `${JSON.stringify({
-            provider: {
-                openai: {
-                    name: 'OpenAI',
-                    models: {
-                        'gpt-4o-mini': { name: 'GPT-4o Mini' },
-                        'gpt-4o': { name: 'GPT-4o' },
-                    },
-                },
-            },
-        }, null, '\t')}\n`, 'utf8');
-        await expect(service.read()).resolves.toEqual({
-            provider: {
-                openai: {
-                    name: 'OpenAI',
-                    models: ['gpt-4o-mini', 'gpt-4o'],
-                },
-            },
-        });
-    });
-    it('keeps string-array models form', async () => {
-        const configPath = path.join(projectDir, '.langflower', 'langflower.jsonc');
-        await fs.mkdir(path.dirname(configPath), { recursive: true });
-        await fs.writeFile(configPath, `${JSON.stringify({
-            provider: {
-                mock: {
-                    name: 'Mock',
-                    models: ['alpha', 'beta'],
-                },
-            },
-        }, null, '\t')}\n`, 'utf8');
-        await expect(service.read()).resolves.toEqual({
-            provider: {
-                mock: {
-                    name: 'Mock',
-                    models: ['alpha', 'beta'],
-                },
-            },
-        });
-    });
-});
-//# sourceMappingURL=langflower-config.service.test.js.map

package/vendor/server/dist/config/redact-langflower-config.d.ts

@@ -1,8 +0,0 @@
-import type { LangflowerConfig } from '@langflower/shared/langflower.js';
-/**
- * Strips secret-bearing fields from project config before WebSocket snapshots.
- * Omits `provider.*.options.apiKey` (literal or `{env:…}`); UI keeps `name` +
- * `models` and non-secret options such as `baseURL`. Sets `hasApiKey` when a
- * secret was present so Settings can show write-only placeholders.
- */
-export declare const redactLangflowerConfigForBridge: (config: LangflowerConfig) => LangflowerConfig;

package/vendor/server/dist/config/redact-langflower-config.js

@@ -1,42 +0,0 @@
-const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-const providerHasApiKey = (provider) => {
-    if (!('options' in provider) || !isRecord(provider.options)) {
-        return false;
-    }
-    const apiKey = provider.options.apiKey;
-    return typeof apiKey === 'string' && apiKey.length > 0;
-};
-const redactProviderOptions = (provider) => {
-    const hasApiKey = providerHasApiKey(provider);
-    if (!('options' in provider) || !isRecord(provider.options)) {
-        return hasApiKey ? { ...provider, hasApiKey: true } : provider;
-    }
-    const { apiKey: _apiKey, ...safeOptions } = provider.options;
-    if (Object.keys(safeOptions).length === 0) {
-        const { options: _options, ...rest } = provider;
-        return hasApiKey
-            ? { ...rest, hasApiKey: true }
-            : rest;
-    }
-    return {
-        ...provider,
-        options: safeOptions,
-        ...(hasApiKey ? { hasApiKey: true } : {}),
-    };
-};
-/**
- * Strips secret-bearing fields from project config before WebSocket snapshots.
- * Omits `provider.*.options.apiKey` (literal or `{env:…}`); UI keeps `name` +
- * `models` and non-secret options such as `baseURL`. Sets `hasApiKey` when a
- * secret was present so Settings can show write-only placeholders.
- */
-export const redactLangflowerConfigForBridge = (config) => {
-    if (config.provider === undefined) {
-        return config;
-    }
-    const provider = Object.fromEntries(Object.entries(config.provider).map(([id, entry]) => [
-        id,
-        redactProviderOptions(entry),
-    ]));
-    return { ...config, provider };
-};

package/vendor/server/dist/config/redact-langflower-config.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=redact-langflower-config.test.d.ts.map

package/vendor/server/dist/config/redact-langflower-config.test.js

@@ -1,69 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { redactLangflowerConfigForBridge } from './redact-langflower-config.js';
-import { resolveProviderCredentials } from './resolve-provider-credentials.js';
-const configWithSecrets = () => ({
-    model: 'openai/gpt-4o-mini',
-    provider: {
-        openai: {
-            name: 'OpenAI',
-            options: {
-                baseURL: 'https://api.openai.com/v1',
-                apiKey: '{env:OPENAI_API_KEY}',
-            },
-            models: ['gpt-4o-mini'],
-        },
-        literal: {
-            name: 'Literal key provider',
-            options: {
-                apiKey: 'sk-live-secret-key-value',
-            },
-            models: ['test-model'],
-        },
-    },
-});
-describe('redactLangflowerConfigForBridge', () => {
-    it('omits apiKey from provider options (env ref and literal)', () => {
-        const redacted = redactLangflowerConfigForBridge(configWithSecrets());
-        expect(redacted.provider?.openai).toEqual({
-            name: 'OpenAI',
-            options: { baseURL: 'https://api.openai.com/v1' },
-            models: ['gpt-4o-mini'],
-        });
-        expect(redacted.provider?.literal).toEqual({
-            name: 'Literal key provider',
-            models: ['test-model'],
-        });
-        expect(redacted.provider?.openai?.options).not.toHaveProperty('apiKey');
-        expect(redacted.provider?.literal).not.toHaveProperty('options');
-    });
-    it('resolved credentials never appear in redacted snapshot payload', () => {
-        const prior = process.env.TEST_LF_KEY;
-        process.env.TEST_LF_KEY = 'resolved-secret-value';
-        try {
-            const config = {
-                provider: {
-                    test: {
-                        name: 'Test',
-                        options: { apiKey: '{env:TEST_LF_KEY}' },
-                    },
-                },
-            };
-            const resolved = resolveProviderCredentials(config, 'test');
-            const redacted = redactLangflowerConfigForBridge(config);
-            const serialized = JSON.stringify(redacted);
-            expect(resolved.apiKey).toBe('resolved-secret-value');
-            expect(serialized).not.toContain('resolved-secret-value');
-            expect(serialized).not.toContain('TEST_LF_KEY');
-            expect(redacted.provider?.test?.options).toBeUndefined();
-        }
-        finally {
-            if (prior === undefined) {
-                delete process.env.TEST_LF_KEY;
-            }
-            else {
-                process.env.TEST_LF_KEY = prior;
-            }
-        }
-    });
-});
-//# sourceMappingURL=redact-langflower-config.test.js.map

package/vendor/server/dist/config/resolve-draft-provider-credentials.d.ts

@@ -1,18 +0,0 @@
-/**
- * Resolve OpenAI-compatible credentials for a Settings draft row probe.
- * Prefer pending draft apiKey; else fall back to the saved layer provider.
- */
-import type { LangflowerConfig, ProviderDraft } from '@langflower/shared/langflower.js';
-type ResolvedCredentials = {
-    readonly apiKey?: string;
-    readonly baseURL?: string;
-};
-export type ResolveDraftProviderCredentialsResult = {
-    readonly ok: true;
-    readonly credentials: ResolvedCredentials;
-} | {
-    readonly ok: false;
-    readonly message: string;
-};
-export declare const resolveDraftProviderCredentials: (row: ProviderDraft, savedLayer: LangflowerConfig) => ResolveDraftProviderCredentialsResult;
-export {};