langflower 0.1.0 → 0.1.2

package/vendor/server/dist/kb/kb-store.js

@@ -1,250 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import fs from 'node:fs/promises';
-import { cosineSimilarity } from './cosine.js';
-import { chunkText } from './chunk-text.js';
-import { kbChunksPath, kbCollectionDir, kbManifestPath, kbRootDir, kbVectorsPath, sanitizeCollectionId, } from './kb-paths.js';
-import { embedTextLocal, LOCAL_EMBED_DIMS } from './local-embed.js';
-const emptyManifest = () => ({ collections: [] });
-const readJsonFile = async (filePath, fallback) => {
-    try {
-        const raw = await fs.readFile(filePath, 'utf8');
-        return JSON.parse(raw);
-    }
-    catch (error) {
-        if (typeof error === 'object' &&
-            error !== null &&
-            'code' in error &&
-            error.code === 'ENOENT') {
-            return fallback;
-        }
-        throw error;
-    }
-};
-const ensureDir = async (dir) => {
-    await fs.mkdir(dir, { recursive: true });
-};
-const readChunks = async (projectDir, collectionId) => {
-    const filePath = kbChunksPath(projectDir, collectionId);
-    try {
-        const raw = await fs.readFile(filePath, 'utf8');
-        return raw
-            .split('\n')
-            .map((line) => line.trim())
-            .filter((line) => line.length > 0)
-            .map((line) => JSON.parse(line));
-    }
-    catch (error) {
-        if (typeof error === 'object' &&
-            error !== null &&
-            'code' in error &&
-            error.code === 'ENOENT') {
-            return [];
-        }
-        throw error;
-    }
-};
-const writeChunks = async (projectDir, collectionId, chunks) => {
-    await ensureDir(kbCollectionDir(projectDir, collectionId));
-    const body = chunks.length === 0
-        ? ''
-        : `${chunks.map((chunk) => JSON.stringify(chunk)).join('\n')}\n`;
-    await fs.writeFile(kbChunksPath(projectDir, collectionId), body, 'utf8');
-};
-const readVectors = async (projectDir, collectionId, dims, expectedCount) => {
-    const filePath = kbVectorsPath(projectDir, collectionId);
-    try {
-        const buf = await fs.readFile(filePath);
-        const floats = new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
-        if (dims <= 0 || floats.length === 0) {
-            return [];
-        }
-        const count = Math.floor(floats.length / dims);
-        const vectors = [];
-        for (let i = 0; i < count; i += 1) {
-            vectors.push(floats.slice(i * dims, (i + 1) * dims));
-        }
-        if (expectedCount > 0 && vectors.length !== expectedCount) {
-            return vectors.slice(0, Math.min(vectors.length, expectedCount));
-        }
-        return vectors;
-    }
-    catch (error) {
-        if (typeof error === 'object' &&
-            error !== null &&
-            'code' in error &&
-            error.code === 'ENOENT') {
-            return [];
-        }
-        throw error;
-    }
-};
-const writeVectors = async (projectDir, collectionId, vectors) => {
-    await ensureDir(kbCollectionDir(projectDir, collectionId));
-    if (vectors.length === 0) {
-        await fs.writeFile(kbVectorsPath(projectDir, collectionId), Buffer.alloc(0));
-        return;
-    }
-    const dims = vectors[0].length;
-    const out = new Float32Array(vectors.length * dims);
-    for (let i = 0; i < vectors.length; i += 1) {
-        const vec = vectors[i];
-        if (vec.length !== dims) {
-            throw new Error('vector dimension mismatch in collection');
-        }
-        out.set(vec, i * dims);
-    }
-    await fs.writeFile(kbVectorsPath(projectDir, collectionId), Buffer.from(out.buffer, out.byteOffset, out.byteLength));
-};
-const touchManifest = async (projectDir, collectionId, chunkCount) => {
-    await ensureDir(kbRootDir(projectDir));
-    const id = sanitizeCollectionId(collectionId);
-    const manifest = await readJsonFile(kbManifestPath(projectDir), emptyManifest());
-    const updatedAt = new Date().toISOString();
-    const others = manifest.collections.filter((entry) => entry.id !== id);
-    const next = {
-        collections: [
-            ...others,
-            { id, updatedAt, chunkCount },
-        ].sort((a, b) => a.id.localeCompare(b.id)),
-    };
-    await fs.writeFile(kbManifestPath(projectDir), `${JSON.stringify(next, null, '\t')}\n`, 'utf8');
-};
-const defaultEmbedTexts = async (texts) => texts.map((text) => embedTextLocal(text));
-export const ingestText = async (args) => {
-    const collectionId = sanitizeCollectionId(args.collectionId);
-    const pieces = chunkText(args.text);
-    if (pieces.length === 0) {
-        return [];
-    }
-    const documentId = args.documentId?.trim() || randomUUID();
-    const existing = await readChunks(args.projectDir, collectionId);
-    const created = pieces.map((text, index) => ({
-        id: `${documentId}:${index}`,
-        text,
-        meta: {
-            documentId,
-            chunkIndex: index,
-            ...(args.source !== undefined && args.source.length > 0
-                ? { source: args.source }
-                : {}),
-        },
-    }));
-    const next = [...existing, ...created];
-    await writeChunks(args.projectDir, collectionId, next);
-    // New chunks invalidate trailing vectors; keep prefix alignment only when
-    // previous vectors match prior chunk count.
-    const priorVectors = await readVectors(args.projectDir, collectionId, LOCAL_EMBED_DIMS, existing.length);
-    const kept = priorVectors.length === existing.length
-        ? priorVectors
-        : [];
-    await writeVectors(args.projectDir, collectionId, kept);
-    await touchManifest(args.projectDir, collectionId, next.length);
-    return created.map((chunk) => chunk.id);
-};
-export const embedCollection = async (args) => {
-    const collectionId = sanitizeCollectionId(args.collectionId);
-    const chunks = await readChunks(args.projectDir, collectionId);
-    if (chunks.length === 0) {
-        return 0;
-    }
-    const embedTexts = args.embedTexts ?? defaultEmbedTexts;
-    const vectors = await embedTexts(chunks.map((chunk) => chunk.text));
-    await writeVectors(args.projectDir, collectionId, vectors);
-    await touchManifest(args.projectDir, collectionId, chunks.length);
-    return vectors.length;
-};
-export const searchCollection = async (args) => {
-    const collectionId = sanitizeCollectionId(args.collectionId);
-    const topK = Math.max(1, args.topK ?? 5);
-    const chunks = await readChunks(args.projectDir, collectionId);
-    if (chunks.length === 0) {
-        return [];
-    }
-    const embedTexts = args.embedTexts ?? defaultEmbedTexts;
-    const queryVec = (await embedTexts([args.query]))[0];
-    if (queryVec === undefined) {
-        return [];
-    }
-    let vectors = await readVectors(args.projectDir, collectionId, queryVec.length, chunks.length);
-    if (vectors.length !== chunks.length) {
-        vectors = [...(await embedTexts(chunks.map((chunk) => chunk.text)))];
-        await writeVectors(args.projectDir, collectionId, vectors);
-    }
-    const ranked = chunks
-        .map((chunk, index) => ({
-        id: chunk.id,
-        text: chunk.text,
-        meta: chunk.meta,
-        score: cosineSimilarity(queryVec, vectors[index]),
-    }))
-        .sort((a, b) => b.score - a.score)
-        .slice(0, topK);
-    return ranked;
-};
-export const listKb = async (args) => {
-    const manifest = await readJsonFile(kbManifestPath(args.projectDir), emptyManifest());
-    const collectionFilter = args.collectionId?.trim();
-    if (collectionFilter === undefined || collectionFilter.length === 0) {
-        return manifest.collections.map((entry) => ({
-            kind: 'collection',
-            id: entry.id,
-            detail: `${entry.chunkCount} chunks`,
-        }));
-    }
-    const collectionId = sanitizeCollectionId(collectionFilter);
-    const chunks = await readChunks(args.projectDir, collectionId);
-    const byDoc = new Map();
-    for (const chunk of chunks) {
-        const documentId = typeof chunk.meta.documentId === 'string'
-            ? chunk.meta.documentId
-            : chunk.id;
-        byDoc.set(documentId, (byDoc.get(documentId) ?? 0) + 1);
-    }
-    return [...byDoc.entries()].map(([id, count]) => ({
-        kind: 'document',
-        id,
-        detail: `${count} chunks`,
-    }));
-};
-export const deleteFromKb = async (args) => {
-    const collectionId = sanitizeCollectionId(args.collectionId);
-    const chunks = await readChunks(args.projectDir, collectionId);
-    if (chunks.length === 0) {
-        return 0;
-    }
-    const chunkIdSet = args.chunkIds !== undefined && args.chunkIds.length > 0
-        ? new Set(args.chunkIds)
-        : null;
-    const documentId = args.documentId?.trim() ?? '';
-    const deleteAll = chunkIdSet === null && documentId.length === 0;
-    if (deleteAll) {
-        await fs.rm(kbCollectionDir(args.projectDir, collectionId), {
-            recursive: true,
-            force: true,
-        });
-        const manifest = await readJsonFile(kbManifestPath(args.projectDir), emptyManifest());
-        const nextManifest = {
-            collections: manifest.collections.filter((entry) => entry.id !== collectionId),
-        };
-        await ensureDir(kbRootDir(args.projectDir));
-        await fs.writeFile(kbManifestPath(args.projectDir), `${JSON.stringify(nextManifest, null, '\t')}\n`, 'utf8');
-        return chunks.length;
-    }
-    const next = chunks.filter((chunk) => {
-        if (chunkIdSet !== null && chunkIdSet.has(chunk.id)) {
-            return false;
-        }
-        if (documentId.length > 0 &&
-            chunk.meta.documentId === documentId) {
-            return false;
-        }
-        return true;
-    });
-    const removed = chunks.length - next.length;
-    await writeChunks(args.projectDir, collectionId, next);
-    // Drop vectors — re-embed after selective delete.
-    await writeVectors(args.projectDir, collectionId, []);
-    await touchManifest(args.projectDir, collectionId, next.length);
-    return removed;
-};
-//# sourceMappingURL=kb-store.js.map

