@terminals-tech/sdk 1.0.0-rc.1 → 1.0.0

package/dist/chunk-XPJ63Y6T.js

@@ -0,0 +1,70 @@
+// ../../lib/terminals-tech/machines/core/adapters/embeddings.ts
+async function emb() {
+  return await import("./dist-OPDCWARF.js");
+}
+async function encodePoints(points, opts = {}) {
+  try {
+    const e = await emb();
+    if (e?.encode) {
+      const inputs = points.map((p) => [p.x, p.y, p.z, p.t || 0]);
+      const out = await e.encode(inputs, { model: opts.model || "default" });
+      if (out && typeof out === "object" && "vectors" in out) {
+        return out.vectors || out;
+      }
+      return out;
+    }
+  } catch {
+  }
+  const vectors = points.map((p) => {
+    const h = Math.sin(p.x * 0.1) + Math.cos(p.y * 0.13) + Math.sin(p.z * 0.07);
+    const base = [h, h * 0.5, -h];
+    return base;
+  });
+  return vectors;
+}
+async function encodeTextBatch(texts, opts = {}) {
+  if (typeof window !== "undefined") {
+    try {
+      const { embedText } = await import("./embeddings-7QXTXUMC.js");
+      return await Promise.all(texts.map((t) => embedText(t, opts.model)));
+    } catch (e) {
+      console.warn(
+        "Browser-side embedding failed. This may happen if modules are not found or WebGPU is unavailable. Fallback will be used.",
+        e
+      );
+    }
+  }
+  try {
+    const e = await emb();
+    if (e?.encodeText) {
+      const out = await e.encodeText(texts, { model: opts.model || "default" });
+      if (out && typeof out === "object" && "vectors" in out) {
+        const vectors = out.vectors;
+        return vectors ?? [];
+      }
+      return Array.isArray(out) ? out : [];
+    }
+  } catch (e) {
+    console.warn(
+      "@terminals-tech/embeddings failed. This is expected in a browser-only environment. Fallback will be used.",
+      e
+    );
+  }
+  console.log("Using fallback hashing for text embeddings.");
+  const toVec = (s) => {
+    let h1 = 0, h2 = 0, h3 = 0;
+    for (let i = 0; i < s.length; i++) {
+      const c = s.charCodeAt(i);
+      h1 = (h1 * 31 + c) % 997;
+      h2 = (h2 * 29 + c) % 991;
+      h3 = (h3 * 23 + c) % 983;
+    }
+    return [h1 / 997, h2 / 991, h3 / 983];
+  };
+  return texts.map(toVec);
+}
+
+export {
+  encodePoints,
+  encodeTextBatch
+};

package/dist/chunk-Y2EULKA2.js

