@workglow/cactus 0.3.2

package/dist/ai-runtime.browser.js

@@ -0,0 +1,603 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/ai/common/Cactus_Constants.ts
+var LOCAL_CACTUS = "LOCAL_CACTUS";
+var CACTUS_NEEDLE_26M = "needle-26m";
+var CACTUS_DEFAULT_HF_REPO = "Abdalrahman/needle-rs-safetensors";
+var CACTUS_DEFAULT_REVISION = "main";
+var CACTUS_CACHE_NAME = "cactus-models-v1";
+var CACTUS_DEFAULT_MODELS_DIR = "~/.cache/cactus-models";
+
+// src/ai/common/Cactus_ModelCatalog.ts
+var CACTUS_CATALOG = [
+  {
+    model_id: CACTUS_NEEDLE_26M,
+    title: "Needle 26M",
+    description: "Specialized 26M-parameter tool-routing transformer. INT4 SafeTensors, 22 MB. Runs via WASM in browser and Node/Bun.",
+    hf_repo: CACTUS_DEFAULT_HF_REPO,
+    revision: CACTUS_DEFAULT_REVISION,
+    assets: {
+      weights: "needle.safetensors",
+      vocab: "vocab.txt",
+      config: "config.json"
+    },
+    capabilities: ["tool-use"]
+  }
+];
+function getCactusCatalogEntry(model_id) {
+  return CACTUS_CATALOG.find((e) => e.model_id === model_id);
+}
+function cactusAssetUrl(entry, filename) {
+  return `https://huggingface.co/${entry.hf_repo}/resolve/${entry.revision}/${filename}`;
+}
+
+// src/ai/common/Cactus_Runtime.browser.ts
+var _sdk;
+var _sdkInitPromise;
+async function loadSdk() {
+  _sdkInitPromise ??= import("needle-rs").then(async (mod) => {
+    const init = mod.default;
+    if (typeof init === "function") {
+      await init();
+    }
+    _sdk = mod;
+    return mod;
+  }).catch((err) => {
+    _sdkInitPromise = undefined;
+    _sdk = undefined;
+    throw new Error(`needle-rs is required for LOCAL_CACTUS tasks. Install it with: bun add needle-rs (cause: ${String(err)})`);
+  });
+  return _sdkInitPromise;
+}
+function getCactusSdk() {
+  if (!_sdk)
+    throw new Error("Cactus SDK not loaded; call loadSdk() first");
+  return _sdk;
+}
+async function fetchAssetBytesBrowser(url) {
+  const cachesApi = globalThis.caches;
+  const cache = await cachesApi.open(CACTUS_CACHE_NAME);
+  const hit = await cache.match(url);
+  if (hit) {
+    return new Uint8Array(await hit.arrayBuffer());
+  }
+  const resp = await fetch(url);
+  if (!resp.ok)
+    throw new Error(`Cactus asset fetch failed (${resp.status}) for ${url}`);
+  await cache.put(url, resp.clone());
+  return new Uint8Array(await resp.arrayBuffer());
+}
+async function fetchAssetBytes(model, filename) {
+  const model_id = model.provider_config.model_id;
+  const entry = getCactusCatalogEntry(model_id);
+  if (!entry)
+    throw new Error(`Unknown Cactus model_id: ${model_id}`);
+  const url = cactusAssetUrl(entry, filename);
+  return fetchAssetBytesBrowser(url);
+}
+var cactusEngines = new Map;
+var cactusConfigJson = new Map;
+var cactusCachedModelIds = new Set;
+var cactusEngineLoadsInFlight = new Map;
+async function getOrLoadEngine(model) {
+  const model_id = model.provider_config.model_id;
+  const cached = cactusEngines.get(model_id);
+  if (cached)
+    return cached;
+  const inFlight = cactusEngineLoadsInFlight.get(model_id);
+  if (inFlight)
+    return inFlight;
+  const loadPromise = (async () => {
+    const sdk = await loadSdk();
+    const entry = getCactusCatalogEntry(model_id);
+    if (!entry)
+      throw new Error(`Unknown Cactus model_id: ${model_id}`);
+    const [weightsBytes, vocabBytes, configBytes] = await Promise.all([
+      fetchAssetBytes(model, entry.assets.weights),
+      fetchAssetBytes(model, entry.assets.vocab),
+      fetchAssetBytes(model, entry.assets.config)
+    ]);
+    try {
+      const text = new TextDecoder().decode(configBytes);
+      cactusConfigJson.set(model_id, JSON.parse(text));
+    } catch {
+      cactusConfigJson.set(model_id, null);
+    }
+    const vocabText = new TextDecoder().decode(vocabBytes);
+    const engine = sdk.NeedleWasm.load(weightsBytes, vocabText);
+    if (!engine) {
+      throw new Error(`needle-rs NeedleWasm.load returned undefined for model ${model_id}`);
+    }
+    cactusEngines.set(model_id, engine);
+    return engine;
+  })().finally(() => {
+    cactusEngineLoadsInFlight.delete(model_id);
+  });
+  cactusEngineLoadsInFlight.set(model_id, loadPromise);
+  return loadPromise;
+}
+function isModelLoaded(model_id) {
+  return cactusEngines.has(model_id);
+}
+function markModelCached(model_id) {
+  cactusCachedModelIds.add(model_id);
+}
+function isModelCached(model_id) {
+  return cactusEngines.has(model_id) || cactusCachedModelIds.has(model_id);
+}
+var cactusSessions = new Map;
+async function deleteCactusSession(id) {
+  return cactusSessions.delete(id);
+}
+async function removeBrowserCacheEntries(entry) {
+  const cachesApi = globalThis.caches;
+  const cache = await cachesApi.open(CACTUS_CACHE_NAME);
+  for (const filename of [entry.assets.weights, entry.assets.vocab, entry.assets.config]) {
+    const url = cactusAssetUrl(entry, filename);
+    try {
+      await cache.delete(url);
+    } catch {}
+  }
+}
+function disposeCactusEngine(model_id) {
+  const engine = cactusEngines.get(model_id);
+  if (engine) {
+    try {
+      engine.free?.();
+    } catch {}
+  }
+  cactusEngines.delete(model_id);
+  cactusConfigJson.delete(model_id);
+  cactusCachedModelIds.delete(model_id);
+}
+async function removeCachedAssets(model) {
+  const model_id = model.provider_config.model_id;
+  const entry = getCactusCatalogEntry(model_id);
+  if (!entry)
+    return;
+  await removeBrowserCacheEntries(entry);
+  disposeCactusEngine(model_id);
+}
+async function disposeCactusResources() {
+  for (const id of Array.from(cactusEngines.keys())) {
+    disposeCactusEngine(id);
+  }
+  cactusEngines.clear();
+  cactusConfigJson.clear();
+  cactusCachedModelIds.clear();
+  cactusSessions.clear();
+}
+
+// src/ai/registerCactusInline.ts
+import { registerProviderInline } from "@workglow/ai/provider-utils";
+
+// src/ai/CactusQueuedProvider.ts
+import { QueuedAiProvider } from "@workglow/ai";
+
+// src/ai/common/Cactus_CapabilitySets.ts
+var CACTUS_TOOL_USE = ["tool-use"];
+var CACTUS_MODEL_DOWNLOAD = ["model.download"];
+var CACTUS_MODEL_DOWNLOAD_REMOVE = [
+  "model.download-remove"
+];
+var CACTUS_MODEL_SEARCH = ["model.search"];
+var CACTUS_MODEL_INFO = ["model.info"];
+var CACTUS_CAPABILITY_SETS = [
+  CACTUS_TOOL_USE,
+  CACTUS_MODEL_DOWNLOAD,
+  CACTUS_MODEL_DOWNLOAD_REMOVE,
+  CACTUS_MODEL_SEARCH,
+  CACTUS_MODEL_INFO
+];
+
+// src/ai/common/Cactus_Capabilities.ts
+var CACTUS_RUN_FN_SPECS = CACTUS_CAPABILITY_SETS.map((serves) => ({ serves }));
+function cactusWorkerRunFnSpecs() {
+  return CACTUS_RUN_FN_SPECS;
+}
+function inferCactusCapabilities(_model) {
+  return ["tool-use", "model.download", "model.download-remove", "model.search", "model.info"];
+}
+
+// src/ai/common/Cactus_Runtime.ts
+var _sdk2;
+var _sdkInitPromise2;
+async function loadSdk2() {
+  _sdkInitPromise2 ??= import("needle-rs").then(async (mod) => {
+    const init = mod.default;
+    if (typeof init === "function") {
+      await init();
+    }
+    _sdk2 = mod;
+    return mod;
+  }).catch((err) => {
+    _sdkInitPromise2 = undefined;
+    _sdk2 = undefined;
+    throw new Error(`needle-rs is required for LOCAL_CACTUS tasks. Install it with: bun add needle-rs (cause: ${String(err)})`);
+  });
+  return _sdkInitPromise2;
+}
+function hasBrowserCacheStorage() {
+  return typeof globalThis !== "undefined" && "caches" in globalThis && typeof globalThis.caches?.open === "function";
+}
+function modelsDirOf(model) {
+  return model.provider_config.models_dir ?? CACTUS_DEFAULT_MODELS_DIR;
+}
+async function fetchAssetBytesBrowser2(url) {
+  const cachesApi = globalThis.caches;
+  const cache = await cachesApi.open(CACTUS_CACHE_NAME);
+  const hit = await cache.match(url);
+  if (hit) {
+    return new Uint8Array(await hit.arrayBuffer());
+  }
+  const resp = await fetch(url);
+  if (!resp.ok)
+    throw new Error(`Cactus asset fetch failed (${resp.status}) for ${url}`);
+  await cache.put(url, resp.clone());
+  return new Uint8Array(await resp.arrayBuffer());
+}
+async function fetchAssetBytesNode(url, models_dir, model_id, filename) {
+  const fs = await import("node:fs/promises");
+  const path = await import("node:path");
+  const resolvedDir = models_dir.startsWith("~/") ? path.join(process.env.HOME ?? process.env.USERPROFILE ?? ".", models_dir.slice(2), model_id) : path.resolve(models_dir, model_id);
+  const filePath = path.join(resolvedDir, filename);
+  try {
+    const buf = await fs.readFile(filePath);
+    return new Uint8Array(buf);
+  } catch {}
+  const resp = await fetch(url);
+  if (!resp.ok)
+    throw new Error(`Cactus asset fetch failed (${resp.status}) for ${url}`);
+  const bytes = new Uint8Array(await resp.arrayBuffer());
+  await fs.mkdir(resolvedDir, { recursive: true });
+  const tmpPath = `${filePath}.tmp`;
+  await fs.writeFile(tmpPath, bytes);
+  await fs.rename(tmpPath, filePath);
+  return bytes;
+}
+async function fetchAssetBytes2(model, filename) {
+  const model_id = model.provider_config.model_id;
+  const entry = getCactusCatalogEntry(model_id);
+  if (!entry)
+    throw new Error(`Unknown Cactus model_id: ${model_id}`);
+  const url = cactusAssetUrl(entry, filename);
+  if (hasBrowserCacheStorage()) {
+    return fetchAssetBytesBrowser2(url);
+  }
+  return fetchAssetBytesNode(url, modelsDirOf(model), model_id, filename);
+}
+var cactusEngines2 = new Map;
+var cactusConfigJson2 = new Map;
+var cactusCachedModelIds2 = new Set;
+var cactusEngineLoadsInFlight2 = new Map;
+async function getOrLoadEngine2(model) {
+  const model_id = model.provider_config.model_id;
+  const cached = cactusEngines2.get(model_id);
+  if (cached)
+    return cached;
+  const inFlight = cactusEngineLoadsInFlight2.get(model_id);
+  if (inFlight)
+    return inFlight;
+  const loadPromise = (async () => {
+    const sdk = await loadSdk2();
+    const entry = getCactusCatalogEntry(model_id);
+    if (!entry)
+      throw new Error(`Unknown Cactus model_id: ${model_id}`);
+    const [weightsBytes, vocabBytes, configBytes] = await Promise.all([
+      fetchAssetBytes2(model, entry.assets.weights),
+      fetchAssetBytes2(model, entry.assets.vocab),
+      fetchAssetBytes2(model, entry.assets.config)
+    ]);
+    try {
+      const text = new TextDecoder().decode(configBytes);
+      cactusConfigJson2.set(model_id, JSON.parse(text));
+    } catch {
+      cactusConfigJson2.set(model_id, null);
+    }
+    const vocabText = new TextDecoder().decode(vocabBytes);
+    const engine = sdk.NeedleWasm.load(weightsBytes, vocabText);
+    if (!engine) {
+      throw new Error(`needle-rs NeedleWasm.load returned undefined for model ${model_id}`);
+    }
+    cactusEngines2.set(model_id, engine);
+    return engine;
+  })().finally(() => {
+    cactusEngineLoadsInFlight2.delete(model_id);
+  });
+  cactusEngineLoadsInFlight2.set(model_id, loadPromise);
+  return loadPromise;
+}
+function isModelLoaded2(model_id) {
+  return cactusEngines2.has(model_id);
+}
+function markModelCached2(model_id) {
+  cactusCachedModelIds2.add(model_id);
+}
+function isModelCached2(model_id) {
+  return cactusEngines2.has(model_id) || cactusCachedModelIds2.has(model_id);
+}
+var cactusSessions2 = new Map;
+async function deleteCactusSession2(id) {
+  return cactusSessions2.delete(id);
+}
+async function removeBrowserCacheEntries2(entry) {
+  if (!hasBrowserCacheStorage())
+    return;
+  const cachesApi = globalThis.caches;
+  const cache = await cachesApi.open(CACTUS_CACHE_NAME);
+  for (const filename of [entry.assets.weights, entry.assets.vocab, entry.assets.config]) {
+    const url = cactusAssetUrl(entry, filename);
+    try {
+      await cache.delete(url);
+    } catch {}
+  }
+}
+async function removeNodeCacheDir(model, model_id) {
+  if (hasBrowserCacheStorage())
+    return;
+  const fs = await import("node:fs/promises");
+  const path = await import("node:path");
+  const models_dir = modelsDirOf(model);
+  const resolvedDir = models_dir.startsWith("~/") ? path.join(process.env.HOME ?? process.env.USERPROFILE ?? ".", models_dir.slice(2), model_id) : path.resolve(models_dir, model_id);
+  await fs.rm(resolvedDir, { recursive: true, force: true });
+}
+function disposeCactusEngine2(model_id) {
+  const engine = cactusEngines2.get(model_id);
+  if (engine) {
+    try {
+      engine.free?.();
+    } catch {}
+  }
+  cactusEngines2.delete(model_id);
+  cactusConfigJson2.delete(model_id);
+  cactusCachedModelIds2.delete(model_id);
+}
+async function removeCachedAssets2(model) {
+  const model_id = model.provider_config.model_id;
+  const entry = getCactusCatalogEntry(model_id);
+  if (!entry)
+    return;
+  await Promise.all([removeBrowserCacheEntries2(entry), removeNodeCacheDir(model, model_id)]);
+  disposeCactusEngine2(model_id);
+}
+
+// src/ai/CactusQueuedProvider.ts
+class CactusQueuedProvider extends QueuedAiProvider {
+  name = LOCAL_CACTUS;
+  displayName = "Cactus (Needle)";
+  isLocal = true;
+  supportsBrowser = true;
+  constructor(promiseRunFns, previewTasks) {
+    super(promiseRunFns, previewTasks);
+  }
+  inferCapabilities(model) {
+    return inferCactusCapabilities(model);
+  }
+  workerRunFnSpecs() {
+    return cactusWorkerRunFnSpecs();
+  }
+  createSession(_model) {
+    return crypto.randomUUID();
+  }
+  async disposeSession(sessionId) {
+    await deleteCactusSession2(sessionId);
+  }
+}
+
+// src/ai/common/Cactus_Download.ts
+var Cactus_Download = async (input, model, _signal, emit) => {
+  if (!model)
+    throw new Error("Model config is required for ModelDownloadTask.");
+  const model_id = model.provider_config.model_id;
+  const entry = getCactusCatalogEntry(model_id);
+  if (!entry)
+    throw new Error(`Unknown Cactus model_id: ${model_id}`);
+  const assets = [entry.assets.weights, entry.assets.vocab, entry.assets.config];
+  for (let i = 0;i < assets.length; i++) {
+    emit({
+      type: "phase",
+      message: `Downloading ${assets[i]}`,
+      progress: Math.round((i + 0.5) / assets.length * 99)
+    });
+    await fetchAssetBytes2(model, assets[i]);
+  }
+  markModelCached2(model_id);
+  emit({ type: "finish", data: { model: input.model } });
+};
+
+// src/ai/common/Cactus_DownloadRemove.ts
+var Cactus_DownloadRemove = async (input, model, _signal, emit) => {
+  if (!model)
+    throw new Error("Model config is required for ModelDownloadRemoveTask.");
+  await removeCachedAssets2(model);
+  emit({ type: "finish", data: { model: input.model } });
+};
+
+// src/ai/common/Cactus_ModelInfo.ts
+var Cactus_ModelInfo = async (input, model, _signal, emit) => {
+  if (!model)
+    throw new Error("Model config is required for ModelInfoTask.");
+  const model_id = model.provider_config.model_id;
+  const entry = getCactusCatalogEntry(model_id);
+  if (!entry)
+    throw new Error(`Unknown Cactus model_id: ${model_id}`);
+  const is_loaded = isModelLoaded2(model_id);
+  const is_cached = isModelCached2(model_id);
+  emit({
+    type: "finish",
+    data: {
+      model: input.model,
+      is_local: true,
+      is_remote: false,
+      supports_browser: true,
+      supports_node: true,
+      is_cached,
+      is_loaded,
+      file_sizes: null
+    }
+  });
+};
+
+// src/ai/common/Cactus_ModelSearch.ts
+var Cactus_ModelSearch = async (input, _model, _signal, emit) => {
+  const query = (input.query ?? "").trim().toLowerCase();
+  const results = CACTUS_CATALOG.filter((e) => !query || e.model_id.toLowerCase().includes(query) || e.title.toLowerCase().includes(query)).map((e) => ({
+    id: e.model_id,
+    label: e.title,
+    description: e.description,
+    record: {
+      model_id: e.model_id,
+      title: e.title,
+      description: e.description,
+      provider: LOCAL_CACTUS,
+      provider_config: { model_id: e.model_id },
+      capabilities: [...e.capabilities],
+      metadata: {}
+    },
+    raw: e
+  }));
+  emit({ type: "finish", data: { results } });
+};
+
+// src/ai/common/Cactus_ToolCalling.ts
+import { extractMessageText } from "@workglow/ai/provider-utils";
+import { filterValidToolCalls } from "@workglow/ai/worker";
+function buildToolsJson(tools) {
+  return JSON.stringify(tools.map((t) => ({
+    name: t.name,
+    ...t.description ? { description: t.description } : {},
+    ...t.inputSchema ? { parameters: t.inputSchema } : {}
+  })));
+}
+function promptText(input) {
+  if (typeof input.prompt === "string")
+    return input.prompt;
+  if (input.prompt)
+    return extractMessageText(input.prompt);
+  if (input.messages && input.messages.length > 0) {
+    const last = input.messages[input.messages.length - 1];
+    return extractMessageText(last.content);
+  }
+  return "";
+}
+function parseToolCalls(raw) {
+  if (!raw)
+    return [];
+  try {
+    const obj = JSON.parse(raw);
+    if (Array.isArray(obj)) {
+      return obj.map((o, i) => ({
+        id: `call_${i}`,
+        name: String(o.name ?? ""),
+        input: o.arguments ?? o.params ?? {}
+      }));
+    }
+    if (obj && typeof obj === "object" && typeof obj.name === "string") {
+      return [
+        {
+          id: "call_0",
+          name: obj.name,
+          input: obj.arguments ?? obj.params ?? {}
+        }
+      ];
+    }
+  } catch {}
+  return [];
+}
+var Cactus_ToolCalling = async (input, model, signal, emit) => {
+  if (!model)
+    throw new Error("Model config is required for ToolCallingTask.");
+  if (signal.aborted)
+    throw signal.reason ?? new Error("The operation was aborted");
+  const engine = await getOrLoadEngine2(model);
+  const query = promptText(input);
+  const toolsJson = buildToolsJson(input.tools);
+  let raw = "";
+  const engineWithStream = engine;
+  if (typeof engineWithStream.run_stream === "function") {
+    raw = await engineWithStream.run_stream(query, toolsJson, (chunk) => {
+      emit({ type: "text-delta", port: "text", textDelta: chunk });
+    });
+  } else {
+    const out = await engineWithStream.run(query, toolsJson);
+    raw = typeof out === "string" ? out : String(out);
+  }
+  const parsed = parseToolCalls(raw);
+  const validToolCalls = filterValidToolCalls(parsed, input.tools);
+  if (validToolCalls.length > 0) {
+    emit({ type: "object-delta", port: "toolCalls", objectDelta: [...validToolCalls] });
+  }
+  emit({ type: "finish", data: { text: raw, toolCalls: validToolCalls } });
+};
+
+// src/ai/common/Cactus_JobRunFns.ts
+var CACTUS_RUN_FNS = [
+  { serves: CACTUS_TOOL_USE, runFn: Cactus_ToolCalling },
+  { serves: CACTUS_MODEL_DOWNLOAD, runFn: Cactus_Download },
+  { serves: CACTUS_MODEL_DOWNLOAD_REMOVE, runFn: Cactus_DownloadRemove },
+  { serves: CACTUS_MODEL_SEARCH, runFn: Cactus_ModelSearch },
+  { serves: CACTUS_MODEL_INFO, runFn: Cactus_ModelInfo }
+];
+var CACTUS_PREVIEW_TASKS = {};
+
+// src/ai/registerCactusInline.ts
+async function registerCactusInline(options) {
+  await registerProviderInline(new CactusQueuedProvider(CACTUS_RUN_FNS, CACTUS_PREVIEW_TASKS), "Cactus", options);
+}
+
+// src/ai/registerCactusWorker.ts
+import { registerProviderWorker } from "@workglow/ai/provider-utils";
+
+// src/ai/CactusProvider.ts
+import { AiProvider } from "@workglow/ai/worker";
+class CactusProvider extends AiProvider {
+  name = LOCAL_CACTUS;
+  displayName = "Cactus (Needle)";
+  isLocal = true;
+  supportsBrowser = true;
+  constructor(promiseRunFns, previewTasks) {
+    super(promiseRunFns, previewTasks);
+  }
+  inferCapabilities(model) {
+    return inferCactusCapabilities(model);
+  }
+  workerRunFnSpecs() {
+    return cactusWorkerRunFnSpecs();
+  }
+  createSession(_model) {
+    return crypto.randomUUID();
+  }
+  async disposeSession(sessionId) {
+    await deleteCactusSession2(sessionId);
+  }
+}
+
+// src/ai/registerCactusWorker.ts
+async function registerCactusWorker() {
+  await registerProviderWorker((ws) => new CactusProvider(CACTUS_RUN_FNS, CACTUS_PREVIEW_TASKS).registerOnWorkerServer(ws), "Cactus");
+}
+export {
+  removeCachedAssets,
+  registerCactusWorker,
+  registerCactusInline,
+  markModelCached,
+  loadSdk,
+  isModelLoaded,
+  isModelCached,
+  getOrLoadEngine,
+  getCactusSdk,
+  fetchAssetBytes,
+  disposeCactusResources,
+  deleteCactusSession,
+  cactusSessions,
+  cactusEngines,
+  cactusConfigJson
+};
+
+//# debugId=883F60C21D152DBF64756E2164756E21