package/vendor/server/dist/kb/kb-store.test.d.ts

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

package/vendor/server/dist/kb/kb-store.test.js

@@ -1,94 +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 { deleteFromKb, embedCollection, ingestText, listKb, searchCollection, } from './kb-store.js';
-describe('kb-store fixture corpus', () => {
-    let projectDir;
-    beforeEach(async () => {
-        projectDir = await fs.mkdtemp(path.join(os.tmpdir(), 'lf-kb-'));
-    });
-    afterEach(async () => {
-        await fs.rm(projectDir, { recursive: true, force: true });
-    });
-    it('search returns relevant chunks for an ingested fixture corpus', async () => {
-        const collectionId = 'wiki';
-        await ingestText({
-            projectDir,
-            collectionId,
-            documentId: 'langflower-overview',
-            source: 'wiki/overview.md',
-            text: [
-                '# Langflower',
-                '',
-                'Langflower is a visual LLM-chain builder with a WebSocket runner,',
-                'reactive nodes, and a project-local knowledge base under .langflower/kb.',
-                'Agents use harness tools like read, glob, and grep.',
-            ].join('\n'),
-        });
-        await ingestText({
-            projectDir,
-            collectionId,
-            documentId: 'cooking-notes',
-            source: 'wiki/cooking.md',
-            text: [
-                '# Cooking',
-                '',
-                'Sourdough bread needs flour, water, salt, and a lively starter.',
-                'Bake at high heat with steam for a crisp crust.',
-            ].join('\n'),
-        });
-        const embedded = await embedCollection({ projectDir, collectionId });
-        expect(embedded).toBeGreaterThan(0);
-        const hits = await searchCollection({
-            projectDir,
-            collectionId,
-            query: 'How does Langflower store the knowledge base?',
-            topK: 3,
-        });
-        expect(hits.length).toBeGreaterThan(0);
-        expect(hits[0].text.toLowerCase()).toMatch(/langflower|knowledge base|\.langflower/);
-        expect(hits[0].score).toBeGreaterThan(0);
-        const cookingHits = await searchCollection({
-            projectDir,
-            collectionId,
-            query: 'sourdough starter and steam bake',
-            topK: 2,
-        });
-        expect(cookingHits[0].text.toLowerCase()).toMatch(/sourdough|flour|bake/);
-    });
-    it('list and delete maintain collection inventory', async () => {
-        await ingestText({
-            projectDir,
-            collectionId: 'notes',
-            documentId: 'a',
-            text: 'Alpha document about rivers and lakes.',
-        });
-        await ingestText({
-            projectDir,
-            collectionId: 'notes',
-            documentId: 'b',
-            text: 'Beta document about mountains and trails.',
-        });
-        await embedCollection({ projectDir, collectionId: 'notes' });
-        const collections = await listKb({ projectDir });
-        expect(collections.map((item) => item.id)).toContain('notes');
-        const docs = await listKb({ projectDir, collectionId: 'notes' });
-        expect(docs.map((item) => item.id).sort()).toEqual(['a', 'b']);
-        const removed = await deleteFromKb({
-            projectDir,
-            collectionId: 'notes',
-            documentId: 'a',
-        });
-        expect(removed).toBeGreaterThan(0);
-        const after = await listKb({ projectDir, collectionId: 'notes' });
-        expect(after.map((item) => item.id)).toEqual(['b']);
-        const wiped = await deleteFromKb({
-            projectDir,
-            collectionId: 'notes',
-        });
-        expect(wiped).toBeGreaterThan(0);
-        expect(await listKb({ projectDir })).toEqual([]);
-    });
-});
-//# sourceMappingURL=kb-store.test.js.map

