langflower 0.0.9 → 0.1.0

package/vendor/common-nodes/dist/embeddings/create-embedding.d.ts

@@ -0,0 +1,39 @@
+import type { OpenAiProviderCredentials } from '../ai/features/openai/create-chat-completion-stream.js';
+export type CreateEmbeddingArgs = {
+    readonly providerId: string;
+    readonly model: string;
+    readonly texts: readonly string[];
+    readonly signal?: AbortSignal;
+};
+export type CreateEmbeddingResult = {
+    readonly dim: number;
+    readonly vectors: readonly Float32Array[];
+};
+export type CreateEmbedding = (args: CreateEmbeddingArgs) => Promise<CreateEmbeddingResult>;
+export type EmbeddingsCreateBody = {
+    readonly model: string;
+    readonly input: readonly string[];
+    readonly encoding_format?: 'float' | 'base64';
+};
+export type EmbeddingsCreateOptions = {
+    readonly signal?: AbortSignal;
+};
+export type EmbeddingsClient = {
+    readonly embeddings: {
+        readonly create: (body: EmbeddingsCreateBody, options?: EmbeddingsCreateOptions) => Promise<{
+            readonly data: readonly {
+                readonly embedding: unknown;
+                readonly index?: number;
+            }[];
+        }>;
+    };
+};
+export type CreateEmbeddingDeps = {
+    readonly resolveProvider: (providerId: string) => Promise<OpenAiProviderCredentials>;
+    readonly createClient?: (credentials: OpenAiProviderCredentials) => EmbeddingsClient;
+};
+/**
+ * Unbound embeddings HTTP factory (`POST /v1/embeddings`).
+ * Forwards {@link CreateEmbeddingArgs.signal} so runner Stop can cancel.
+ */
+export declare const createEmbedding: (deps: CreateEmbeddingDeps) => CreateEmbedding;

package/vendor/common-nodes/dist/embeddings/create-embedding.js

