@workglow/ai-provider 0.0.121 → 0.0.123

package/dist/provider-llamacpp/index.js

@@ -1,741 +1,137 @@
-import {
-  LLAMACPP_DEFAULT_MODELS_DIR,
-  LOCAL_LLAMACPP,
-  LlamaCppModelConfigSchema,
-  LlamaCppModelRecordSchema,
-  LlamaCppModelSchema,
-  LlamaCppProvider
-} from "../index-wr57rwyx.js";
-import {
-  __require
-} from "../index-6j5pq722.js";
-// src/provider-llamacpp/common/LlamaCpp_JobRunFns.ts
-import { filterValidToolCalls } from "@workglow/ai";
-import { getLogger, parsePartialJson } from "@workglow/util";
-var _sdk;
-async function loadSdk() {
-  if (!_sdk) {
-    try {
-      _sdk = await import("node-llama-cpp");
-    } catch (err) {
-      throw new Error("node-llama-cpp is required for LOCAL_LLAMACPP tasks. Install it with: bun add node-llama-cpp");
-    }
-  }
-  return _sdk;
-}
-var llamaInstance;
-var models = new Map;
-var textContexts = new Map;
-var embeddingContexts = new Map;
-var resolvedPaths = new Map;
-async function getLlamaInstance() {
-  if (!llamaInstance) {
-    const { getLlama } = await loadSdk();
-    llamaInstance = await getLlama();
-  }
-  return llamaInstance;
-}
-function getConfigKey(model) {
-  return model.provider_config.model_url ?? model.provider_config.model_path;
-}
-function getActualModelPath(model) {
-  const key = getConfigKey(model);
-  const resolved = resolvedPaths.get(key);
-  return resolved ?? model.provider_config.model_path;
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
 }