package/vendor/server/dist/kb/local-embed.d.ts

@@ -1,8 +0,0 @@
-/** Fixed local embedding size (hashing trick). Offline MVP for epic 10. */
-export declare const LOCAL_EMBED_DIMS = 64;
-/**
- * Deterministic bag-of-tokens hashing embedder. Good enough for fixture
- * relevance tests without an external embedding API.
- */
-export declare const embedTextLocal: (text: string) => Float32Array;
-//# sourceMappingURL=local-embed.d.ts.map

package/vendor/server/dist/kb/local-embed.js

@@ -1,41 +0,0 @@
-/** Fixed local embedding size (hashing trick). Offline MVP for epic 10. */
-export const LOCAL_EMBED_DIMS = 64;
-/**
- * Deterministic bag-of-tokens hashing embedder. Good enough for fixture
- * relevance tests without an external embedding API.
- */
-export const embedTextLocal = (text) => {
-    const vec = new Float32Array(LOCAL_EMBED_DIMS);
-    const tokens = text
-        .toLowerCase()
-        .split(/[^a-z0-9_]+/i)
-        .filter((token) => token.length > 0);
-    for (const token of tokens) {
-        let hash = 2166136261;
-        for (let i = 0; i < token.length; i += 1) {
-            hash ^= token.charCodeAt(i);
-            hash = Math.imul(hash, 16777619);
-        }
-        const index = (hash >>> 0) % LOCAL_EMBED_DIMS;
-        vec[index] = (vec[index] ?? 0) + 1;
-        const index2 = ((hash >>> 8) ^ token.length) % LOCAL_EMBED_DIMS;
-        vec[index2] = (vec[index2] ?? 0) + 0.5;
-    }
-    return l2Normalize(vec);
-};
-const l2Normalize = (vec) => {
-    let sumSquares = 0;
-    for (let i = 0; i < vec.length; i += 1) {
-        sumSquares += vec[i] * vec[i];
-    }
-    if (sumSquares <= 0) {
-        return vec;
-    }
-    const scale = 1 / Math.sqrt(sumSquares);
-    const out = new Float32Array(vec.length);
-    for (let i = 0; i < vec.length; i += 1) {
-        out[i] = vec[i] * scale;
-    }
-    return out;
-};
-//# sourceMappingURL=local-embed.js.map