@@ -0,0 +1,154 @@
+/**
+ * Unbound OpenAI-compatible embeddings factory.
+ * Caller supplies credential resolve (server injects secrets).
+ * Does not rewrite texts for EmbedHandle `role` — packs/catalog do that.
+ *
+ * Always pass `encoding_format: 'float'`. openai-node otherwise defaults to
+ * `base64` and runs `toFloat32Array` on the body; local servers that return
+ * JSON `number[]` become a zero typed array. Chat completions have no such
+ * field — this is embeddings-only.
+ */
+import OpenAI from 'openai';
+const SECRET_SUBSTRINGS = ['sk-', 'apiKey', 'api_key', 'authorization'];
+const requireNonEmpty = (value, label) => {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error(`${label} is required for OpenAI-compatible embeddings`);
+    }
+    return trimmed;
+};
+const toSafeErrorMessage = (message) => {
+    const lower = message.toLowerCase();
+    for (const needle of SECRET_SUBSTRINGS) {
+        if (lower.includes(needle.toLowerCase())) {
+            return 'Failed to create embeddings for provider';
+        }
+    }
+    return message;
+};
+const abortError = () => {
+    const error = new Error('The operation was aborted');
+    error.name = 'AbortError';
+    return error;
+};
+const defaultCreateClient = (credentials) => new OpenAI({
+    apiKey: credentials.apiKey ?? 'local-no-key',
+    ...(credentials.baseURL !== undefined
+        ? { baseURL: credentials.baseURL }
+        : {}),
+});
+const first8 = (value) => {
+    if (Array.isArray(value) || ArrayBuffer.isView(value)) {
+        const list = value;
+        const out = [];
+        const n = Math.min(8, list.length);
+        for (let i = 0; i < n; i += 1) {
+            out.push(list[i]);
+        }
+        return out;
+    }
+    return [];
+};
+const embeddingSnapshot = (embedding) => {
+    const embeddingLen = Array.isArray(embedding) || ArrayBuffer.isView(embedding)
+        ? embedding.length
+        : undefined;
+    return JSON.stringify({
+        embeddingIsArray: Array.isArray(embedding),
+        embeddingType: embedding === null ? 'null' : typeof embedding,
+        embeddingCtor: typeof embedding === 'object' && embedding !== null
+            ? embedding.constructor.name
+            : undefined,
+        embeddingLen,
+        embeddingFirst8: first8(embedding),
+    });
+};
+const missingNumericMessage = (embedding) => `Embedding item is missing a numeric embedding array (is a chat model loaded instead of an embedding model?). ${embeddingSnapshot(embedding)}`;
+const asNumericVector = (embedding) => {
+    if (embedding instanceof Float32Array ||
+        embedding instanceof Float64Array) {
+        return embedding;
+    }
+    if (Array.isArray(embedding)) {
+        const numbers = embedding.filter((item) => typeof item === 'number' && Number.isFinite(item));
+        if (numbers.length !== embedding.length) {
+            throw new Error(missingNumericMessage(embedding));
+        }
+        return numbers;
+    }
+    throw new Error(missingNumericMessage(embedding));
+};
+const l2Norm = (values) => {
+    let sumSq = 0;
+    for (let i = 0; i < values.length; i += 1) {
+        const n = Number(values[i] ?? 0);
+        sumSq += n * n;
+    }
+    return Math.sqrt(sumSq);
+};
+const orderByIndex = (data, textCount) => {
+    const byIndex = new Map();
+    data.forEach((item, fallbackIndex) => {
+        const index = typeof item.index === 'number' ? item.index : fallbackIndex;
+        byIndex.set(index, item.embedding);
+    });
+    return Array.from({ length: textCount }, (_, index) => {
+        if (!byIndex.has(index)) {
+            throw new Error(`Embedding batch missing index ${String(index)}`);
+        }
+        return { embedding: byIndex.get(index) };
+    });
+};
+const toVectors = (data) => {
+    if (data.length === 0) {
+        throw new Error('Provider returned no embedding vectors');
+    }
+    const vectors = data.map((row) => Float32Array.from(asNumericVector(row.embedding)));
+    const dim = vectors[0]?.length ?? 0;
+    if (dim === 0) {
+        throw new Error('Provider returned an empty embedding vector');
+    }
+    for (const vector of vectors) {
+        if (vector.length !== dim) {
+            throw new Error(`Embedding batch dim mismatch: expected ${dim}, got ${vector.length}`);
+        }
+        if (l2Norm(vector) === 0) {
+            throw new Error('Provider returned a zero embedding vector (is a chat model loaded instead of an embedding model?).');
+        }
+    }
+    return { dim, vectors };
+};
+/**
+ * Unbound embeddings HTTP factory (`POST /v1/embeddings`).
+ * Forwards {@link CreateEmbeddingArgs.signal} so runner Stop can cancel.
+ */
+export const createEmbedding = (deps) => {
+    const createClient = deps.createClient ?? defaultCreateClient;
+    return async (args) => {
+        if (args.signal?.aborted === true) {
+            throw abortError();
+        }
+        const providerId = requireNonEmpty(args.providerId, 'Provider');
+        const model = requireNonEmpty(args.model, 'Model');
+        if (args.texts.length === 0) {
+            throw new Error('Texts are required for OpenAI-compatible embeddings');
+        }
+        const credentials = await deps.resolveProvider(providerId);
+        const client = createClient(credentials);
+        try {
+            const response = await client.embeddings.create({
+                model,
+                input: [...args.texts],
+                encoding_format: 'float',
+            }, args.signal !== undefined ? { signal: args.signal } : {});
+            return toVectors(orderByIndex(response.data, args.texts.length));
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw error;
+            }
+            const raw = error instanceof Error ? error.message : String(error);
+            throw new Error(toSafeErrorMessage(raw));
+        }
+    };
+};

