@workglow/ai-provider 0.0.121 → 0.0.122

package/dist/provider-hf-inference/registerHfInferenceWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerHfInferenceWorker.d.ts","sourceRoot":"","sources":["../../src/provider-hf-inference/registerHfInferenceWorker.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,IAAI,CAAC,CAK/D"}

package/dist/provider-hf-inference/runtime.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Worker server and main-thread inline Hugging Face Inference registration (pulls in `HFI_JobRunFns`),
+ * plus API client helpers (`HFI_Client`).
+ * Import from `@workglow/ai-provider/hf-inference/runtime` — not from the main `hf-inference` barrel.
+ *
+ * Use `export *` (not `export { … } from "…"`) so the Bun bundler keeps the module graph.
+ */
+export * from "./common/HFI_Client";
+export * from "./registerHfInferenceInline";
+export * from "./registerHfInferenceWorker";
+//# sourceMappingURL=runtime.d.ts.map

package/dist/provider-hf-inference/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/provider-hf-inference/runtime.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;GAMG;AACH,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC"}

package/dist/provider-hf-inference/runtime.js

@@ -0,0 +1,592 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+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');
+});
+
+// src/provider-hf-inference/common/HFI_Client.ts
+var _sdk;
+async function loadHfInferenceSDK() {
+  if (!_sdk) {
+    try {
+      _sdk = await import("@huggingface/inference");
+    } catch {
+      throw new Error("@huggingface/inference is required for Hugging Face Inference tasks. Install it with: bun add @huggingface/inference");
+    }
+  }
+  return _sdk;
+}
+async function getClient(model) {
+  const sdk = await loadHfInferenceSDK();
+  const config = model?.provider_config;
+  const apiKey = config?.credential_key || config?.api_key || (typeof process !== "undefined" ? process.env?.HF_TOKEN : undefined);
+  if (!apiKey) {
+    throw new Error("Missing Hugging Face API key: set provider_config.credential_key or the HF_TOKEN environment variable.");
+  }
+  return new sdk.InferenceClient(apiKey);
+}
+function getModelName(model) {
+  const name = model?.provider_config?.model_name;
+  if (!name) {
+    throw new Error("Missing model name in provider_config.model_name.");
+  }
+  return name;
+}
+function getProvider(model) {
+  return model?.provider_config?.provider;
+}
+// src/common/PipelineTaskMapping.ts
+var TASK_TO_PIPELINES = {
+  TextEmbeddingTask: ["feature-extraction"],
+  TextGenerationTask: ["text-generation"],
+  TextSummaryTask: ["sentence-similarity", "summarization"],
+  TextTranslationTask: ["translation"],
+  TextClassificationTask: ["text-classification", "zero-shot-classification"],
+  TextQuestionAnswerTask: ["question-answering"],
+  TextFillMaskTask: ["fill-mask"],
+  TextLanguageDetectionTask: ["text-classification"],
+  TextNamedEntityRecognitionTask: ["token-classification"],
+  TokenClassificationTask: ["token-classification"],
+  ImageClassificationTask: ["image-classification", "zero-shot-image-classification"],
+  ImageEmbeddingTask: ["image-feature-extraction"],
+  ImageSegmentationTask: ["image-segmentation"],
+  ImageToImageTask: ["image-to-image"],
+  ImageToTextTask: ["image-to-text"],
+  ObjectDetectionTask: ["object-detection", "zero-shot-object-detection"],
+  DepthEstimationTask: ["depth-estimation"],
+  AudioClassificationTask: ["audio-classification"],
+  SpeechRecognitionTask: ["automatic-speech-recognition"]
+};
+function pipelineToTaskTypes(pipeline) {
+  return Object.entries(TASK_TO_PIPELINES).filter(([, pipelines]) => pipelines.includes(pipeline)).map(([task]) => task);
+}
+
+// src/common/HfModelSearch.ts
+var HF_API_BASE = "https://huggingface.co/api";
+function formatDownloads(n) {
+  if (n >= 1e6)
+    return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1000)
+    return `${(n / 1000).toFixed(1)}k`;
+  return String(n);
+}
+function mapHfProviderConfig(entry, provider) {
+  switch (provider) {
+    case "HF_TRANSFORMERS_ONNX":
+      return {
+        model_path: entry.id,
+        ...entry.pipeline_tag ? { pipeline: entry.pipeline_tag } : {}
+      };
+    case "LOCAL_LLAMACPP":
+      return { model_path: entry.id };
+    default:
+      return { model_name: entry.id };
+  }
+}
+function mapHfModelResult(entry, provider) {
+  const badges = [entry.pipeline_tag, entry.library_name].filter(Boolean).join(" | ");
+  return {
+    id: entry.id,
+    label: `${entry.id}${badges ? `  ${badges}` : ""}`,
+    description: `${formatDownloads(entry.downloads)} downloads`,
+    record: {
+      model_id: entry.id,
+      provider,
+      title: entry.id.split("/").pop() ?? entry.id,
+      description: [entry.pipeline_tag, `${formatDownloads(entry.downloads)} downloads`].filter(Boolean).join(" — "),
+      tasks: entry.pipeline_tag ? pipelineToTaskTypes(entry.pipeline_tag) : [],
+      provider_config: mapHfProviderConfig(entry, provider),
+      metadata: {}
+    },
+    raw: entry
+  };
+}
+async function searchHfModels(query, extraParams, expandFields, signal) {
+  const params = new URLSearchParams({
+    search: query,
+    limit: "500",
+    sort: "downloads",
+    direction: "-1",
+    ...extraParams
+  });
+  params.append("expand[]", "pipeline_tag");
+  if (expandFields) {
+    for (const field of expandFields) {
+      params.append("expand[]", field);
+    }
+  }
+  const res = await fetch(`${HF_API_BASE}/models?${params}`, { signal });
+  if (!res.ok)
+    throw new Error(`HuggingFace API returned ${res.status}`);
+  return res.json();
+}
+
+// src/provider-hf-inference/common/HFI_Constants.ts
+var HF_INFERENCE = "HF_INFERENCE";
+
+// src/provider-hf-inference/common/HFI_ModelSearch.ts
+var HFI_ModelSearch = async (input, _model, _onProgress, signal) => {
+  const entries = await searchHfModels(input.query, undefined, undefined, signal);
+  const results = entries.map((entry) => mapHfModelResult(entry, HF_INFERENCE));
+  return { results };
+};
+
+// src/provider-hf-inference/common/HFI_ModelInfo.ts
+var HFI_ModelInfo = async (input) => {
+  return {
+    model: input.model,
+    is_local: false,
+    is_remote: true,
+    supports_browser: true,
+    supports_node: true,
+    is_cached: false,
+    is_loaded: false,
+    file_sizes: null
+  };
+};
+
+// src/provider-hf-inference/common/HFI_TextEmbedding.ts
+import { getLogger } from "@workglow/util/worker";
+var HFI_TextEmbedding = async (input, model, update_progress, signal) => {
+  const logger = getLogger();
+  const timerLabel = `hfi:TextEmbedding:${model?.provider_config?.model_name}`;
+  logger.time(timerLabel, { model: model?.provider_config?.model_name });
+  update_progress(0, "Starting HF Inference text embedding");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  if (Array.isArray(input.text)) {
+    const embeddings = await Promise.all(input.text.map((text) => client.featureExtraction({
+      model: modelName,
+      inputs: text
+    }, { signal })));
+    update_progress(100, "Completed HF Inference text embedding");
+    logger.timeEnd(timerLabel, { model: model?.provider_config?.model_name, batch: true });
+    return {
+      vector: embeddings.map((embedding2) => new Float32Array(embedding2))
+    };
+  }
+  const embedding = await client.featureExtraction({
+    model: modelName,
+    inputs: input.text
+  }, { signal });
+  update_progress(100, "Completed HF Inference text embedding");
+  logger.timeEnd(timerLabel, { model: model?.provider_config?.model_name });
+  return { vector: new Float32Array(embedding) };
+};
+
+// src/provider-hf-inference/common/HFI_TextGeneration.ts
+import { getLogger as getLogger2 } from "@workglow/util/worker";
+var HFI_TextGeneration = async (input, model, update_progress, signal) => {
+  if (Array.isArray(input.prompt)) {
+    getLogger2().warn("HFI_TextGeneration: array input received; processing sequentially (no native batch support)");
+    const prompts = input.prompt;
+    const results = [];
+    for (const item of prompts) {
+      const r = await HFI_TextGeneration({ ...input, prompt: item }, model, update_progress, signal);
+      results.push(r.text);
+    }
+    return { text: results };
+  }
+  const logger = getLogger2();
+  const timerLabel = `hfi:TextGeneration:${model?.provider_config?.model_name}`;
+  logger.time(timerLabel, { model: model?.provider_config?.model_name });
+  update_progress(0, "Starting HF Inference text generation");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const provider = getProvider(model);
+  const response = await client.chatCompletion({
+    model: modelName,
+    messages: [{ role: "user", content: input.prompt }],
+    max_tokens: input.maxTokens,
+    temperature: input.temperature,
+    top_p: input.topP,
+    frequency_penalty: input.frequencyPenalty,
+    provider
+  }, { signal });
+  update_progress(100, "Completed HF Inference text generation");
+  logger.timeEnd(timerLabel, { model: model?.provider_config?.model_name });
+  return { text: response.choices[0]?.message?.content ?? "" };
+};
+var HFI_TextGeneration_Stream = async function* (input, model, signal) {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const provider = getProvider(model);
+  const stream = client.chatCompletionStream({
+    model: modelName,
+    messages: [{ role: "user", content: input.prompt }],
+    max_tokens: input.maxTokens,
+    temperature: input.temperature,
+    top_p: input.topP,
+    frequency_penalty: input.frequencyPenalty,
+    provider
+  }, { signal });
+  for await (const chunk of stream) {
+    const delta = chunk.choices[0]?.delta?.content ?? "";
+    if (delta) {
+      yield { type: "text-delta", port: "text", textDelta: delta };
+    }
+  }
+  yield { type: "finish", data: {} };
+};
+
+// src/provider-hf-inference/common/HFI_TextRewriter.ts
+import { getLogger as getLogger3 } from "@workglow/util/worker";
+var HFI_TextRewriter = async (input, model, update_progress, signal) => {
+  if (Array.isArray(input.text)) {
+    getLogger3().warn("HFI_TextRewriter: array input received; processing sequentially (no native batch support)");
+    const texts = input.text;
+    const results = [];
+    for (const item of texts) {
+      const r = await HFI_TextRewriter({ ...input, text: item }, model, update_progress, signal);
+      results.push(r.text);
+    }
+    return { text: results };
+  }
+  update_progress(0, "Starting HF Inference text rewriting");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const provider = getProvider(model);
+  const response = await client.chatCompletion({
+    model: modelName,
+    messages: [
+      { role: "system", content: input.prompt },
+      { role: "user", content: input.text }
+    ],
+    provider
+  }, { signal });
+  update_progress(100, "Completed HF Inference text rewriting");
+  return { text: response.choices[0]?.message?.content ?? "" };
+};
+var HFI_TextRewriter_Stream = async function* (input, model, signal) {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const provider = getProvider(model);
+  const stream = client.chatCompletionStream({
+    model: modelName,
+    messages: [
+      { role: "system", content: input.prompt },
+      { role: "user", content: input.text }
+    ],
+    provider
+  }, { signal });
+  for await (const chunk of stream) {
+    const delta = chunk.choices[0]?.delta?.content ?? "";
+    if (delta) {
+      yield { type: "text-delta", port: "text", textDelta: delta };
+    }
+  }
+  yield { type: "finish", data: {} };
+};
+
+// src/provider-hf-inference/common/HFI_TextSummary.ts
+import { getLogger as getLogger4 } from "@workglow/util/worker";
+var HFI_TextSummary = async (input, model, update_progress, signal) => {
+  if (Array.isArray(input.text)) {
+    getLogger4().warn("HFI_TextSummary: array input received; processing sequentially (no native batch support)");
+    const texts = input.text;
+    const results = [];
+    for (const item of texts) {
+      const r = await HFI_TextSummary({ ...input, text: item }, model, update_progress, signal);
+      results.push(r.text);
+    }
+    return { text: results };
+  }
+  update_progress(0, "Starting HF Inference text summarization");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const provider = getProvider(model);
+  const response = await client.chatCompletion({
+    model: modelName,
+    messages: [
+      { role: "system", content: "Summarize the following text concisely." },
+      { role: "user", content: input.text }
+    ],
+    provider
+  }, { signal });
+  update_progress(100, "Completed HF Inference text summarization");
+  return { text: response.choices[0]?.message?.content ?? "" };
+};
+var HFI_TextSummary_Stream = async function* (input, model, signal) {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const provider = getProvider(model);
+  const stream = client.chatCompletionStream({
+    model: modelName,
+    messages: [
+      { role: "system", content: "Summarize the following text concisely." },
+      { role: "user", content: input.text }
+    ],
+    provider
+  }, { signal });
+  for await (const chunk of stream) {
+    const delta = chunk.choices[0]?.delta?.content ?? "";
+    if (delta) {
+      yield { type: "text-delta", port: "text", textDelta: delta };
+    }
+  }
+  yield { type: "finish", data: {} };
+};
+
+// src/provider-hf-inference/common/HFI_ToolCalling.ts
+import { buildToolDescription, filterValidToolCalls, toOpenAIMessages } from "@workglow/ai/worker";
+import { getLogger as getLogger5, parsePartialJson } from "@workglow/util/worker";
+function mapHFIToolChoice(toolChoice) {
+  if (!toolChoice || toolChoice === "auto")
+    return "auto";
+  if (toolChoice === "none")
+    return "none";
+  if (toolChoice === "required")
+    return "required";
+  return "auto";
+}
+var HFI_ToolCalling = async (input, model, update_progress, signal) => {
+  if (Array.isArray(input.prompt)) {
+    getLogger5().warn("HFI_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 HFI_ToolCalling({ ...input, prompt: item }, model, update_progress, signal);
+      texts.push(r.text);
+      toolCallsList.push(r.toolCalls);
+    }
+    return { text: texts, toolCalls: toolCallsList };
+  }
+  update_progress(0, "Starting HF Inference tool calling");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const provider = getProvider(model);
+  const tools = input.tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: buildToolDescription(t),
+      parameters: t.inputSchema
+    }
+  }));
+  const messages = toOpenAIMessages(input);
+  const toolChoice = mapHFIToolChoice(input.toolChoice);
+  const params = {
+    model: modelName,
+    messages,
+    max_tokens: input.maxTokens,
+    temperature: input.temperature,
+    provider
+  };
+  if (toolChoice !== "none") {
+    params.tools = tools;
+    params.tool_choice = toolChoice;
+  }
+  const response = await client.chatCompletion(params, { signal });
+  const text = response.choices[0]?.message?.content ?? "";
+  const toolCalls = [];
+  let callIndex = 0;
+  (response.choices[0]?.message?.tool_calls ?? []).forEach((tc) => {
+    let parsedInput = {};
+    const rawArgs = tc.function?.arguments;
+    if (typeof rawArgs === "string") {
+      try {
+        parsedInput = JSON.parse(rawArgs);
+      } catch {
+        const partial = parsePartialJson(rawArgs);
+        parsedInput = partial ?? {};
+      }
+    } else if (rawArgs != null) {
+      parsedInput = rawArgs;
+    }
+    const id = tc.id ?? `call_${callIndex}`;
+    callIndex++;
+    toolCalls.push({ id, name: tc.function.name, input: parsedInput });
+  });
+  update_progress(100, "Completed HF Inference tool calling");
+  return { text, toolCalls: filterValidToolCalls(toolCalls, input.tools) };
+};
+var HFI_ToolCalling_Stream = async function* (input, model, signal) {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const provider = getProvider(model);
+  const tools = input.tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: buildToolDescription(t),
+      parameters: t.inputSchema
+    }
+  }));
+  const messages = toOpenAIMessages(input);
+  const toolChoice = mapHFIToolChoice(input.toolChoice);
+  const params = {
+    model: modelName,
+    messages,
+    max_tokens: input.maxTokens,
+    temperature: input.temperature,
+    provider
+  };
+  if (toolChoice !== "none") {
+    params.tools = tools;
+    params.tool_choice = toolChoice;
+  }
+  const stream = client.chatCompletionStream(params, { signal });
+  let accumulatedText = "";
+  const toolCallAccumulator = new Map;
+  for await (const chunk of stream) {
+    const choice = chunk.choices[0];
+    if (!choice)
+      continue;
+    const contentDelta = choice.delta?.content ?? "";
+    if (contentDelta) {
+      accumulatedText += contentDelta;
+      yield { type: "text-delta", port: "text", textDelta: contentDelta };
+    }
+    const tcDeltas = choice.delta?.tool_calls;
+    if (Array.isArray(tcDeltas)) {
+      for (const tcDelta of tcDeltas) {
+        const idx = tcDelta.index;
+        if (!toolCallAccumulator.has(idx)) {
+          toolCallAccumulator.set(idx, {
+            id: tcDelta.id ?? "",
+            name: tcDelta.function?.name ?? "",
+            arguments: ""
+          });
+        }
+        const acc = toolCallAccumulator.get(idx);
+        if (tcDelta.id)
+          acc.id = tcDelta.id;
+        if (tcDelta.function?.name)
+          acc.name = tcDelta.function.name;
+        if (tcDelta.function?.arguments)
+          acc.arguments += tcDelta.function.arguments;
+      }
+      const snapshot = [];
+      for (const [, tc] of toolCallAccumulator) {
+        let parsedInput;
+        try {
+          parsedInput = JSON.parse(tc.arguments);
+        } catch {
+          const partial = parsePartialJson(tc.arguments);
+          parsedInput = partial ?? {};
+        }
+        snapshot.push({ id: tc.id, name: tc.name, input: parsedInput });
+      }
+      yield { type: "object-delta", port: "toolCalls", objectDelta: snapshot };
+    }
+  }
+  const toolCalls = [];
+  for (const [, tc] of toolCallAccumulator) {
+    let finalInput;
+    try {
+      finalInput = JSON.parse(tc.arguments);
+    } catch {
+      finalInput = parsePartialJson(tc.arguments) ?? {};
+    }
+    toolCalls.push({ id: tc.id, name: tc.name, input: finalInput });
+  }
+  const validToolCalls = filterValidToolCalls(toolCalls, input.tools);
+  yield {
+    type: "finish",
+    data: { text: accumulatedText, toolCalls: validToolCalls }
+  };
+};
+
+// src/provider-hf-inference/common/HFI_JobRunFns.ts
+var HFI_TASKS = {
+  ModelInfoTask: HFI_ModelInfo,
+  TextGenerationTask: HFI_TextGeneration,
+  TextEmbeddingTask: HFI_TextEmbedding,
+  TextRewriterTask: HFI_TextRewriter,
+  TextSummaryTask: HFI_TextSummary,
+  ToolCallingTask: HFI_ToolCalling,
+  ModelSearchTask: HFI_ModelSearch
+};
+var HFI_STREAM_TASKS = {
+  TextGenerationTask: HFI_TextGeneration_Stream,
+  TextRewriterTask: HFI_TextRewriter_Stream,
+  TextSummaryTask: HFI_TextSummary_Stream,
+  ToolCallingTask: HFI_ToolCalling_Stream
+};
+
+// src/provider-hf-inference/HfInferenceQueuedProvider.ts
+import {
+  QueuedAiProvider
+} from "@workglow/ai";
+class HfInferenceQueuedProvider extends QueuedAiProvider {
+  name = HF_INFERENCE;
+  isLocal = false;
+  supportsBrowser = true;
+  taskTypes = [
+    "ModelInfoTask",
+    "TextGenerationTask",
+    "TextEmbeddingTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "ToolCallingTask",
+    "ModelSearchTask"
+  ];
+  constructor(tasks, streamTasks, reactiveTasks) {
+    super(tasks, streamTasks, reactiveTasks);
+  }
+}
+
+// src/provider-hf-inference/registerHfInferenceInline.ts
+async function registerHfInferenceInline(options) {
+  await new HfInferenceQueuedProvider(HFI_TASKS, HFI_STREAM_TASKS).register(options ?? {});
+}
+// src/provider-hf-inference/registerHfInferenceWorker.ts
+import { getLogger as getLogger6, globalServiceRegistry, WORKER_SERVER } from "@workglow/util/worker";
+
+// src/provider-hf-inference/HfInferenceProvider.ts
+import {
+  AiProvider
+} from "@workglow/ai/worker";
+class HfInferenceProvider extends AiProvider {
+  name = HF_INFERENCE;
+  isLocal = false;
+  supportsBrowser = true;
+  taskTypes = [
+    "ModelInfoTask",
+    "TextGenerationTask",
+    "TextEmbeddingTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "ToolCallingTask",
+    "ModelSearchTask"
+  ];
+  constructor(tasks, streamTasks, reactiveTasks) {
+    super(tasks, streamTasks, reactiveTasks);
+  }
+}
+
+// src/provider-hf-inference/registerHfInferenceWorker.ts
+async function registerHfInferenceWorker() {
+  const workerServer = globalServiceRegistry.get(WORKER_SERVER);
+  new HfInferenceProvider(HFI_TASKS, HFI_STREAM_TASKS).registerOnWorkerServer(workerServer);
+  workerServer.sendReady();
+  getLogger6().info("Hugging Face Inference worker job run functions registered");
+}
+export {
+  registerHfInferenceWorker,
+  registerHfInferenceInline,
+  loadHfInferenceSDK,
+  getProvider,
+  getModelName,
+  getClient
+};
+
+//# debugId=5FD912978007B88564756E2164756E21