package/vendor/server/dist/listen-http-server.d.ts

@@ -1,6 +0,0 @@
-import type http from 'node:http';
-/**
- * Bind `httpServer` and reject with a clear message when the port is taken
- * (instead of hanging on a listen without an `error` handler).
- */
-export declare const listenHttpServer: (httpServer: http.Server, port: number, host?: string) => Promise<void>;

package/vendor/server/dist/listen-http-server.js

@@ -1,18 +0,0 @@
-/**
- * Bind `httpServer` and reject with a clear message when the port is taken
- * (instead of hanging on a listen without an `error` handler).
- */
-export const listenHttpServer = (httpServer, port, host = '127.0.0.1') => new Promise((resolve, reject) => {
-    const onError = (error) => {
-        if (error.code === 'EADDRINUSE') {
-            reject(new Error(`порт занят: ${host}:${String(port)}`));
-            return;
-        }
-        reject(error);
-    };
-    httpServer.once('error', onError);
-    httpServer.listen(port, host, () => {
-        httpServer.off('error', onError);
-        resolve();
-    });
-});

package/vendor/server/dist/llm/create-chat-completion-stream.d.ts

@@ -1,8 +0,0 @@
-import type { CreateChatCompletionStream } from '@langflower/node-definitions';
-import type { LangflowerConfigService } from '../config/langflower-config.service.js';
-/**
- * Binds a server-only chat completion stream factory using the official
- * `openai` npm package and phase-1 credential resolve.
- */
-export declare const bindCreateChatCompletionStream: (langflowerConfigService: LangflowerConfigService) => CreateChatCompletionStream;
-//# sourceMappingURL=create-chat-completion-stream.d.ts.map