package/vendor/common-nodes/dist/embeddings/embed-provider/node.d.ts

@@ -0,0 +1,53 @@
+/**
+ * UC2: emits a live {@link EmbedHandle} on **embed** after a one-text probe
+ * fixes `dim`. Empty panel provider/model → Settings default.
+ */
+export declare const embedProviderNode: {
+    readonly emitOncePerActivation: boolean;
+    readonly stopsRun: boolean;
+    readonly chatEntry: boolean;
+    readonly uiSchema: readonly [{
+        readonly field: "providerId";
+        readonly type: "select";
+        readonly label: "Provider";
+        readonly optionsSource: "langflower.providers";
+    }, {
+        readonly field: "model";
+        readonly type: "select";
+        readonly label: "Model";
+        readonly optionsSource: "langflower.models";
+        readonly dependsOn: "providerId";
+    }];
+    readonly bypassPorts: Record<string, import("@langflower/node-sdk").WireType>;
+    readonly inputsConfigs: readonly [import("@langflower/node-sdk").InputPortMeta<import("@langflower/node-sdk").ExecutionContext<readonly [{
+        readonly field: "providerId";
+        readonly type: "select";
+        readonly label: "Provider";
+        readonly optionsSource: "langflower.providers";
+    }, {
+        readonly field: "model";
+        readonly type: "select";
+        readonly label: "Model";
+        readonly optionsSource: "langflower.models";
+        readonly dependsOn: "providerId";
+    }], Record<string, never>>>, ...import("@langflower/node-sdk").InputPortMeta<unknown>[]];
+    readonly outputsConfigs: (import("@langflower/node-sdk").OutputParams & import("@langflower/node-sdk").PortMeta)[];
+    readonly getInstance: () => import("@langflower/node-sdk").ReactiveNodeInstance<readonly [{
+        readonly field: "providerId";
+        readonly type: "select";
+        readonly label: "Provider";
+        readonly optionsSource: "langflower.providers";
+    }, {
+        readonly field: "model";
+        readonly type: "select";
+        readonly label: "Model";
+        readonly optionsSource: "langflower.models";
+        readonly dependsOn: "providerId";
+    }], Record<string, never>>;
+    readonly paletteSecondary?: true;
+    readonly description?: string;
+    readonly type: string;
+    readonly displayName: string;
+    readonly category: string | undefined;
+    readonly icon: string | undefined;
+};

package/vendor/common-nodes/dist/embeddings/embed-provider/node.js

