@kaelio/ktx 0.1.0 → 0.1.1

package/node_modules/@ktx/llm/dist/embedding-provider.js

@@ -1,15 +1,6 @@
-import { createHash } from 'node:crypto';
-import { spawn } from 'node:child_process';
-import { join } from 'node:path';
 import OpenAI from 'openai';
 const DEFAULT_BATCH_SIZE = 100;
-function deterministicVector(text, dimensions) {
-    const digest = createHash('sha256').update(text).digest();
-    return Array.from({ length: dimensions }, (_, index) => {
-        const byte = digest[index % digest.length];
-        return Number(((byte / 255) * 2 - 1).toFixed(6));
-    });
-}
+const HTTP_ERROR_BODY_MAX_LENGTH = 2_000;
 function assertNonEmptyText(text) {
     if (!text.trim()) {
         throw new Error('Embedding text must be non-empty');
@@ -41,102 +32,12 @@ function joinUrl(baseURL, pathPrefix, path) {
     const suffix = path.replace(/^\/+/, '');
     return prefix ? `${base}/${prefix}/${suffix}` : `${base}/${suffix}`;
 }
-function errorText(error) {
-    if (error instanceof Error) {
-        return error.cause
-            ? `${error.name}: ${error.message}; cause: ${errorText(error.cause)}`
-            : `${error.name}: ${error.message}`;
-    }
-    return String(error);
-}
-function parseJsonObject(raw, subcommand) {
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new Error(`ktx-daemon ${subcommand} returned non-object JSON`);
-    }
-    return parsed;
-}
-function isCommandNotFound(error) {
-    return (error instanceof Error &&
-        ('code' in error || 'errno' in error) &&
-        (error.code === 'ENOENT' || error.errno === 'ENOENT'));
-}
-function defaultSentenceTransformersProcessCommands() {
-    const venvBin = process.platform === 'win32' ? join('.venv', 'Scripts', 'ktx-daemon.exe') : join('.venv', 'bin', 'ktx-daemon');
-    const repoVenvBin = process.platform === 'win32'
-        ? join('ktx', '.venv', 'Scripts', 'ktx-daemon.exe')
-        : join('ktx', '.venv', 'bin', 'ktx-daemon');
-    return [
-        { command: 'ktx-daemon', args: [] },
-        { command: venvBin, args: [] },
-        { command: repoVenvBin, args: [] },
-    ];
-}
-function runSentenceTransformersProcessCommand(options) {
-    return async (subcommand, payload) => new Promise((resolve, reject) => {
-        const child = spawn(options.command, [...options.args, subcommand], {
-            cwd: options.cwd,
-            env: { ...process.env, ...options.env },
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        const stdout = [];
-        const stderr = [];
-        child.stdout.on('data', (chunk) => stdout.push(chunk));
-        child.stderr.on('data', (chunk) => stderr.push(chunk));
-        child.on('error', reject);
-        child.on('close', (code) => {
-            const stdoutText = Buffer.concat(stdout).toString('utf8').trim();
-            const stderrText = Buffer.concat(stderr).toString('utf8').trim();
-            if (code !== 0) {
-                reject(new Error(`ktx-daemon ${subcommand} failed: ${stderrText || `exit code ${code}`}`));
-                return;
-            }
-            try {
-                resolve(parseJsonObject(stdoutText, subcommand));
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-        child.stdin.end(`${JSON.stringify(payload)}\n`);
-    });
-}
-function runSentenceTransformersProcessJson(options) {
-    return async (subcommand, payload) => {
-        const errors = [];
-        for (const command of options.commands) {
-            try {
-                return await runSentenceTransformersProcessCommand({
-                    ...command,
-                    cwd: options.cwd,
-                    env: options.env,
-                })(subcommand, payload);
-            }
-            catch (error) {
-                errors.push(`${command.command}: ${errorText(error)}`);
-                if (!isCommandNotFound(error)) {
-                    break;
-                }
-            }
-        }
-        throw new Error(`ktx-daemon ${subcommand} failed: ${errors.join('; ')}`);
-    };
-}
-class DeterministicEmbeddingProvider {
-    dimensions;
-    maxBatchSize;
-    constructor(dimensions, batchSize = DEFAULT_BATCH_SIZE) {
-        this.dimensions = dimensions;
-        this.maxBatchSize = batchSize;
-    }
-    async embed(text) {
-        assertNonEmptyText(text);
-        return deterministicVector(text, this.dimensions);
-    }
-    async embedMany(texts) {
-        assertBatchSize(texts, this.maxBatchSize);
-        return texts.map((text) => deterministicVector(text, this.dimensions));
+function boundedHttpBody(text) {
+    const normalized = text.trim();
+    if (normalized.length <= HTTP_ERROR_BODY_MAX_LENGTH) {
+        return normalized;
     }
+    return `${normalized.slice(0, HTTP_ERROR_BODY_MAX_LENGTH)}...`;
 }
 class OpenAIEmbeddingProvider {
     config;
@@ -186,9 +87,7 @@ class SentenceTransformersEmbeddingProvider {
     fetch;
     baseURL;
     pathPrefix;
-    runJson;
     startupProbe;
-    useProcessRunner = false;
     constructor(config, deps) {
         if (!config.sentenceTransformers?.baseURL) {
             throw new Error('sentenceTransformers.baseURL is required when KTX embedding backend is sentence-transformers');
@@ -198,15 +97,6 @@ class SentenceTransformersEmbeddingProvider {
         this.fetch = deps.fetch ?? fetch;
         this.baseURL = config.sentenceTransformers.baseURL;
         this.pathPrefix = config.sentenceTransformers.pathPrefix ?? '/api';
-        this.runJson =
-            deps.runSentenceTransformersJson ??
-                runSentenceTransformersProcessJson({
-                    commands: deps.sentenceTransformersCommand
-                        ? [{ command: deps.sentenceTransformersCommand, args: deps.sentenceTransformersArgs ?? [] }]
-                        : defaultSentenceTransformersProcessCommands(),
-                    cwd: deps.sentenceTransformersCwd,
-                    env: deps.sentenceTransformersEnv,
-                });
         this.startupProbe = this.requestSingle('__ktx_embedding_probe__').then((embedding) => {
             assertVectorDimensions(embedding, this.dimensions, 'sentence-transformers');
         });
@@ -219,7 +109,7 @@ class SentenceTransformersEmbeddingProvider {
     async embedMany(texts) {
         assertBatchSize(texts, this.maxBatchSize);
         await this.startupProbe;
-        const response = await this.requestJson('embedding-compute-bulk', '/embeddings/compute-bulk', { texts });
+        const response = await this.requestJson('/embeddings/compute-bulk', { texts });
         if (!response ||
             typeof response !== 'object' ||
             !('embeddings' in response) ||
@@ -233,29 +123,14 @@ class SentenceTransformersEmbeddingProvider {
         return response.embeddings.map((embedding) => assertVectorDimensions(embedding, this.dimensions, 'sentence-transformers'));
     }
     async requestSingle(text) {
-        const response = await this.requestJson('embedding-compute', '/embeddings/compute', { text });
+        const response = await this.requestJson('/embeddings/compute', { text });
         if (!response || typeof response !== 'object' || !('embedding' in response) || !Array.isArray(response.embedding)) {
             throw new Error('Embedding provider sentence-transformers returned malformed single response');
         }
         return response.embedding;
     }
-    async requestJson(command, path, body) {
-        if (this.useProcessRunner) {
-            return this.runJson(command, body);
-        }
-        try {
-            return await this.postJson(path, body);
-        }
-        catch (httpError) {
-            try {
-                const response = await this.runJson(command, body);
-                this.useProcessRunner = true;
-                return response;
-            }
-            catch (processError) {
-                throw new Error(`Embedding provider sentence-transformers local HTTP request failed (${errorText(httpError)}) and ktx-daemon fallback failed (${errorText(processError)})`);
-            }
-        }
+    async requestJson(path, body) {
+        return await this.postJson(path, body);
     }
     async postJson(path, body) {
         const response = await this.fetch(joinUrl(this.baseURL, this.pathPrefix, path), {
@@ -264,7 +139,8 @@ class SentenceTransformersEmbeddingProvider {
             body: JSON.stringify(body),
         });
         if (!response.ok) {
-            throw new Error(`Embedding provider sentence-transformers request failed with HTTP ${response.status}`);
+            const bodyText = boundedHttpBody(await response.text());
+            throw new Error(`Embedding provider sentence-transformers request failed with HTTP ${response.status}${bodyText ? `: ${bodyText}` : ''}`);
         }
         const parsed = (await response.json());
         if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
@@ -275,8 +151,6 @@ class SentenceTransformersEmbeddingProvider {
 }
 export function createKtxEmbeddingProvider(config, deps = {}) {
     switch (config.backend) {
-        case 'deterministic':
-            return new DeterministicEmbeddingProvider(config.dimensions, config.batchSize);
         case 'openai':
             return new OpenAIEmbeddingProvider(config, deps);
         case 'sentence-transformers':

package/node_modules/@ktx/llm/dist/embedding-provider.test.js

@@ -1,18 +1,13 @@
 import { describe, expect, it, vi } from 'vitest';
 import { createKtxEmbeddingProvider } from './embedding-provider.js';
 describe('createKtxEmbeddingProvider', () => {
-    it('creates deterministic embeddings with stable dimensions', async () => {
-        const provider = createKtxEmbeddingProvider({
+    it('rejects deterministic embeddings', () => {
+        const config = JSON.parse(JSON.stringify({
             backend: 'deterministic',
             model: 'sha256',
             dimensions: 6,
-            batchSize: 4,
-        });
-        await expect(provider.embed('Revenue policy')).resolves.toHaveLength(6);
-        await expect(provider.embed('Revenue policy')).resolves.toEqual(await provider.embed('Revenue policy'));
-        await expect(provider.embed('Revenue policy')).resolves.not.toEqual(await provider.embed('Approval policy'));
-        await expect(provider.embedMany(['a', 'b'])).resolves.toHaveLength(2);
-        expect(provider.maxBatchSize).toBe(4);
+        }));
+        expect(() => createKtxEmbeddingProvider(config)).toThrow('Unsupported KTX embedding backend: deterministic');
     });
     it('rejects gateway embeddings', () => {
         const config = JSON.parse(JSON.stringify({
@@ -72,28 +67,18 @@ describe('createKtxEmbeddingProvider', () => {
         expect(daemonFetch).toHaveBeenNthCalledWith(1, 'https://daemon.test/base/embeddings/compute', expect.objectContaining({ method: 'POST' }));
         expect(daemonFetch).toHaveBeenNthCalledWith(2, 'https://daemon.test/base/embeddings/compute-bulk', expect.objectContaining({ method: 'POST' }));
     });
-    it('falls back to one-shot ktx-daemon inference when the local HTTP daemon is unavailable', async () => {
-        const fetch = vi.fn().mockRejectedValue(new TypeError('fetch failed'));
-        const runSentenceTransformersJson = vi
+    it('reports local HTTP daemon failures without a ktx-daemon spawn fallback cascade', async () => {
+        const fetch = vi
             .fn()
-            .mockResolvedValueOnce({ embedding: [0.1, 0.2] })
-            .mockResolvedValueOnce({ embeddings: [[0.3, 0.4], [0.5, 0.6]] });
+            .mockResolvedValue(new Response('Embedding compute failed: httpx.InvalidURL: Invalid port', { status: 500 }));
         const provider = createKtxEmbeddingProvider({
             backend: 'sentence-transformers',
             model: 'all-MiniLM-L6-v2',
             dimensions: 2,
             sentenceTransformers: { baseURL: 'http://127.0.0.1:8765', pathPrefix: '' },
-        }, { fetch, runSentenceTransformersJson });
-        await expect(provider.embedMany(['hello', 'world'])).resolves.toEqual([
-            [0.3, 0.4],
-            [0.5, 0.6],
-        ]);
+        }, { fetch });
+        await expect(provider.embed('hello')).rejects.toThrow('Embedding provider sentence-transformers request failed with HTTP 500: Embedding compute failed: httpx.InvalidURL: Invalid port');
+        await expect(provider.embed('hello')).rejects.not.toThrow('ktx-daemon fallback failed');
         expect(fetch).toHaveBeenCalledTimes(1);
-        expect(runSentenceTransformersJson).toHaveBeenNthCalledWith(1, 'embedding-compute', {
-            text: '__ktx_embedding_probe__',
-        });
-        expect(runSentenceTransformersJson).toHaveBeenNthCalledWith(2, 'embedding-compute-bulk', {
-            texts: ['hello', 'world'],
-        });
     });
 });

package/node_modules/@ktx/llm/dist/types.d.ts

@@ -68,7 +68,7 @@ export interface KtxLlmProvider {
     promptCachingConfig(): KtxPromptCachingConfig;
     activeBackend(): KtxLlmBackend;
 }
-export type KtxEmbeddingBackend = 'openai' | 'deterministic' | 'sentence-transformers';
+export type KtxEmbeddingBackend = 'openai' | 'sentence-transformers';
 export interface KtxEmbeddingTokenUsageEvent {
     backend: KtxEmbeddingBackend;
     model: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaelio/ktx",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Standalone KTX context layer for database agents",
   "private": false,
   "type": "module",