-async function getOrLoadModel(model) {
-  const modelPath = getActualModelPath(model);
-  const cached = models.get(modelPath);
-  if (cached)
-    return cached;
-  const llama = await getLlamaInstance();
-  const config = model.provider_config;
-  const loadedModel = await llama.loadModel({
-    modelPath,
-    ...config.gpu_layers !== undefined && { gpuLayers: config.gpu_layers }
-  });
-  models.set(modelPath, loadedModel);
-  return loadedModel;
-}
-async function getOrCreateTextContext(model) {
-  const modelPath = getActualModelPath(model);
-  const cached = textContexts.get(modelPath);
-  if (cached)
-    return cached;
-  const loadedModel = await getOrLoadModel(model);
-  const config = model.provider_config;
-  const context = await loadedModel.createContext({
-    ...config.context_size && { contextSize: config.context_size },
-    ...config.flash_attention !== undefined && { flashAttention: config.flash_attention }
-  });
-  textContexts.set(modelPath, context);
-  return context;
-}
-async function getOrCreateEmbeddingContext(model) {
-  const modelPath = getActualModelPath(model);
-  const cached = embeddingContexts.get(modelPath);
-  if (cached)
-    return cached;
-  const loadedModel = await getOrLoadModel(model);
-  const context = await loadedModel.createEmbeddingContext();
-  embeddingContexts.set(modelPath, context);
-  return context;
-}
-async function* streamFromSession(promptFn, signal) {
-  const queue = [];
-  let isComplete = false;
-  let completionError;
-  let resolveWait = null;
-  const notifyWaiter = () => {
-    resolveWait?.();
-    resolveWait = null;
-  };
-  const promptPromise = promptFn((chunk) => {
-    queue.push(chunk);
-    notifyWaiter();
-  }).then(() => {
-    isComplete = true;
-    notifyWaiter();
-  }).catch((err) => {
-    completionError = err;
-    isComplete = true;
-    notifyWaiter();
-  });
-  try {
-    while (true) {
-      while (queue.length > 0) {
-        yield { type: "text-delta", port: "text", textDelta: queue.shift() };
-      }
-      if (isComplete)
-        break;
-      await new Promise((r) => {
-        resolveWait = r;
-      });
-    }
-    while (queue.length > 0) {
-      yield { type: "text-delta", port: "text", textDelta: queue.shift() };
-    }
-  } finally {
-    await promptPromise.catch(() => {});
-  }
-  if (completionError) {
-    if (signal.aborted)
-      return;
-    throw completionError;
-  }
-  yield { type: "finish", data: {} };
-}
-var LlamaCpp_Download = async (input, model, update_progress, signal) => {
-  if (!model)
-    throw new Error("Model config is required for DownloadModelTask.");
-  const { createModelDownloader } = await loadSdk();
-  const config = model.provider_config;
-  const modelUri = config.model_url ?? config.model_path;
-  const dirPath = config.models_dir ?? LLAMACPP_DEFAULT_MODELS_DIR;
-  update_progress(0, "Creating model downloader");
-  const downloader = await createModelDownloader({ modelUri, dirPath });
-  const progressInterval = setInterval(() => {
-    const total = downloader.totalSize;
-    const downloaded = downloader.downloadedSize;
-    if (total && total > 0 && downloaded !== undefined) {
-      const pct = Math.min(99, Math.round(downloaded / total * 100));
-      update_progress(pct, "Downloading model", { file: modelUri, progress: pct / 100 });
-    }
-  }, 500);
-  let modelPath;
-  try {
-    modelPath = await downloader.download();
-  } finally {
-    clearInterval(progressInterval);
-  }
-  resolvedPaths.set(getConfigKey(model), modelPath);
-  update_progress(100, "Model downloaded", { file: modelUri, progress: 1 });
-  return { model: input.model };
-};
-var LlamaCpp_Unload = async (input, model, update_progress, _signal) => {
-  if (!model)
-    throw new Error("Model config is required for UnloadModelTask.");
-  const modelPath = getActualModelPath(model);
-  const ctx = textContexts.get(modelPath);
-  if (ctx) {
-    await ctx.dispose();
-    textContexts.delete(modelPath);
-    update_progress(33, "Text context disposed");
-  }
-  const embCtx = embeddingContexts.get(modelPath);
-  if (embCtx) {
-    await embCtx.dispose();
-    embeddingContexts.delete(modelPath);
-    update_progress(66, "Embedding context disposed");
-  }
-  const cachedModel = models.get(modelPath);
-  if (cachedModel) {
-    await cachedModel.dispose();
-    models.delete(modelPath);
-    update_progress(100, "Model unloaded from memory");
-  } else {
-    update_progress(100, "Model was not loaded");
-  }
-  return { model: input.model };
-};
-var LlamaCpp_TextGeneration = async (input, model, update_progress, signal) => {
-  if (Array.isArray(input.prompt)) {
-    getLogger().warn("LlamaCpp_TextGeneration: array input received; processing sequentially (no native batch support)");
-    const prompts = input.prompt;
-    const results = [];
-    for (const item of prompts) {
-      const r = await LlamaCpp_TextGeneration({ ...input, prompt: item }, model, update_progress, signal);
-      results.push(r.text);
-    }
-    return { text: results };
-  }
-  if (!model)
-    throw new Error("Model config is required for TextGenerationTask.");
-  const { LlamaChatSession } = await loadSdk();
-  update_progress(0, "Loading model");
-  const context = await getOrCreateTextContext(model);
-  update_progress(10, "Generating text");
-  const sequence = context.getSequence();
-  const session = new LlamaChatSession({ contextSequence: sequence });
-  try {
-    const text = await session.prompt(input.prompt, {
-      signal,
-      ...input.temperature !== undefined && { temperature: input.temperature },
-      ...input.maxTokens !== undefined && { maxTokens: input.maxTokens },
-      ...input.topP !== undefined && { topP: input.topP }
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
     });
-    update_progress(100, "Text generation complete");
-    return { text };
-  } finally {
-    sequence.dispose();
-  }
-};
-var LlamaCpp_TextGeneration_Stream = async function* (input, model, signal) {
-  if (!model)
-    throw new Error("Model config is required for TextGenerationTask.");
-  const { LlamaChatSession } = await loadSdk();
-  const context = await getOrCreateTextContext(model);
-  const sequence = context.getSequence();
-  const session = new LlamaChatSession({ contextSequence: sequence });
-  try {
-    yield* streamFromSession((onTextChunk) => {
-      return session.prompt(input.prompt, {
-        signal,
-        onTextChunk,
-        ...input.temperature !== undefined && { temperature: input.temperature },
-        ...input.maxTokens !== undefined && { maxTokens: input.maxTokens },
-        ...input.topP !== undefined && { topP: input.topP }
-      });
-    }, signal);
-  } finally {
-    sequence.dispose();
-  }
-};
-var LlamaCpp_TextEmbedding = async (input, model, update_progress, _signal) => {
-  if (!model)
-    throw new Error("Model config is required for TextEmbeddingTask.");
-  update_progress(0, "Loading embedding model");
-  const context = await getOrCreateEmbeddingContext(model);
-  const texts = Array.isArray(input.text) ? input.text : [input.text];
-  update_progress(10, "Computing embeddings");
-  const embeddings = await Promise.all(texts.map((text) => context.getEmbeddingFor(text).then((e) => new Float32Array(e.vector))));
-  update_progress(100, "Embeddings complete");
-  if (Array.isArray(input.text)) {
-    return { vector: embeddings };
-  }
-  return { vector: embeddings[0] };
-};
-var LlamaCpp_TextRewriter = async (input, model, update_progress, signal) => {
-  if (Array.isArray(input.text)) {
-    getLogger().warn("LlamaCpp_TextRewriter: array input received; processing sequentially (no native batch support)");
-    const texts = input.text;
-    const results = [];
-    for (const item of texts) {
-      const r = await LlamaCpp_TextRewriter({ ...input, text: item }, model, update_progress, signal);
-      results.push(r.text);
-    }
-    return { text: results };
-  }
-  if (!model)
-    throw new Error("Model config is required for TextRewriterTask.");
-  const { LlamaChatSession } = await loadSdk();
-  update_progress(0, "Loading model");
-  const context = await getOrCreateTextContext(model);
-  update_progress(10, "Rewriting text");
-  const sequence = context.getSequence();
-  const session = new LlamaChatSession({
-    contextSequence: sequence,
-    systemPrompt: input.prompt
-  });
-  try {
-    const text = await session.prompt(input.text, { signal });
-    update_progress(100, "Text rewriting complete");
-    return { text };
-  } finally {
-    sequence.dispose();
-  }
-};
-var LlamaCpp_TextRewriter_Stream = async function* (input, model, signal) {
-  if (!model)
-    throw new Error("Model config is required for TextRewriterTask.");
-  const { LlamaChatSession } = await loadSdk();
-  const context = await getOrCreateTextContext(model);
-  const sequence = context.getSequence();
-  const session = new LlamaChatSession({
-    contextSequence: sequence,
-    systemPrompt: input.prompt
-  });
-  try {
-    yield* streamFromSession((onTextChunk) => {
-      return session.prompt(input.text, { signal, onTextChunk });
-    }, signal);
-  } finally {
-    sequence.dispose();
-  }
-};
-var LlamaCpp_TextSummary = async (input, model, update_progress, signal) => {
-  if (Array.isArray(input.text)) {
-    getLogger().warn("LlamaCpp_TextSummary: array input received; processing sequentially (no native batch support)");
-    const texts = input.text;
-    const results = [];
-    for (const item of texts) {
-      const r = await LlamaCpp_TextSummary({ ...input, text: item }, model, update_progress, signal);
-      results.push(r.text);
-    }
-    return { text: results };
-  }
-  if (!model)
-    throw new Error("Model config is required for TextSummaryTask.");
-  const { LlamaChatSession } = await loadSdk();
-  update_progress(0, "Loading model");
-  const context = await getOrCreateTextContext(model);
-  update_progress(10, "Summarizing text");
-  const sequence = context.getSequence();
-  const session = new LlamaChatSession({
-    contextSequence: sequence,
-    systemPrompt: "Summarize the following text concisely, preserving the key points."
-  });
-  try {
-    const text = await session.prompt(input.text, { signal });
-    update_progress(100, "Summarization complete");
-    return { text };
-  } finally {
-    sequence.dispose();
-  }
-};
-var LlamaCpp_TextSummary_Stream = async function* (input, model, signal) {
-  if (!model)
-    throw new Error("Model config is required for TextSummaryTask.");
-  const { LlamaChatSession } = await loadSdk();
-  const context = await getOrCreateTextContext(model);
-  const sequence = context.getSequence();
-  const session = new LlamaChatSession({
-    contextSequence: sequence,
-    systemPrompt: "Summarize the following text concisely, preserving the key points."
-  });
-  try {
-    yield* streamFromSession((onTextChunk) => {
-      return session.prompt(input.text, { signal, onTextChunk });
-    }, signal);
-  } finally {
-    sequence.dispose();
-  }
 };