@@ -0,0 +1,126 @@
+import { defineReactiveNode, withLoading, EMBED_HANDLE_WIRE_TYPE, } from '@langflower/node-sdk';
+import { distinctUntilChanged, map, switchMap } from 'rxjs';
+import { getRunHostServices } from '../../ai/features/run-host-services.js';
+import { fromEmbedding } from '../from-embedding.js';
+import { resolveEmbeddingProviderModel } from '../resolve-embedding-provider-model.js';
+const embedPanelUiSchema = [
+    {
+        field: 'providerId',
+        type: 'select',
+        label: 'Provider',
+        optionsSource: 'langflower.providers',
+    },
+    {
+        field: 'model',
+        type: 'select',
+        label: 'Model',
+        optionsSource: 'langflower.models',
+        dependsOn: 'providerId',
+    },
+];
+const abortError = () => {
+    const error = new Error('The operation was aborted');
+    error.name = 'AbortError';
+    return error;
+};
+const prefixForRole = (text, role) => role === 'query' ? `query: ${text}` : `passage: ${text}`;
+const linkAbortSignals = (runSignal, callSignal) => {
+    const controller = new AbortController();
+    const forward = (signal) => {
+        if (signal.aborted) {
+            controller.abort();
+            return;
+        }
+        signal.addEventListener('abort', () => controller.abort(), {
+            once: true,
+        });
+    };
+    forward(runSignal);
+    if (callSignal !== undefined) {
+        forward(callSignal);
+    }
+    return controller.signal;
+};
+const buildEmbedHandle = (options) => {
+    const { create, providerId, model, dim, runSignal } = options;
+    if (create === undefined) {
+        throw new Error('OpenAI-compatible embeddings are only available during server workflow runs');
+    }
+    return {
+        dim,
+        embedTexts: async (texts, options) => {
+            if (runSignal.aborted === true) {
+                throw abortError();
+            }
+            if (options?.signal?.aborted === true) {
+                throw abortError();
+            }
+            const role = options?.role ?? 'document';
+            const prefixed = texts.map((text) => prefixForRole(text, role));
+            const result = await create({
+                providerId,
+                model,
+                texts: prefixed,
+                signal: linkAbortSignals(runSignal, options?.signal),
+            });
+            if (result.dim !== dim) {
+                throw new Error(`Embedding dim mismatch: expected ${dim}, got ${result.dim}`);
+            }
+            return result.vectors;
+        },
+    };
+};
+/**
+ * UC2: emits a live {@link EmbedHandle} on **embed** after a one-text probe
+ * fixes `dim`. Empty panel provider/model → Settings default.
+ */
+export const embedProviderNode = defineReactiveNode({
+    type: 'common-embed-provider',
+    displayName: 'Embed provider',
+    category: 'Embeddings',
+    description: `
+Share an embedding model with custom nodes. Wire **embed** into a pack that needs batch vectors.
+
+Uses the Settings default model, or pick one on this node.
+`.trim(),
+    uiSchema: embedPanelUiSchema,
+    bind(ctx, { configureOutput, combineInputs }) {
+        const resolved$ = combineInputs([ctx], ([ec]) => ec).pipeValue(map((ec) => {
+            const host = getRunHostServices(ec);
+            const resolved = resolveEmbeddingProviderModel(ec.params, host);
+            return {
+                ec,
+                host,
+                key: `${resolved.providerId}/${resolved.model}`,
+                ...resolved,
+            };
+        }), distinctUntilChanged((left, right) => left.key === right.key));
+        const embed$ = resolved$.pipe(withLoading()).pipeValue(switchMap(({ host, providerId, model }) => fromEmbedding(async (runSignal) => {
+            const create = host?.createEmbedding;
+            if (create === undefined) {
+                throw new Error('OpenAI-compatible embeddings are only available during server workflow runs');
+            }
+            const probe = await create({
+                providerId,
+                model,
+                texts: [prefixForRole('x', 'document')],
+                signal: runSignal,
+            });
+            return buildEmbedHandle({
+                create,
+                providerId,
+                model,
+                dim: probe.dim,
+                runSignal,
+            });
+        })));
+        return {
+            inputs: [],
+            outputs: [
+                configureOutput('embed', embed$, {
+                    wireType: EMBED_HANDLE_WIRE_TYPE,
+                }),
+            ],
+        };
+    },
+});

package/vendor/common-nodes/dist/embeddings/embed-similarity/node.d.ts

@@ -0,0 +1,20 @@
+/**
+ * UC1: L2-normalized dot (cosine) between two wired JSON vectors.
+ * Pure / offline — no HTTP, no provider panel.
+ */
+export declare const embedSimilarityNode: {
+    readonly emitOncePerActivation: boolean;
+    readonly stopsRun: boolean;
+    readonly chatEntry: boolean;
+    readonly uiSchema: readonly [];
+    readonly bypassPorts: Record<string, import("@langflower/node-sdk").WireType>;
+    readonly inputsConfigs: readonly [import("@langflower/node-sdk").InputPortMeta<import("@langflower/node-sdk").ExecutionContext<readonly [], Record<string, never>>>, ...import("@langflower/node-sdk").InputPortMeta<unknown>[]];
+    readonly outputsConfigs: (import("@langflower/node-sdk").OutputParams & import("@langflower/node-sdk").PortMeta)[];
+    readonly getInstance: () => import("@langflower/node-sdk").ReactiveNodeInstance<readonly [], Record<string, never>>;
+    readonly paletteSecondary?: true;
+    readonly description?: string;
+    readonly type: string;
+    readonly displayName: string;
+    readonly category: string | undefined;
+    readonly icon: string | undefined;
+};