package/vendor/server/dist/llm/create-chat-completion-stream.js

@@ -1,125 +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 OpenAI-compatible chat`);
-    }
-    return trimmed;
-};
-const toOpenAiMessages = (messages) => messages.map((message) => {
-    if (message.role === 'tool') {
-        return {
-            role: 'tool',
-            content: message.content,
-            tool_call_id: message.tool_call_id,
-        };
-    }
-    if (message.role === 'assistant' && message.tool_calls !== undefined) {
-        return {
-            role: 'assistant',
-            content: message.content.length > 0 ? message.content : null,
-            tool_calls: message.tool_calls.map((call) => ({
-                id: call.id,
-                type: 'function',
-                function: {
-                    name: call.name,
-                    arguments: call.arguments,
-                },
-            })),
-        };
-    }
-    return {
-        role: message.role,
-        content: message.content,
-    };
-});
-const mergeToolCallDelta = (acc, index, delta) => {
-    const current = acc.get(index) ?? { id: '', name: '', arguments: '' };
-    acc.set(index, {
-        id: delta.id !== undefined && delta.id.length > 0 ? delta.id : current.id,
-        name: delta.function?.name !== undefined && delta.function.name.length > 0
-            ? `${current.name}${delta.function.name}`
-            : current.name,
-        arguments: delta.function?.arguments !== undefined
-            ? `${current.arguments}${delta.function.arguments}`
-            : current.arguments,
-    });
-};
-const finalizeToolCalls = (acc) => [...acc.entries()]
-    .sort(([a], [b]) => a - b)
-    .map(([, call]) => ({
-    id: call.id.length > 0 ? call.id : `call_${call.name}`,
-    name: call.name,
-    arguments: call.arguments,
-}))
-    .filter((call) => call.name.length > 0);
-/**
- * Binds a server-only chat completion stream factory using the official
- * `openai` npm package and phase-1 credential resolve.
- */
-export const bindCreateChatCompletionStream = (langflowerConfigService) => {
-    return async (args) => {
-        const providerId = requireNonEmpty(args.providerId, 'Provider');
-        const model = requireNonEmpty(args.model, 'Model');
-        const config = await langflowerConfigService.read();
-        const credentials = resolveProviderCredentials(config, providerId);
-        const client = new OpenAI({
-            apiKey: credentials.apiKey ?? 'local-no-key',
-            ...(credentials.baseURL !== undefined
-                ? { baseURL: credentials.baseURL }
-                : {}),
-        });
-        const tools = args.tools !== undefined && args.tools.length > 0
-            ? args.tools.map((tool) => ({
-                type: 'function',
-                function: {
-                    name: tool.function.name,
-                    ...(tool.function.description !== undefined
-                        ? { description: tool.function.description }
-                        : {}),
-                    ...(tool.function.parameters !== undefined
-                        ? {
-                            parameters: tool.function.parameters,
-                        }
-                        : {}),
-                },
-            }))
-            : undefined;
-        const stream = await client.chat.completions.create({
-            model,
-            messages: toOpenAiMessages(args.messages),
-            stream: true,
-            ...(tools !== undefined ? { tools } : {}),
-        }, {
-            signal: args.signal,
-        });
-        async function* iterate() {
-            let fullText = '';
-            const toolAcc = new Map();
-            for await (const chunk of stream) {
-                const choice = chunk.choices[0];
-                const delta = choice?.delta;
-                const content = delta?.content;
-                if (content !== undefined && content !== null && content.length > 0) {
-                    fullText += content;
-                    yield { kind: 'draft', text: content };
-                }
-                const toolDeltas = delta?.tool_calls;
-                if (toolDeltas !== undefined) {
-                    for (const toolDelta of toolDeltas) {
-                        mergeToolCallDelta(toolAcc, toolDelta.index ?? 0, toolDelta);
-                    }
-                }
-            }
-            const tool_calls = finalizeToolCalls(toolAcc);
-            yield {
-                kind: 'done',
-                text: fullText,
-                ...(tool_calls.length > 0 ? { tool_calls } : {}),
-            };
-        }
-        return iterate();
-    };
-};
-//# sourceMappingURL=create-chat-completion-stream.js.map

package/vendor/server/dist/llm/create-chat-completion-stream.test.d.ts

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

package/vendor/server/dist/llm/create-chat-completion-stream.test.js

@@ -1,72 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { bindCreateChatCompletionStream } from './create-chat-completion-stream.js';
-const mockConfigService = (config) => ({
-    read: async () => config,
-});
-describe('bindCreateChatCompletionStream', () => {
-    it('throws safe errors when provider or model is missing', async () => {
-        const factory = bindCreateChatCompletionStream(mockConfigService({
-            provider: {
-                openai: {
-                    name: 'OpenAI',
-                    options: { apiKey: '{env:MISSING}' },
-                },
-            },
-        }));
-        await expect(factory({
-            providerId: '',
-            model: 'gpt-4o-mini',
-            messages: [{ role: 'user', content: 'Hi' }],
-        })).rejects.toThrow(/Provider is required/);
-        await expect(factory({
-            providerId: 'openai',
-            model: '',
-            messages: [{ role: 'user', content: 'Hi' }],
-        })).rejects.toThrow(/Model is required/);
-    });
-    it('throws when provider id is unknown without leaking secrets', async () => {
-        const factory = bindCreateChatCompletionStream(mockConfigService({
-            provider: {
-                openai: {
-                    name: 'OpenAI',
-                    options: { apiKey: 'sk-test-should-not-leak' },
-                },
-            },
-        }));
-        try {
-            await factory({
-                providerId: 'unknown',
-                model: 'gpt-4o-mini',
-                messages: [{ role: 'user', content: 'Hi' }],
-            });
-            expect.unreachable('expected throw');
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            expect(message).toContain('Provider "unknown" is not configured');
-            expect(message).not.toContain('sk-test');
-        }
-    });
-    it('accepts well-formed args with configured provider (network skipped)', async () => {
-        const factory = bindCreateChatCompletionStream(mockConfigService({
-            provider: {
-                lmstudio: {
-                    name: 'LM Studio',
-                    options: {
-                        baseURL: 'http://127.0.0.1:59999/v1',
-                    },
-                },
-            },
-        }));
-        const messages = [
-            { role: 'system', content: 'You are helpful.' },
-            { role: 'user', content: 'Hi' },
-        ];
-        await expect(factory({
-            providerId: 'lmstudio',
-            model: 'local-model',
-            messages,
-        })).rejects.toThrow();
-    });
-});
-//# sourceMappingURL=create-chat-completion-stream.test.js.map

package/vendor/server/dist/llm/create-embedding.d.ts

@@ -1,9 +0,0 @@
-import type { CreateEmbedding } from '@langflower/node-definitions';
-import type { LangflowerConfigService } from '../config/langflower-config.service.js';
-/**
- * Binds OpenAI-compatible embeddings from `langflower.jsonc` `embedding`.
- * Caller should only inject when `config.embedding` is present; otherwise KB
- * nodes use local hashing.
- */
-export declare const bindCreateEmbedding: (langflowerConfigService: LangflowerConfigService) => CreateEmbedding;
-//# sourceMappingURL=create-embedding.d.ts.map