-async function disposeLlamaCppResources() {
-  const disposeAll = async (map) => {
-    for (const resource of map.values()) {
-      await resource.dispose().catch(() => {});
-    }
-    map.clear();
-  };
-  await disposeAll(textContexts);
-  await disposeAll(embeddingContexts);
-  await disposeAll(models);
-  if (llamaInstance) {
-    await llamaInstance.dispose?.().catch(() => {});
-    llamaInstance = undefined;
-  }
-  resolvedPaths.clear();
-}
-var LlamaCpp_CountTokens = async (input, model, onProgress, signal) => {
-  if (Array.isArray(input.text)) {
-    getLogger().warn("LlamaCpp_CountTokens: array input received; processing sequentially (no native batch support)");
-    const texts = input.text;
-    const counts = [];
-    for (const item of texts) {
-      const r = await LlamaCpp_CountTokens({ ...input, text: item }, model, onProgress, signal);
-      counts.push(r.count);
-    }
-    return { count: counts };
-  }
-  const loadedModel = await getOrLoadModel(model);
-  const tokens = loadedModel.tokenizer(input.text);
-  return { count: tokens.length };
-};
-var LlamaCpp_CountTokens_Reactive = async (input, _output, model) => {
-  return LlamaCpp_CountTokens(input, model, () => {}, new AbortController().signal);
-};
-function buildLlamaCppPrompt(input) {
-  const inputMessages = input.messages;
-  if (!inputMessages || inputMessages.length === 0) {
-    return Array.isArray(input.prompt) ? input.prompt.join(`
-`) : input.prompt;
-  }
-  const parts = [];
-  for (const msg of inputMessages) {
-    if (msg.role === "user") {
-      parts.push(`User: ${msg.content}`);
-    } else if (msg.role === "assistant" && Array.isArray(msg.content)) {
-      const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-      if (text)
-        parts.push(`Assistant: ${text}`);
-    } else if (msg.role === "tool" && Array.isArray(msg.content)) {
-      for (const block of msg.content) {
-        parts.push(`Tool Result: ${block.content}`);
-      }
-    }
-  }
-  return parts.join(`
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+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');
+});
 
-`);
-}
-function buildLlamaCppFunctions(tools, capturedCalls) {
-  const { defineChatSessionFunction } = _sdk;
-  const functions = {};
-  for (const tool of tools) {
-    const toolName = tool.name;
-    functions[toolName] = defineChatSessionFunction({
-      description: tool.description,
-      params: tool.inputSchema,
-      handler(params) {
-        capturedCalls.push({ name: toolName, input: params ?? {} });
-        return "OK";
-      }
-    });
-  }
-  return functions;
-}
-var LlamaCpp_ToolCalling = async (input, model, update_progress, signal) => {
-  if (Array.isArray(input.prompt)) {
-    getLogger().warn("LlamaCpp_ToolCalling: array input received; processing sequentially (no native batch support)");
-    const prompts = input.prompt;
-    const texts = [];
-    const toolCallsList = [];
-    for (const item of prompts) {
-      const r = await LlamaCpp_ToolCalling({ ...input, prompt: item }, model, update_progress, signal);
-      texts.push(r.text);
-      toolCallsList.push(r.toolCalls);
-    }
-    return { text: texts, toolCalls: toolCallsList };
-  }
-  if (!model)
-    throw new Error("Model config is required for ToolCallingTask.");
-  await loadSdk();
-  update_progress(0, "Loading model");
-  const context = await getOrCreateTextContext(model);
-  const capturedCalls = [];
-  const functions = input.toolChoice === "none" ? undefined : buildLlamaCppFunctions(input.tools, capturedCalls);
-  update_progress(10, "Running tool calling");
-  const sequence = context.getSequence();
-  const { LlamaChatSession } = _sdk;
-  const promptText = buildLlamaCppPrompt(input);
-  const session = new LlamaChatSession({
-    contextSequence: sequence,
-    ...input.systemPrompt && { systemPrompt: input.systemPrompt }
-  });
-  try {
-    const text = await session.prompt(promptText, {
-      signal,
-      ...functions && { functions },
-      ...input.temperature !== undefined && { temperature: input.temperature },
-      ...input.maxTokens !== undefined && { maxTokens: input.maxTokens }
-    });
-    const toolCalls = [];
-    capturedCalls.forEach((call, index) => {
-      const id = `call_${index}`;
-      toolCalls.push({ id, name: call.name, input: call.input });
-    });
-    update_progress(100, "Tool calling complete");
-    return { text, toolCalls: filterValidToolCalls(toolCalls, input.tools) };
-  } finally {
-    sequence.dispose();
-  }
-};
-var LlamaCpp_ToolCalling_Stream = async function* (input, model, signal) {
-  if (!model)
-    throw new Error("Model config is required for ToolCallingTask.");
-  await loadSdk();
-  const context = await getOrCreateTextContext(model);
-  const capturedCalls = [];
-  const functions = input.toolChoice === "none" ? undefined : buildLlamaCppFunctions(input.tools, capturedCalls);
-  const sequence = context.getSequence();
-  const { LlamaChatSession } = _sdk;
-  const promptText = buildLlamaCppPrompt(input);
-  const session = new LlamaChatSession({
-    contextSequence: sequence,
-    ...input.systemPrompt && { systemPrompt: input.systemPrompt }
-  });
-  const queue = [];
-  let isComplete = false;
-  let completionError;
-  let resolveWait = null;
-  const notifyWaiter = () => {
-    resolveWait?.();
-    resolveWait = null;
-  };
-  let accumulatedText = "";
-  const promptPromise = session.prompt(promptText, {
-    signal,
-    ...functions && { functions },
-    onTextChunk: (chunk) => {
-      queue.push(chunk);
-      notifyWaiter();
+// src/provider-llamacpp/common/LlamaCpp_Constants.ts
+var LOCAL_LLAMACPP = "LOCAL_LLAMACPP";
+var LLAMACPP_DEFAULT_MODELS_DIR = "./models";
+// src/provider-llamacpp/common/LlamaCpp_ModelSchema.ts
+import { ModelConfigSchema, ModelRecordSchema } from "@workglow/ai/worker";
+var LlamaCppModelSchema = {
+  type: "object",
+  properties: {
+    provider: {
+      const: LOCAL_LLAMACPP,
+      description: "Discriminator: local node-llama-cpp (GGUF) model."
     },
-    ...input.temperature !== undefined && { temperature: input.temperature },
-    ...input.maxTokens !== undefined && { maxTokens: input.maxTokens }
-  }).then(() => {
-    isComplete = true;
-    notifyWaiter();
-  }).catch((err) => {
-    completionError = err;
-    isComplete = true;
-    notifyWaiter();
-  });
-  try {
-    while (true) {
-      while (queue.length > 0) {
-        const chunk = queue.shift();
-        accumulatedText += chunk;
-        yield { type: "text-delta", port: "text", textDelta: chunk };
-      }
-      if (isComplete)
-        break;
-      await new Promise((r) => {
-        resolveWait = r;
-      });
-    }
-    while (queue.length > 0) {
-      const chunk = queue.shift();
-      accumulatedText += chunk;
-      yield { type: "text-delta", port: "text", textDelta: chunk };
-    }
-  } finally {
-    await promptPromise.catch(() => {});
-    sequence.dispose();
-  }
-  if (completionError) {
-    if (!signal.aborted)
-      throw completionError;
-    return;
-  }
-  const toolCalls = [];
-  capturedCalls.forEach((call, index) => {
-    const id = `call_${index}`;
-    toolCalls.push({ id, name: call.name, input: call.input });
-  });
-  const validToolCalls = filterValidToolCalls(toolCalls, input.tools);
-  if (validToolCalls.length > 0) {
-    yield { type: "object-delta", port: "toolCalls", objectDelta: [...validToolCalls] };
-  }
-  yield {
-    type: "finish",
-    data: { text: accumulatedText, toolCalls: validToolCalls }
-  };
-};
-var LlamaCpp_StructuredGeneration = async (input, model, update_progress, signal) => {
-  if (!model)
-    throw new Error("Model config is required for StructuredGenerationTask.");
-  await loadSdk();
-  update_progress(0, "Loading model");
-  const llama = await getLlamaInstance();
-  const context = await getOrCreateTextContext(model);
-  update_progress(10, "Running structured generation");
-  const grammar = await llama.createGrammarForJsonSchema(input.outputSchema);
-  const sequence = context.getSequence();
-  const { LlamaChatSession } = _sdk;
-  const session = new LlamaChatSession({ contextSequence: sequence });
-  try {
-    const text = await session.prompt(input.prompt, {
-      signal,
-      grammar,
-      ...input.temperature !== undefined && { temperature: input.temperature },
-      ...input.maxTokens !== undefined && { maxTokens: input.maxTokens }
-    });
-    let object;
-    try {
-      object = JSON.parse(text);
-    } catch {
-      object = {};
-    }
-    update_progress(100, "Structured generation complete");
-    return { object };
-  } finally {
-    sequence.dispose();
-  }
-};
-var LlamaCpp_StructuredGeneration_Stream = async function* (input, model, signal) {
-  if (!model)
-    throw new Error("Model config is required for StructuredGenerationTask.");
-  await loadSdk();
-  const llama = await getLlamaInstance();
-  const context = await getOrCreateTextContext(model);
-  const grammar = await llama.createGrammarForJsonSchema(input.outputSchema);
-  const sequence = context.getSequence();
-  const { LlamaChatSession } = _sdk;
-  const session = new LlamaChatSession({ contextSequence: sequence });
-  const queue = [];
-  let isComplete = false;
-  let completionError;
-  let resolveWait = null;
-  const notifyWaiter = () => {
-    resolveWait?.();
-    resolveWait = null;
-  };
-  let accumulatedText = "";
-  const promptPromise = session.prompt(input.prompt, {
-    signal,
-    grammar,
-    onTextChunk: (chunk) => {
-      queue.push(chunk);
-      notifyWaiter();
-    },
-    ...input.temperature !== undefined && { temperature: input.temperature },
-    ...input.maxTokens !== undefined && { maxTokens: input.maxTokens }
-  }).then(() => {
-    isComplete = true;
-    notifyWaiter();
-  }).catch((err) => {
-    completionError = err;
-    isComplete = true;
-    notifyWaiter();
-  });
-  try {
-    while (true) {
-      while (queue.length > 0) {
-        const chunk = queue.shift();
-        accumulatedText += chunk;
-        const partial = parsePartialJson(accumulatedText);
-        if (partial !== undefined) {
-          yield {
-            type: "object-delta",
-            port: "object",
-            objectDelta: partial
-          };
+    provider_config: {
+      type: "object",
+      description: "node-llama-cpp specific configuration.",
+      properties: {
+        model_path: {
+          type: "string",
+          description: "Filesystem path to the .gguf model file."
+        },
+        model_url: {
+          type: "string",
+          description: "URI or URL to download the model from (e.g. 'hf:user/repo:quant' or an https URL). Used by DownloadModelTask."
+        },
+        models_dir: {
+          type: "string",
+          description: "Directory to download models into.",
+          default: LLAMACPP_DEFAULT_MODELS_DIR
+        },
+        gpu_layers: {
+          type: "integer",
+          description: "Number of model layers to offload to GPU. Use -1 for auto-detection.",
+          minimum: -1
+        },
+        context_size: {
+          type: "integer",
+          description: "Context window size in tokens.",
+          minimum: 1
+        },
+        flash_attention: {
+          type: "boolean",
+          description: "Enable flash attention for improved performance where supported.",
+          default: true
+        },
+        embedding: {
+          type: "boolean",
+          description: "Whether this model is used for text embedding (vs text generation).",
+          default: false
         }
-      }
-      if (isComplete)
-        break;
-      await new Promise((r) => {
-        resolveWait = r;
-      });
-    }
-    while (queue.length > 0) {
-      const chunk = queue.shift();
-      accumulatedText += chunk;
-    }
-  } finally {
-    await promptPromise.catch(() => {});
-    sequence.dispose();
-  }
-  if (completionError) {
-    if (signal.aborted)
-      return;
-    throw completionError;
-  }
-  let finalObject;
-  try {
-    finalObject = JSON.parse(accumulatedText);
-  } catch {
-    finalObject = parsePartialJson(accumulatedText) ?? {};
-  }
-  yield { type: "finish", data: { object: finalObject } };
-};
-var LlamaCpp_ModelInfo = async (input, model) => {
-  if (!model)
-    throw new Error("Model config is required for ModelInfoTask.");
-  const modelPath = getActualModelPath(model);
-  const is_loaded = models.has(modelPath);
-  let is_cached = is_loaded;
-  let file_sizes = null;
-  try {
-    const fs = await import("node:fs/promises");
-    const stat = await fs.stat(modelPath);
-    is_cached = true;
-    file_sizes = { model: stat.size };
-  } catch {
-    if (resolvedPaths.has(getConfigKey(model))) {
-      is_cached = true;
-    }
+      },
+      required: ["model_path"],
+      additionalProperties: false
+    }
+  },
+  required: ["provider", "provider_config"],
+  additionalProperties: true
+};
+var LlamaCppModelRecordSchema = {
+  type: "object",
+  properties: {
+    ...ModelRecordSchema.properties,
+    ...LlamaCppModelSchema.properties
+  },
+  required: [...ModelRecordSchema.required, ...LlamaCppModelSchema.required],
+  additionalProperties: false
+};
+var LlamaCppModelConfigSchema = {
+  type: "object",
+  properties: {
+    ...ModelConfigSchema.properties,
+    ...LlamaCppModelSchema.properties
+  },
+  required: [...ModelConfigSchema.required, ...LlamaCppModelSchema.required],
+  additionalProperties: false
+};
+// src/provider-llamacpp/LlamaCppQueuedProvider.ts
+import {
+  QueuedAiProvider
+} from "@workglow/ai";
+class LlamaCppQueuedProvider extends QueuedAiProvider {
+  name = LOCAL_LLAMACPP;
+  isLocal = true;
+  supportsBrowser = false;
+  taskTypes = [
+    "DownloadModelTask",
+    "UnloadModelTask",
+    "ModelInfoTask",
+    "CountTokensTask",
+    "TextGenerationTask",
+    "TextEmbeddingTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "ToolCallingTask",
+    "ModelSearchTask"
+  ];
+  constructor(tasks, streamTasks, reactiveTasks) {
+    super(tasks, streamTasks, reactiveTasks);
   }
-  return {
-    model: input.model,
-    is_local: true,
-    is_remote: false,
-    supports_browser: false,
-    supports_node: true,
-    is_cached,
-    is_loaded,
-    file_sizes
-  };
-};
-var LLAMACPP_TASKS = {
-  DownloadModelTask: LlamaCpp_Download,
-  UnloadModelTask: LlamaCpp_Unload,
-  ModelInfoTask: LlamaCpp_ModelInfo,
-  CountTokensTask: LlamaCpp_CountTokens,
-  TextGenerationTask: LlamaCpp_TextGeneration,
-  TextEmbeddingTask: LlamaCpp_TextEmbedding,
-  TextRewriterTask: LlamaCpp_TextRewriter,
-  TextSummaryTask: LlamaCpp_TextSummary,
-  ToolCallingTask: LlamaCpp_ToolCalling,
-  StructuredGenerationTask: LlamaCpp_StructuredGeneration
-};
-var LLAMACPP_STREAM_TASKS = {
-  TextGenerationTask: LlamaCpp_TextGeneration_Stream,
-  TextRewriterTask: LlamaCpp_TextRewriter_Stream,
-  TextSummaryTask: LlamaCpp_TextSummary_Stream,
-  ToolCallingTask: LlamaCpp_ToolCalling_Stream,
-  StructuredGenerationTask: LlamaCpp_StructuredGeneration_Stream
-};
-var LLAMACPP_REACTIVE_TASKS = {
-  CountTokensTask: LlamaCpp_CountTokens_Reactive
-};
-// src/provider-llamacpp/LlamaCpp_Worker.ts
-import { getLogger as getLogger2, globalServiceRegistry, WORKER_SERVER } from "@workglow/util";
-function LLAMACPP_WORKER_JOBRUN_REGISTER() {
-  const workerServer = globalServiceRegistry.get(WORKER_SERVER);
-  new LlamaCppProvider(LLAMACPP_TASKS, LLAMACPP_STREAM_TASKS, LLAMACPP_REACTIVE_TASKS).registerOnWorkerServer(workerServer);
-  workerServer.sendReady();
-  getLogger2().info("LLAMACPP_WORKER_JOBRUN registered");
+}
+
+// src/provider-llamacpp/registerLlamaCpp.ts
+async function registerLlamaCpp(options) {
+  await new LlamaCppQueuedProvider().register(options);
 }
 export {
-  disposeLlamaCppResources,
-  LlamaCpp_Unload,
-  LlamaCpp_ToolCalling_Stream,
-  LlamaCpp_ToolCalling,
-  LlamaCpp_TextSummary_Stream,
-  LlamaCpp_TextSummary,
-  LlamaCpp_TextRewriter_Stream,
-  LlamaCpp_TextRewriter,
-  LlamaCpp_TextGeneration_Stream,
-  LlamaCpp_TextGeneration,
-  LlamaCpp_TextEmbedding,
-  LlamaCpp_StructuredGeneration_Stream,
-  LlamaCpp_StructuredGeneration,
-  LlamaCpp_ModelInfo,
-  LlamaCpp_Download,
-  LlamaCpp_CountTokens_Reactive,
-  LlamaCpp_CountTokens,
-  LlamaCppProvider,
+  registerLlamaCpp,
   LlamaCppModelSchema,
   LlamaCppModelRecordSchema,
   LlamaCppModelConfigSchema,
   LOCAL_LLAMACPP,
-  LLAMACPP_WORKER_JOBRUN_REGISTER,
-  LLAMACPP_TASKS,
-  LLAMACPP_STREAM_TASKS,
-  LLAMACPP_REACTIVE_TASKS,
   LLAMACPP_DEFAULT_MODELS_DIR
 };
 
-//# debugId=2C1EC584C3FA43E664756E2164756E21
+//# debugId=5DCB59F869EA8BFD64756E2164756E21