package/vendor/common-nodes/dist/embeddings/embed-similarity/node.js

@@ -0,0 +1,81 @@
+import { defineReactiveNode } from '@langflower/node-sdk';
+const toNumberVector = (value, label) => {
+    if (!Array.isArray(value)) {
+        throw new Error(`${label} must be a JSON number array`);
+    }
+    return value.map((entry, index) => {
+        const n = Number(entry);
+        if (!Number.isFinite(n)) {
+            throw new Error(`${label}[${index}] must be a finite number`);
+        }
+        return n;
+    });
+};
+const l2Normalize = (values) => {
+    const out = new Float32Array(values.length);
+    let sumSq = 0;
+    for (let i = 0; i < values.length; i += 1) {
+        const n = values[i] ?? 0;
+        out[i] = n;
+        sumSq += n * n;
+    }
+    const norm = Math.sqrt(sumSq);
+    if (norm === 0) {
+        throw new Error('Cannot compute similarity for a zero-norm vector');
+    }
+    const scale = 1 / norm;
+    for (let i = 0; i < out.length; i += 1) {
+        out[i] = (out[i] ?? 0) * scale;
+    }
+    return out;
+};
+const cosineSimilarity = (left, right) => {
+    if (left.length !== right.length) {
+        throw new Error(`Vector dim mismatch: ${left.length} vs ${right.length}`);
+    }
+    const a = l2Normalize(left);
+    const b = l2Normalize(right);
+    let sum = 0;
+    for (let i = 0; i < a.length; i += 1) {
+        sum += (a[i] ?? 0) * (b[i] ?? 0);
+    }
+    return sum;
+};
+/**
+ * UC1: L2-normalized dot (cosine) between two wired JSON vectors.
+ * Pure / offline — no HTTP, no provider panel.
+ */
+export const embedSimilarityNode = defineReactiveNode({
+    type: 'common-embed-similarity',
+    displayName: 'Embed similarity',
+    category: 'Embeddings',
+    description: `
+Score how close two vectors are (cosine, typically 0–1).
+
+Typical uses:
+- Compare two Embed text outputs
+- Rank which snippet matches a query
+`.trim(),
+    uiSchema: [],
+    bind(_ctx, { makeInput, configureOutput, combineInputs }) {
+        const a = makeInput('a', {
+            name: 'a',
+            wireType: 'json',
+            required: true,
+        });
+        const b = makeInput('b', {
+            name: 'b',
+            wireType: 'json',
+            required: true,
+        });
+        const score$ = combineInputs([a, b], ([left, right]) => cosineSimilarity(toNumberVector(left, 'a'), toNumberVector(right, 'b')));
+        return {
+            inputs: [a, b],
+            outputs: [
+                configureOutput('score', score$, {
+                    wireType: 'number',
+                }),
+            ],
+        };
+    },
+});

package/vendor/common-nodes/dist/embeddings/embed-text/node.d.ts

