enigma-memory 0.1.18 → 0.1.22

package/packages/inference-runtime/src/http.js

@@ -0,0 +1,232 @@
+const JSON_TYPE = 'application/json; charset=utf-8';
+
+function writeJson(res, status, value, headers = {}) {
+  const body = JSON.stringify(value);
+  res.writeHead(status, {
+    'Content-Type': JSON_TYPE,
+    'Content-Length': Buffer.byteLength(body),
+    'Cache-Control': 'no-store',
+    'X-Content-Type-Options': 'nosniff',
+    ...headers,
+  });
+  res.end(body);
+}
+
+function routeError(error) {
+  const status = error?.statusCode || (error instanceof TypeError ? 400 : 500);
+  return { status, body: { error: { code: error?.code || (status === 400 ? 'invalid_request' : 'platform_error'), message: error?.message || 'platform request failed' } } };
+}
+
+function readJson(req, maxBytes = 1024 * 1024) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let bytes = 0;
+    let rejected = false;
+    req.on('data', (chunk) => {
+      if (rejected) return;
+      bytes += chunk.length;
+      if (bytes > maxBytes) {
+        rejected = true;
+        const error = new Error(`request body exceeds ${maxBytes} bytes`);
+        error.code = 'payload_too_large';
+        error.statusCode = 413;
+        reject(error);
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.once('error', reject);
+    req.once('end', () => {
+      if (rejected) return;
+      try { resolve(JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}')); }
+      catch { const error = new TypeError('request body must be valid JSON'); error.code = 'invalid_json'; reject(error); }
+    });
+  });
+}
+
+function match(pathname, expression) {
+  const value = expression.exec(pathname);
+  return value ? value.slice(1).map(decodeURIComponent) : null;
+}
+
+function unavailable(capability) {
+  const error = new Error(`${capability} runtime is not configured`);
+  error.code = 'runtime_unavailable';
+  error.statusCode = 503;
+  return error;
+}
+
+export function createInferenceHttpHandler(options = {}) {
+  const chat = options.chat || null;
+  const images = options.images || null;
+  const videos = options.videos || null;
+  const code = options.code || null;
+  const browser = options.browser || null;
+  const authorize = options.authorize;
+  if (typeof authorize !== 'function') throw new TypeError('platform HTTP handler requires an explicit authorizer');
+
+  async function handle(req, res, url) {
+    if (!url.pathname.startsWith('/v1/')) return false;
+    try {
+      let authorized = false;
+      try {
+        authorized = await authorize(req, res);
+      } catch {
+        if (!res.writableEnded) writeJson(res, 401, { error: { code: 'authorization_failed', message: 'platform authorization failed' } });
+        return true;
+      }
+      if (!authorized) {
+        if (!res.writableEnded) writeJson(res, 401, { error: { code: 'unauthorized', message: 'platform authorization required' } });
+        return true;
+      }
+      if (req.method === 'GET' && url.pathname === '/v1/platform') {
+        writeJson(res, 200, { object: 'enigma.platform', capabilities: { chat: Boolean(chat), images: Boolean(images), videos: Boolean(videos), code: Boolean(code), browser: Boolean(browser) } });
+        return true;
+      }
+      if (req.method === 'GET' && url.pathname === '/v1/models') {
+        if (!chat) throw unavailable('chat');
+        writeJson(res, 200, { object: 'list', data: chat.listModels() });
+        return true;
+      }
+      if (req.method === 'POST' && url.pathname === '/v1/chat/completions') {
+        if (!chat) throw unavailable('chat');
+        const payload = await readJson(req, 8 * 1024 * 1024);
+        if (payload.stream === true) {
+          res.writeHead(200, { 'Content-Type': 'text/event-stream; charset=utf-8', 'Cache-Control': 'no-store, no-transform', Connection: 'keep-alive', 'X-Accel-Buffering': 'no' });
+          try {
+            await chat.complete(payload, { onEvent(event) { if (!res.writableEnded) res.write(`data: ${JSON.stringify(event)}\n\n`); } });
+            if (!res.writableEnded) res.end('data: [DONE]\n\n');
+          } catch (error) {
+            if (!res.writableEnded) res.end(`data: ${JSON.stringify({ error: routeError(error).body.error })}\n\ndata: [DONE]\n\n`);
+          }
+        } else writeJson(res, 200, await chat.complete(payload));
+        return true;
+      }
+      if (req.method === 'GET' && url.pathname === '/v1/images/models') {
+        if (!images) throw unavailable('images');
+        writeJson(res, 200, { object: 'list', data: images.listModels() });
+        return true;
+      }
+      if (req.method === 'POST' && url.pathname === '/v1/images/generations') {
+        if (!images) throw unavailable('images');
+        writeJson(res, 200, await images.generate(await readJson(req, 20 * 1024 * 1024)));
+        return true;
+      }
+      if (req.method === 'GET' && url.pathname === '/v1/videos/models') {
+        if (!videos) throw unavailable('videos');
+        writeJson(res, 200, { object: 'list', data: videos.listModels() });
+        return true;
+      }
+      if (req.method === 'POST' && url.pathname === '/v1/videos/queue') {
+        if (!videos) throw unavailable('videos');
+        writeJson(res, 202, await videos.queue(await readJson(req, 20 * 1024 * 1024)));
+        return true;
+      }
+      if (req.method === 'POST' && url.pathname === '/v1/videos/retrieve') {
+        if (!videos) throw unavailable('videos');
+        const payload = await readJson(req);
+        writeJson(res, 200, await videos.retrieve(payload.id));
+        return true;
+      }
+      if (req.method === 'POST' && url.pathname === '/v1/code/sessions') {
+        if (!code) throw unavailable('code');
+        writeJson(res, 201, { session: await code.create(await readJson(req)) });
+        return true;
+      }
+      let route = match(url.pathname, /^\/v1\/code\/sessions\/([^/]+)\/uploads$/);
+      if (req.method === 'POST' && route) {
+        if (!code) throw unavailable('code');
+        writeJson(res, 201, await code.upload(route[0], await readJson(req, 8 * 1024 * 1024)));
+        return true;
+      }
+      route = match(url.pathname, /^\/v1\/code\/sessions\/([^/]+)\/execute$/);
+      if (req.method === 'POST' && route) {
+        if (!code) throw unavailable('code');
+        writeJson(res, 200, await code.execute(route[0], await readJson(req)));
+        return true;
+      }
+      route = match(url.pathname, /^\/v1\/code\/sessions\/([^/]+)\/events$/);
+      if (req.method === 'GET' && route) {
+        if (!code) throw unavailable('code');
+        writeJson(res, 200, await code.events(route[0], Number(url.searchParams.get('after') || 0)));
+        return true;
+      }
+      route = match(url.pathname, /^\/v1\/code\/sessions\/([^/]+)\/artifacts$/);
+      if (req.method === 'GET' && route) {
+        if (!code) throw unavailable('code');
+        writeJson(res, 200, { artifacts: await code.artifacts(route[0]) });
+        return true;
+      }
+      route = match(url.pathname, /^\/v1\/code\/sessions\/([^/]+)\/artifacts\/(.+)$/);
+      if (req.method === 'GET' && route) {
+        if (!code) throw unavailable('code');
+        const artifact = await code.artifact(route[0], route[1]);
+        res.writeHead(200, { 'Content-Type': 'application/octet-stream', 'Content-Length': artifact.length, 'Cache-Control': 'no-store' });
+        res.end(artifact);
+        return true;
+      }
+      route = match(url.pathname, /^\/v1\/code\/sessions\/([^/]+)\/stop$/);
+      if (req.method === 'POST' && route) {
+        if (!code) throw unavailable('code');
+        writeJson(res, 200, { session: await code.stop(route[0]) });
+        return true;
+      }
+      route = match(url.pathname, /^\/v1\/code\/sessions\/([^/]+)$/);
+      if (req.method === 'DELETE' && route) {
+        if (!code) throw unavailable('code');
+        writeJson(res, 200, { session: await code.burn(route[0]) });
+        return true;
+      }
+      if (req.method === 'POST' && url.pathname === '/v1/browser/sessions') {
+        if (!browser) throw unavailable('browser');
+        writeJson(res, 201, { session: await browser.create(await readJson(req)) });
+        return true;
+      }
+      route = match(url.pathname, /^\/v1\/browser\/sessions\/([^/]+)\/status$/);
+      if (req.method === 'GET' && route) {
+        if (!browser) throw unavailable('browser');
+        writeJson(res, 200, { session: await browser.status(route[0]) });
+        return true;
+      }
+      route = match(url.pathname, /^\/v1\/browser\/sessions\/([^/]+)\/connect$/);
+      if (req.method === 'POST' && route) {
+        if (!browser) throw unavailable('browser');
+        writeJson(res, 200, { session: await browser.connect(route[0]) });
+        return true;
+      }
+      route = match(url.pathname, /^\/v1\/browser\/sessions\/([^/]+)\/navigate$/);
+      if (req.method === 'POST' && route) {
+        if (!browser) throw unavailable('browser');
+        writeJson(res, 200, { session: await browser.navigate(route[0], await readJson(req)) });
+        return true;
+      }
+      route = match(url.pathname, /^\/v1\/browser\/sessions\/([^/]+)\/control$/);
+      if (req.method === 'POST' && route) {
+        if (!browser) throw unavailable('browser');
+        writeJson(res, 200, await browser.control(route[0], await readJson(req)));
+        return true;
+      }
+      route = match(url.pathname, /^\/v1\/browser\/sessions\/([^/]+)\/render$/);
+      if (req.method === 'GET' && route) {
+        if (!browser) throw unavailable('browser');
+        writeJson(res, 200, { render: await browser.render(route[0]) });
+        return true;
+      }
+      route = match(url.pathname, /^\/v1\/browser\/sessions\/([^/]+)$/);
+      if (req.method === 'DELETE' && route) {
+        if (!browser) throw unavailable('browser');
+        writeJson(res, 200, { session: await browser.burn(route[0]) });
+        return true;
+      }
+      writeJson(res, 404, { error: { code: 'not_found', message: 'platform route not found' } });
+      return true;
+    } catch (error) {
+      if (res.writableEnded || res.destroyed) return true;
+      const routed = routeError(error);
+      writeJson(res, routed.status, routed.body);
+      return true;
+    }
+  }
+
+  return Object.freeze({ handle });
+}

package/packages/inference-runtime/src/image.js

@@ -0,0 +1,186 @@
+import { createHmac, randomBytes } from 'node:crypto';
+
+export const ENIGMA_IMAGE_JOB_SCHEMA = 'enigma.image_job.v1';
+export const ENIGMA_IMAGE_RESULT_SCHEMA = 'enigma.image_result.v1';
+
+const FORMATS = new Set(['png', 'jpeg', 'webp']);
+const runtimeReferenceKey = randomBytes(32);
+
+function requiredString(value, field, maxLength = 16_000) {
+  if (typeof value !== 'string' || !value.trim()) throw new TypeError(`${field} must be a non-empty string`);
+  const normalized = value.trim();
+  if (normalized.length > maxLength) throw new TypeError(`${field} exceeds ${maxLength} characters`);
+  return normalized;
+}
+
+function boundedInteger(value, field, minimum, maximum, fallback) {
+  const candidate = value === undefined ? fallback : value;
+  if (!Number.isInteger(candidate) || candidate < minimum || candidate > maximum) {
+    throw new TypeError(`${field} must be an integer from ${minimum} to ${maximum}`);
+  }
+  return candidate;
+}
+
+function boundedNumber(value, field, minimum, maximum, fallback) {
+  const candidate = value === undefined ? fallback : value;
+  if (typeof candidate !== 'number' || !Number.isFinite(candidate) || candidate < minimum || candidate > maximum) {
+    throw new TypeError(`${field} must be a finite number from ${minimum} to ${maximum}`);
+  }
+  return candidate;
+}
+
+function promptReference(prompt) {
+  return createHmac('sha256', runtimeReferenceKey).update(prompt).digest('hex');
+}
+
+function normalizedAsset(asset, format) {
+  if (!asset || typeof asset !== 'object') throw new TypeError('image provider returned an invalid asset');
+  if (typeof asset.url === 'string') {
+    const url = new URL(asset.url);
+    if (url.protocol !== 'https:' && url.protocol !== 'data:') throw new TypeError('image asset URL must use HTTPS or data:');
+    return { url: url.toString(), format: asset.format || format };
+  }
+  if (typeof asset.base64 === 'string') {
+    if (asset.base64.length > 32 * 1024 * 1024) throw new TypeError('image asset exceeds the 24 MiB decoded limit');
+    return { base64: asset.base64, format: asset.format || format };
+  }
+  throw new TypeError('image provider asset requires url or base64');
+}
+
+export function normalizeImageRequest(input = {}) {
+  const prompt = requiredString(input.prompt, 'prompt');
+  const model = requiredString(input.model, 'model', 160);
+  const format = input.format === undefined ? 'webp' : String(input.format).toLowerCase();
+  if (!FORMATS.has(format)) throw new TypeError('format must be png, jpeg, or webp');
+  return {
+    prompt,
+    model,
+    negativePrompt: typeof input.negativePrompt === 'string' ? input.negativePrompt.slice(0, 8_000) : '',
+    width: boundedInteger(input.width, 'width', 256, 2_048, 1_024),
+    height: boundedInteger(input.height, 'height', 256, 2_048, 1_024),
+    steps: boundedInteger(input.steps, 'steps', 1, 100, 30),
+    cfgScale: boundedNumber(input.cfgScale, 'cfgScale', 1, 30, 7.5),
+    variants: boundedInteger(input.variants, 'variants', 1, 4, 1),
+    format,
+    seed: input.seed === undefined ? null : boundedInteger(input.seed, 'seed', 0, 2_147_483_647, 0),
+  };
+}
+
+export function createOpenAIImageProvider(options = {}) {
+  const id = requiredString(options.id || 'openai-images', 'provider id', 160);
+  const baseUrl = new URL(options.baseUrl || 'https://api.openai.com/v1/');
+  const models = new Set((options.models || []).map((model) => requiredString(model, 'model', 160)));
+  if (models.size === 0) throw new TypeError('OpenAI image provider requires at least one model');
+  const apiKey = requiredString(options.apiKey, 'apiKey', 4_096);
+  return Object.freeze({
+    id,
+    models: Object.freeze([...models]),
+    async generate(request, context = {}) {
+      if (!models.has(request.model)) throw new TypeError(`model ${request.model} is not configured for ${id}`);
+      const endpoint = new URL('images/generations', baseUrl);
+      const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          model: request.model,
+          prompt: request.negativePrompt ? `${request.prompt}\n\nAvoid: ${request.negativePrompt}` : request.prompt,
+          n: request.variants,
+          size: `${request.width}x${request.height}`,
+          response_format: 'b64_json',
+        }),
+        signal: context.signal,
+      });
+      const payload = await response.json();
+      if (!response.ok) throw new Error(`image provider ${id} failed with HTTP ${response.status}`);
+      if (!Array.isArray(payload.data)) throw new Error(`image provider ${id} returned no data array`);
+      return {
+        assets: payload.data.map((item) => item.b64_json
+          ? { base64: item.b64_json, format: request.format }
+          : { url: item.url, format: request.format }),
+        providerRequestId: response.headers.get('x-request-id') || null,
+      };
+    },
+  });
+}
+
+export function createImageBackend(options = {}) {
+  const providers = new Map();
+  for (const provider of options.providers || []) {
+    if (!provider || typeof provider.generate !== 'function') throw new TypeError('image provider requires generate()');
+    const id = requiredString(provider.id, 'provider id', 160);
+    if (providers.has(id)) throw new TypeError(`duplicate image provider: ${id}`);
+    const models = [...new Set((provider.models || []).map((model) => requiredString(model, 'model', 160)))];
+    if (models.length === 0) throw new TypeError(`image provider ${id} requires models`);
+    providers.set(id, Object.freeze({ ...provider, id, models: Object.freeze(models) }));
+  }
+  const modelRoutes = new Map();
+  for (const provider of providers.values()) {
+    for (const model of provider.models) {
+      if (modelRoutes.has(model)) throw new TypeError(`image model has multiple providers without an explicit router: ${model}`);
+      modelRoutes.set(model, provider);
+    }
+  }
+  const timeoutMs = boundedInteger(options.timeoutMs, 'timeoutMs', 1_000, 15 * 60_000, 120_000);
+
+  return Object.freeze({
+    listModels() {
+      return [...modelRoutes].map(([model, provider]) => ({ model, provider: provider.id, modality: 'image' }));
+    },
+    async quote(input) {
+      const request = normalizeImageRequest(input);
+      const provider = modelRoutes.get(request.model);
+      if (!provider) throw new Error(`no image provider configured for model ${request.model}`);
+      const quote = typeof provider.quote === 'function' ? await provider.quote(request) : null;
+      return {
+        schema: 'enigma.image_quote.v1',
+        model: request.model,
+        provider: provider.id,
+        variants: request.variants,
+        ...(quote && typeof quote === 'object' ? quote : { amount: null, asset: null }),
+      };
+    },
+    async generate(input = {}) {
+      const request = normalizeImageRequest(input);
+      const provider = modelRoutes.get(request.model);
+      if (!provider) throw new Error(`no image provider configured for model ${request.model}`);
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(new Error('image generation timed out')), timeoutMs);
+      const startedAt = Date.now();
+      try {
+        const generated = await provider.generate(request, { signal: controller.signal });
+        const assets = (generated?.assets || []).map((asset) => normalizedAsset(asset, request.format));
+        if (assets.length !== request.variants) {
+          throw new Error(`image provider ${provider.id} returned ${assets.length} assets; expected ${request.variants}`);
+        }
+        const result = {
+          schema: ENIGMA_IMAGE_RESULT_SCHEMA,
+          job: {
+            schema: ENIGMA_IMAGE_JOB_SCHEMA,
+            model: request.model,
+            provider: provider.id,
+            width: request.width,
+            height: request.height,
+            variants: request.variants,
+            format: request.format,
+            promptRef: promptReference(request.prompt),
+          },
+          assets,
+          durationMs: Date.now() - startedAt,
+          providerRequestId: generated?.providerRequestId || null,
+          retention: 'caller_controlled',
+        };
+        await options.onUsage?.({
+          modality: 'image',
+          provider: provider.id,
+          model: request.model,
+          units: assets.length,
+          durationMs: result.durationMs,
+          promptRef: result.job.promptRef,
+        });
+        return result;
+      } finally {
+        clearTimeout(timer);
+      }
+    },
+  });
+}

package/packages/inference-runtime/src/index.js

@@ -0,0 +1,10 @@
+export * from './contracts.js';
+export * from './privacy.js';
+export * from './model-router.js';
+export * from './chat.js';
+export * from './image.js';
+export * from './video.js';
+export * from './code.js';
+export * from './browser.js';
+export * from './http.js';
+export * from './platform.js';