@@ -0,0 +1,172 @@
+import {
+  robustJsonParse
+} from "./chunk-WGBCRNMB.js";
+import {
+  getDB
+} from "./chunk-AFDUOYHD.js";
+
+// ../../lib/terminals-tech/mesh/trace-path.ts
+var LTREE_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
+function isValidTracePath(path) {
+  return LTREE_PATTERN.test(path) && path.length <= 256;
+}
+function assertTracePath(path) {
+  if (!isValidTracePath(path)) {
+    throw new Error(`Invalid trace_path: "${path}"`);
+  }
+  return path;
+}
+
+// ../../lib/terminals-tech/mesh/pg-events.ts
+async function appendMeshEvent(tracePath, payload, embeddingOrOpts, span, metadata) {
+  assertTracePath(tracePath);
+  let embedding;
+  let interactionId;
+  let runId;
+  let stackId;
+  let userId;
+  if (Array.isArray(embeddingOrOpts) || embeddingOrOpts === void 0) {
+    embedding = embeddingOrOpts;
+  } else {
+    embedding = embeddingOrOpts.embedding;
+    span = embeddingOrOpts.span;
+    metadata = embeddingOrOpts.metadata;
+    interactionId = embeddingOrOpts.interactionId;
+    runId = embeddingOrOpts.runId;
+    stackId = embeddingOrOpts.stackId;
+    userId = embeddingOrOpts.userId;
+  }
+  const db = await getDB();
+  const prevResult = await db.query(
+    `SELECT id, md5(id::text || COALESCE(prev_hash, '') || payload::text) as hash FROM mesh_events ORDER BY created_at DESC LIMIT 1`
+  );
+  const prevHash = prevResult.rows[0]?.hash || "00000000000000000000000000000000";
+  const type = tracePath.split(".").pop() || "event";
+  const spanVal = span ? JSON.stringify(span) : null;
+  const result = await db.query(
+    `INSERT INTO mesh_events (
+       prev_hash,
+       trace_path,
+       type,
+       payload,
+       embedding,
+       span,
+       metadata,
+       interaction_id,
+       run_id,
+       stack_id,
+       user_id
+     ) VALUES ($1, $2::ltree, $3, $4, $5, $6::jsonb, $7, $8, $9, $10, $11)
+     RETURNING id, created_at;`,
+    [
+      prevHash,
+      tracePath,
+      type,
+      JSON.stringify(payload),
+      embedding ? `[${embedding.join(",")}]` : null,
+      spanVal,
+      metadata ? JSON.stringify(metadata) : null,
+      interactionId || null,
+      runId || null,
+      stackId || null,
+      userId || null
+    ]
+  );
+  const row = result.rows[0];
+  if (!row) {
+    throw new Error("Failed to insert mesh event");
+  }
+  return {
+    id: row.id,
+    type,
+    payload,
+    timestamp: new Date(row.created_at).getTime(),
+    embedding,
+    metadata,
+    prevHash,
+    tracePath,
+    span,
+    interactionId,
+    runId,
+    stackId,
+    userId
+  };
+}
+async function queryMeshEvents(pathQuery, limit = 100) {
+  const db = await getDB();
+  const result = await db.query(
+    `SELECT * FROM mesh_events 
+     WHERE trace_path ~ $1::lquery 
+     ORDER BY created_at DESC 
+     LIMIT $2`,
+    [pathQuery, limit]
+  );
+  return result.rows.map((row) => {
+    const eventRow = row;
+    return {
+      id: eventRow.id,
+      type: eventRow.type || eventRow.trace_path.split(".").pop() || "event",
+      payload: robustJsonParse(eventRow.payload),
+      timestamp: new Date(eventRow.created_at).getTime(),
+      embedding: eventRow.embedding ? JSON.parse(eventRow.embedding) : void 0,
+      metadata: eventRow.metadata ? robustJsonParse(eventRow.metadata) ?? void 0 : void 0,
+      prevHash: eventRow.prev_hash ?? void 0,
+      tracePath: eventRow.trace_path,
+      span: eventRow.span ? parseSpanJsonb(eventRow.span) : void 0,
+      interactionId: eventRow.interaction_id ?? void 0,
+      runId: eventRow.run_id ?? void 0,
+      stackId: eventRow.stack_id ?? void 0,
+      userId: eventRow.user_id ?? void 0
+    };
+  });
+}
+async function calculateTokenTrajectory(pathQuery, limit = 10) {
+  const db = await getDB();
+  const result = await db.query(
+    `SELECT embedding FROM mesh_events 
+     WHERE trace_path ~ $1::lquery AND embedding IS NOT NULL
+     ORDER BY created_at DESC 
+     LIMIT $2`,
+    [pathQuery, limit]
+  );
+  const vectors = result.rows.map((r) => JSON.parse(r.embedding)).reverse();
+  const distances = [];
+  for (let i = 1; i < vectors.length; i++) {
+    distances.push(cosineDistance(vectors[i - 1], vectors[i]));
+  }
+  return distances;
+}
+function parseSpanJsonb(spanVal) {
+  try {
+    if (typeof spanVal === "object" && Array.isArray(spanVal)) {
+      return [Number(spanVal[0]), Number(spanVal[1])];
+    }
+    const parsed = typeof spanVal === "string" ? JSON.parse(spanVal) : spanVal;
+    if (Array.isArray(parsed)) {
+      return [Number(parsed[0]), Number(parsed[1])];
+    }
+    if (typeof parsed === "string") {
+      const parts = parsed.replace(/[()]/g, "").split(",");
+      return [parseFloat(parts[0]), parseFloat(parts[1])];
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function cosineDistance(a, b) {
+  if (a.length !== b.length) return 0;
+  let dot = 0, magA = 0, magB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    magA += a[i] * a[i];
+    magB += b[i] * b[i];
+  }
+  return 1 - dot / (Math.sqrt(magA) * Math.sqrt(magB));
+}
+
+export {
+  appendMeshEvent,
+  queryMeshEvents,
+  calculateTokenTrajectory
+};

package/dist/chunk-YJEZWCYV.js

@@ -0,0 +1,94 @@
+import {
+  isNetworkAllowed,
+  requireNetworkApproval
+} from "./chunk-UJDUQNE2.js";
+
+// ../../lib/terminals-tech/machines/core/runners/container-lite-shared.ts
+import path from "path";
+var DEFAULT_CONTAINER_LITE_TIMEOUT_MS = 12e4;
+var DEFAULT_CONTAINER_LITE_IMAGE = "python:3.11-slim";
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function asStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function extractUrls(input) {
+  const urls = [];
+  const extract = (value) => {
+    if (typeof value === "string") {
+      try {
+        const url = new URL(value);
+        if (url.protocol === "http:" || url.protocol === "https:") {
+          urls.push(value);
+        }
+      } catch {
+        return;
+      }
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach(extract);
+      return;
+    }
+    if (isRecord(value)) {
+      Object.values(value).forEach(extract);
+    }
+  };
+  extract(input);
+  return urls;
+}
+async function validateContainerLiteNetworkPolicy(urls, ctx) {
+  for (const url of urls) {
+    const allowed = isNetworkAllowed(ctx.policies, url) || await requireNetworkApproval(ctx.stackId, ctx.nodeId, ctx.policies, url);
+    if (!allowed) {
+      return { allowed: false, deniedUrl: url };
+    }
+  }
+  return { allowed: true };
+}
+function flattenFilesystemTree(tree, prefix = "") {
+  if (typeof tree === "string") {
+    return prefix ? [{ path: prefix, content: tree }] : [];
+  }
+  if (!isRecord(tree)) {
+    return [];
+  }
+  if ("file" in tree && isRecord(tree.file) && typeof tree.file.contents === "string" && prefix) {
+    return [{ path: prefix, content: tree.file.contents }];
+  }
+  const writes = [];
+  for (const [name, value] of Object.entries(tree)) {
+    const nextPath = prefix ? path.posix.join(prefix, name) : name;
+    writes.push(...flattenFilesystemTree(value, nextPath));
+  }
+  return writes;
+}
+function buildContainerLiteCommand(command, args, env) {
+  const envPrefix = Object.entries(env).map(([key, value]) => `${key}=${shellQuote(value)}`).join(" ");
+  const commandWithArgs = [shellQuote(command), ...args.map((arg) => shellQuote(arg))].join(" ");
+  return envPrefix ? `${envPrefix} ${commandWithArgs}` : commandWithArgs;
+}
+function resolveContainerLiteCwd(workdir, requestedCwd) {
+  if (!requestedCwd) {
+    return workdir;
+  }
+  return requestedCwd.startsWith("/") ? requestedCwd : path.posix.join(workdir, requestedCwd);
+}
+
+export {
+  DEFAULT_CONTAINER_LITE_TIMEOUT_MS,
+  DEFAULT_CONTAINER_LITE_IMAGE,
+  shellQuote,
+  asStringArray,
+  isRecord,
+  extractUrls,
+  validateContainerLiteNetworkPolicy,
+  flattenFilesystemTree,
+  buildContainerLiteCommand,
+  resolveContainerLiteCwd
+};

package/dist/chunk-ZVO47SQV.js

@@ -0,0 +1,150 @@
+// ../../lib/terminals-tech/core/ai/embeddings.ts
+var DEFAULT_EMBEDDING_MODEL = "Xenova/all-MiniLM-L6-v2";
+var DEFAULT_EMBEDDING_DIM = 384;
+var embedderPromise = null;
+var workerHandle = null;
+var workerInitPromise = null;
+var reqCounter = 0;
+async function getEmbeddingsWorker() {
+  try {
+    if (typeof window === "undefined") return null;
+    if (workerHandle) return workerHandle;
+    const w = new Worker("/workers/embeddings-worker.js", {
+      type: "classic",
+      name: "embeddings-worker"
+    });
+    workerHandle = w;
+    return w;
+  } catch {
+    return null;
+  }
+}
+async function getEmbedder(modelName = DEFAULT_EMBEDDING_MODEL) {
+  if (typeof window === "undefined") {
+    throw new Error("embedText is only available in the browser environment");
+  }
+  const w = await getEmbeddingsWorker();
+  if (w && !workerInitPromise) {
+    workerInitPromise = (async () => {
+      try {
+        const { getDefaultOnnxExecutionProviders } = await import("./capabilities-MIPUMBLL.js");
+        const providers = await getDefaultOnnxExecutionProviders();
+        await new Promise((resolve, reject) => {
+          const onMsg = (ev) => {
+            if (ev.data && ev.data.type === "inited") {
+              w.removeEventListener("message", onMsg);
+              if (ev.data.ok) resolve();
+              else reject(new Error(ev.data.error || "worker init failed"));
+            }
+          };
+          w.addEventListener("message", onMsg);
+          w.postMessage({
+            type: "init",
+            model: modelName,
+            execProviders: providers.length ? providers : ["wasm"]
+          });
+        });
+        return true;
+      } catch {
+        return false;
+      }
+    })();
+  }
+  if (w && workerInitPromise) {
+    const ok = await workerInitPromise;
+    if (ok) return null;
+  }
+  if (!embedderPromise) {
+    const { getDefaultOnnxExecutionProviders } = await import("./capabilities-MIPUMBLL.js");
+    const { pipeline, env } = await import("@xenova/transformers");
+    env.allowRemoteModels = true;
+    env.allowLocalModels = false;
+    const providers = await getDefaultOnnxExecutionProviders();
+    env.backends.onnx.executionProviders = providers.length ? providers : ["wasm"];
+    try {
+      embedderPromise = pipeline("feature-extraction", modelName, {
+        quantized: true
+      });
+    } catch (e) {
+      try {
+        env.backends.onnx.executionProviders = ["wasm"];
+        embedderPromise = pipeline("feature-extraction", modelName, {
+          quantized: true
+        });
+      } catch (e2) {
+        throw e2;
+      }
+    }
+  }
+  return embedderPromise;
+}
+async function embedText(text, modelName) {
+  const extractor = await getEmbedder(modelName);
+  if (!extractor) {
+    const w = await getEmbeddingsWorker();
+    if (!w) throw new Error("Embeddings worker unavailable");
+    const id = ++reqCounter;
+    return await new Promise((resolve, reject) => {
+      const onMsg = (ev) => {
+        const d = ev.data;
+        if (!d || d.id !== id) return;
+        w.removeEventListener("message", onMsg);
+        if (d.ok) {
+          const arr = d.data instanceof Float32Array ? Array.from(d.data) : Array.isArray(d.data) ? d.data : [];
+          resolve(arr);
+        } else {
+          reject(new Error(d.error || "embed failed"));
+        }
+      };
+      w.addEventListener("message", onMsg);
+      w.postMessage({ type: "embed", id, text });
+    });
+  }
+  const output = await extractor(text, { pooling: "mean", normalize: true });
+  const data = output && output.data ? output.data : output;
+  return Array.from(data);
+}
+async function prewarmEmbeddingsWorker(modelName = DEFAULT_EMBEDDING_MODEL, mode = "worker-only") {
+  if (typeof window === "undefined") return false;
+  const w = await getEmbeddingsWorker();
+  if (!w) return false;
+  if (mode === "worker-only") return true;
+  if (!workerInitPromise) {
+    workerInitPromise = (async () => {
+      try {
+        const { getDefaultOnnxExecutionProviders } = await import("./capabilities-MIPUMBLL.js");
+        const providers = await getDefaultOnnxExecutionProviders();
+        await new Promise((resolve, reject) => {
+          const onMsg = (ev) => {
+            if (ev.data && ev.data.type === "inited") {
+              w.removeEventListener("message", onMsg);
+              if (ev.data.ok) resolve();
+              else reject(new Error(ev.data.error || "worker init failed"));
+            }
+          };
+          w.addEventListener("message", onMsg);
+          w.postMessage({
+            type: "init",
+            model: modelName,
+            execProviders: providers.length ? providers : ["wasm"]
+          });
+        });
+        return true;
+      } catch {
+        return false;
+      }
+    })();
+  }
+  return workerInitPromise.then(Boolean).catch(() => false);
+}
+function getEmbeddingDimension() {
+  return DEFAULT_EMBEDDING_DIM;
+}
+
+export {
+  DEFAULT_EMBEDDING_MODEL,
+  DEFAULT_EMBEDDING_DIM,
+  embedText,
+  prewarmEmbeddingsWorker,
+  getEmbeddingDimension
+};