@@ -0,0 +1,53 @@
+/**
+ * UC1: embed a single string via the host embeddings factory (raw texts,
+ * no e5 role prefixes). Empty panel provider/model → Settings default.
+ */
+export declare const embedTextNode: {
+    readonly emitOncePerActivation: boolean;
+    readonly stopsRun: boolean;
+    readonly chatEntry: boolean;
+    readonly uiSchema: readonly [{
+        readonly field: "providerId";
+        readonly type: "select";
+        readonly label: "Provider";
+        readonly optionsSource: "langflower.providers";
+    }, {
+        readonly field: "model";
+        readonly type: "select";
+        readonly label: "Model";
+        readonly optionsSource: "langflower.models";
+        readonly dependsOn: "providerId";
+    }];
+    readonly bypassPorts: Record<string, import("@langflower/node-sdk").WireType>;
+    readonly inputsConfigs: readonly [import("@langflower/node-sdk").InputPortMeta<import("@langflower/node-sdk").ExecutionContext<readonly [{
+        readonly field: "providerId";
+        readonly type: "select";
+        readonly label: "Provider";
+        readonly optionsSource: "langflower.providers";
+    }, {
+        readonly field: "model";
+        readonly type: "select";
+        readonly label: "Model";
+        readonly optionsSource: "langflower.models";
+        readonly dependsOn: "providerId";
+    }], Record<string, never>>>, ...import("@langflower/node-sdk").InputPortMeta<unknown>[]];
+    readonly outputsConfigs: (import("@langflower/node-sdk").OutputParams & import("@langflower/node-sdk").PortMeta)[];
+    readonly getInstance: () => import("@langflower/node-sdk").ReactiveNodeInstance<readonly [{
+        readonly field: "providerId";
+        readonly type: "select";
+        readonly label: "Provider";
+        readonly optionsSource: "langflower.providers";
+    }, {
+        readonly field: "model";
+        readonly type: "select";
+        readonly label: "Model";
+        readonly optionsSource: "langflower.models";
+        readonly dependsOn: "providerId";
+    }], Record<string, never>>;
+    readonly paletteSecondary?: true;
+    readonly description?: string;
+    readonly type: string;
+    readonly displayName: string;
+    readonly category: string | undefined;
+    readonly icon: string | undefined;
+};

package/vendor/common-nodes/dist/embeddings/embed-text/node.js

@@ -0,0 +1,91 @@
+import { defineReactiveNode, withLoading } from '@langflower/node-sdk';
+import { map, switchMap } from 'rxjs';
+import { getRunHostServices } from '../../ai/features/run-host-services.js';
+import { fromEmbedding } from '../from-embedding.js';
+import { resolveEmbeddingProviderModel } from '../resolve-embedding-provider-model.js';
+const PREVIEW_FLOATS = 8;
+const embedPanelUiSchema = [
+    {
+        field: 'providerId',
+        type: 'select',
+        label: 'Provider',
+        optionsSource: 'langflower.providers',
+    },
+    {
+        field: 'model',
+        type: 'select',
+        label: 'Model',
+        optionsSource: 'langflower.models',
+        dependsOn: 'providerId',
+    },
+];
+const formatEmbedPreview = (dim, vector) => {
+    const shown = vector.slice(0, PREVIEW_FLOATS).map((n) => {
+        const rounded = Math.round(n * 100) / 100;
+        return String(rounded);
+    });
+    const suffix = vector.length > PREVIEW_FLOATS ? ', …' : '';
+    return `dim=${dim}  [${shown.join(', ')}${suffix}]`;
+};
+/**
+ * UC1: embed a single string via the host embeddings factory (raw texts,
+ * no e5 role prefixes). Empty panel provider/model → Settings default.
+ */
+export const embedTextNode = defineReactiveNode({
+    type: 'common-embed-text',
+    displayName: 'Embed text',
+    category: 'Embeddings',
+    description: `
+Turn wired text into an embedding vector. Uses the Settings default model, or pick one on the node.
+
+Typical uses:
+- String → Embed text → Preview
+- Feed **vector** into Embed similarity
+`.trim(),
+    uiSchema: embedPanelUiSchema,
+    bind(ctx, { makeInput, configureOutput, combineInputs }) {
+        const text = makeInput('text', {
+            name: 'text',
+            wireType: 'string',
+            inline: 'text',
+            required: true,
+        });
+        const session$ = combineInputs([text, ctx], ([rawText, ec]) => ({
+            rawText: String(rawText ?? ''),
+            ec,
+        }))
+            .pipe(withLoading())
+            .pipeValue(switchMap(({ rawText, ec }) => fromEmbedding(async (signal) => {
+            const host = getRunHostServices(ec);
+            const create = host?.createEmbedding;
+            if (create === undefined) {
+                throw new Error('OpenAI-compatible embeddings are only available during server workflow runs');
+            }
+            const { providerId, model } = resolveEmbeddingProviderModel(ec.params, host);
+            const result = await create({
+                providerId,
+                model,
+                texts: [rawText],
+                signal,
+            });
+            const first = result.vectors[0];
+            if (first === undefined) {
+                throw new Error('Provider returned no embedding vectors');
+            }
+            const vector = Array.from(first);
+            return {
+                vector,
+                dim: result.dim,
+                preview: formatEmbedPreview(result.dim, vector),
+            };
+        })));
+        return {
+            inputs: [text],
+            outputs: [
+                configureOutput('vector', session$.pipeValue(map((session) => session.vector)), { wireType: 'json' }),
+                configureOutput('dim', session$.pipeValue(map((session) => session.dim)), { wireType: 'number' }),
+                configureOutput('preview', session$.pipeValue(map((session) => session.preview)), { wireType: 'string' }),
+            ],
+        };
+    },
+});

package/vendor/common-nodes/dist/embeddings/from-embedding.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Run an embeddings Promise on a teardown-owned AbortSignal.
+ * Stays open after the first value so unsubscribe (runner Stop) can still
+ * abort in-flight work — unlike `from(promise)`, which completes and would
+ * abort immediately after a successful probe.
+ */
+import { Observable } from 'rxjs';
+export declare const fromEmbedding: <T>(work: (signal: AbortSignal) => Promise<T>) => Observable<T>;

package/vendor/common-nodes/dist/embeddings/from-embedding.js

@@ -0,0 +1,24 @@
+/**
+ * Run an embeddings Promise on a teardown-owned AbortSignal.
+ * Stays open after the first value so unsubscribe (runner Stop) can still
+ * abort in-flight work — unlike `from(promise)`, which completes and would
+ * abort immediately after a successful probe.
+ */
+import { defer, Observable } from 'rxjs';
+export const fromEmbedding = (work) => defer(() => {
+    const cancel = new AbortController();
+    return new Observable((subscriber) => {
+        void work(cancel.signal).then((value) => {
+            if (!subscriber.closed) {
+                subscriber.next(value);
+            }
+        }, (error) => {
+            if (!subscriber.closed) {
+                subscriber.error(error);
+            }
+        });
+        return () => {
+            cancel.abort();
+        };
+    });
+});

package/vendor/common-nodes/dist/embeddings/resolve-embedding-provider-model.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Resolve embedding provider/model from node params with optional host
+ * default (`LangflowerConfig.embedding` parsed into
+ * {@link RunHostServices.defaultEmbedding}).
+ */
+import type { RunHostServices } from '../ai/features/run-host-services.js';
+export type ResolvedEmbeddingProviderModel = {
+    readonly providerId: string;
+    readonly model: string;
+};
+export declare const resolveEmbeddingProviderModel: (params: Readonly<Record<string, unknown>>, host: RunHostServices | undefined) => ResolvedEmbeddingProviderModel;

package/vendor/common-nodes/dist/embeddings/resolve-embedding-provider-model.js

@@ -0,0 +1,8 @@
+export const resolveEmbeddingProviderModel = (params, host) => {
+    const fromParamsProvider = String(params['providerId'] ?? '').trim();
+    const fromParamsModel = String(params['model'] ?? '').trim();
+    return {
+        providerId: fromParamsProvider || host?.defaultEmbedding?.providerId || '',
+        model: fromParamsModel || host?.defaultEmbedding?.model || '',
+    };
+};