@workglow/ai-provider 0.0.121 → 0.0.123

package/dist/provider-openai/runtime.browser.js

@@ -0,0 +1,647 @@
+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-openai/common/OpenAI_Client.ts
+var _OpenAIClass;
+async function loadOpenAISDK() {
+  if (!_OpenAIClass) {
+    try {
+      const sdk = await import("openai");
+      _OpenAIClass = sdk.default;
+    } catch {
+      throw new Error("openai is required for OpenAI tasks. Install it with: bun add openai");
+    }
+  }
+  return _OpenAIClass;
+}
+async function getClient(model) {
+  const OpenAI = await loadOpenAISDK();
+  const config = model?.provider_config;
+  const apiKey = config?.credential_key || config?.api_key || (typeof process !== "undefined" ? process.env?.OPENAI_API_KEY : undefined);
+  if (!apiKey) {
+    throw new Error("Missing OpenAI API key: set provider_config.credential_key or the OPENAI_API_KEY environment variable.");
+  }
+  return new OpenAI({
+    apiKey,
+    baseURL: config?.base_url || undefined,
+    organization: config?.organization || undefined,
+    dangerouslyAllowBrowser: true
+  });
+}
+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;
+}
+// src/provider-openai/common/OpenAI_Constants.ts
+var OPENAI = "OPENAI";
+
+// src/provider-openai/common/OpenAI_ModelSearch.ts
+var OPENAI_FALLBACK = [
+  { label: "gpt-5.4", value: "gpt-5.4" },
+  { label: "gpt-5", value: "gpt-5" },
+  { label: "gpt-5-mini", value: "gpt-5-mini" },
+  { label: "gpt-4o-mini", value: "gpt-4o-mini" },
+  { label: "gpt-4-turbo", value: "gpt-4-turbo" },
+  { label: "o3", value: "o3" },
+  { label: "o3-mini", value: "o3-mini" },
+  { label: "o1", value: "o1" },
+  { label: "o1-mini", value: "o1-mini" }
+];
+async function listOpenAiModels() {
+  const client = await getClient(undefined);
+  const models = [];
+  for await (const m of client.models.list()) {
+    models.push({ label: `${m.id}  ${m.owned_by}`, value: m.id });
+  }
+  models.sort((a, b) => {
+    const aGpt = a.value.startsWith("gpt") || a.value.startsWith("o1") ? 0 : 1;
+    const bGpt = b.value.startsWith("gpt") || b.value.startsWith("o1") ? 0 : 1;
+    if (aGpt !== bGpt)
+      return aGpt - bGpt;
+    return a.value.localeCompare(b.value);
+  });
+  return models;
+}
+function mapModelList(models) {
+  return models.map((m) => ({
+    id: m.value,
+    label: m.label,
+    description: "",
+    record: {
+      model_id: m.value,
+      provider: OPENAI,
+      title: m.value,
+      description: "",
+      tasks: [],
+      provider_config: { model_name: m.value },
+      metadata: {}
+    },
+    raw: m
+  }));
+}
+var OpenAI_ModelSearch = async () => {
+  let models;
+  try {
+    models = await listOpenAiModels();
+  } catch {
+    models = OPENAI_FALLBACK;
+  }
+  return { results: mapModelList(models) };
+};
+
+// src/provider-openai/common/OpenAI_CountTokens.browser.ts
+import { getLogger } from "@workglow/util/worker";
+var _tiktoken;
+async function loadTiktoken() {
+  if (!_tiktoken) {
+    try {
+      _tiktoken = await import("js-tiktoken");
+    } catch {
+      throw new Error("js-tiktoken is required for OpenAI token counting in the browser. Install it with: bun add js-tiktoken");
+    }
+  }
+  return _tiktoken;
+}
+var _encoderCache = new Map;
+async function getEncoder(modelName) {
+  const tiktoken = await loadTiktoken();
+  if (!_encoderCache.has(modelName)) {
+    try {
+      _encoderCache.set(modelName, tiktoken.encodingForModel(modelName));
+    } catch {
+      const fallback = "cl100k_base";
+      if (!_encoderCache.has(fallback)) {
+        _encoderCache.set(fallback, tiktoken.getEncoding(fallback));
+      }
+      _encoderCache.set(modelName, _encoderCache.get(fallback));
+    }
+  }
+  return _encoderCache.get(modelName);
+}
+var OpenAI_CountTokens = async (input, model) => {
+  if (Array.isArray(input.text)) {
+    getLogger().warn("OpenAI_CountTokens: array input received; processing sequentially (no native batch support)");
+    const texts = input.text;
+    const counts = [];
+    for (const item of texts) {
+      const r = await OpenAI_CountTokens({ ...input, text: item }, model, () => {}, new AbortController().signal);
+      counts.push(r.count);
+    }
+    return { count: counts };
+  }
+  const enc = await getEncoder(getModelName(model));
+  const tokens = enc.encode(input.text);
+  return { count: tokens.length };
+};
+var OpenAI_CountTokens_Reactive = async (input, _output, model) => {
+  return OpenAI_CountTokens(input, model, () => {}, new AbortController().signal);
+};
+
+// src/provider-openai/common/OpenAI_ModelInfo.ts
+var OpenAI_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-openai/common/OpenAI_StructuredGeneration.ts
+import { parsePartialJson } from "@workglow/util/worker";
+var OpenAI_StructuredGeneration = async (input, model, update_progress, signal, outputSchema) => {
+  update_progress(0, "Starting OpenAI structured generation");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const schema = input.outputSchema ?? outputSchema;
+  const response = await client.chat.completions.create({
+    model: modelName,
+    messages: [{ role: "user", content: input.prompt }],
+    response_format: {
+      type: "json_schema",
+      json_schema: {
+        name: "structured_output",
+        schema,
+        strict: true
+      }
+    },
+    max_completion_tokens: input.maxTokens,
+    temperature: input.temperature
+  }, { signal });
+  const content = response.choices[0]?.message?.content ?? "{}";
+  update_progress(100, "Completed OpenAI structured generation");
+  return { object: JSON.parse(content) };
+};
+var OpenAI_StructuredGeneration_Stream = async function* (input, model, signal, outputSchema) {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const schema = input.outputSchema ?? outputSchema;
+  const stream = await client.chat.completions.create({
+    model: modelName,
+    messages: [{ role: "user", content: input.prompt }],
+    response_format: {
+      type: "json_schema",
+      json_schema: {
+        name: "structured_output",
+        schema,
+        strict: true
+      }
+    },
+    max_completion_tokens: input.maxTokens,
+    temperature: input.temperature,
+    stream: true
+  }, { signal });
+  let accumulatedJson = "";
+  for await (const chunk of stream) {
+    const delta = chunk.choices[0]?.delta?.content ?? "";
+    if (delta) {
+      accumulatedJson += delta;
+      const partial = parsePartialJson(accumulatedJson);
+      if (partial !== undefined) {
+        yield { type: "object-delta", port: "object", objectDelta: partial };
+      }
+    }
+  }
+  let finalObject;
+  try {
+    finalObject = JSON.parse(accumulatedJson);
+  } catch {
+    finalObject = parsePartialJson(accumulatedJson) ?? {};
+  }
+  yield { type: "finish", data: { object: finalObject } };
+};
+
+// src/provider-openai/common/OpenAI_TextEmbedding.ts
+import { getLogger as getLogger2 } from "@workglow/util/worker";
+var OpenAI_TextEmbedding = async (input, model, update_progress, signal) => {
+  const logger = getLogger2();
+  const timerLabel = `openai:TextEmbedding:${model?.provider_config?.model_name}`;
+  logger.time(timerLabel, { model: model?.provider_config?.model_name });
+  update_progress(0, "Starting OpenAI text embedding");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const response = await client.embeddings.create({
+    model: modelName,
+    input: input.text
+  }, { signal });
+  update_progress(100, "Completed OpenAI text embedding");
+  logger.timeEnd(timerLabel, { model: model?.provider_config?.model_name });
+  if (Array.isArray(input.text)) {
+    return {
+      vector: response.data.map((item) => new Float32Array(item.embedding))
+    };
+  }
+  return { vector: new Float32Array(response.data[0].embedding) };
+};
+
+// src/provider-openai/common/OpenAI_TextGeneration.ts
+import { getLogger as getLogger3 } from "@workglow/util/worker";
+var OpenAI_TextGeneration = async (input, model, update_progress, signal) => {
+  if (Array.isArray(input.prompt)) {
+    getLogger3().warn("OpenAI_TextGeneration: array input received; processing sequentially (no native batch support)");
+    const prompts = input.prompt;
+    const results = [];
+    for (const item of prompts) {
+      const r = await OpenAI_TextGeneration({ ...input, prompt: item }, model, update_progress, signal);
+      results.push(r.text);
+    }
+    return { text: results };
+  }
+  const logger = getLogger3();
+  const timerLabel = `openai:TextGeneration:${model?.provider_config?.model_name}`;
+  logger.time(timerLabel, { model: model?.provider_config?.model_name });
+  update_progress(0, "Starting OpenAI text generation");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const response = await client.chat.completions.create({
+    model: modelName,
+    messages: [{ role: "user", content: input.prompt }],
+    max_completion_tokens: input.maxTokens,
+    temperature: input.temperature,
+    top_p: input.topP,
+    frequency_penalty: input.frequencyPenalty,
+    presence_penalty: input.presencePenalty
+  }, { signal });
+  update_progress(100, "Completed OpenAI text generation");
+  logger.timeEnd(timerLabel, { model: model?.provider_config?.model_name });
+  return { text: response.choices[0]?.message?.content ?? "" };
+};
+var OpenAI_TextGeneration_Stream = async function* (input, model, signal) {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const stream = await client.chat.completions.create({
+    model: modelName,
+    messages: [{ role: "user", content: input.prompt }],
+    max_completion_tokens: input.maxTokens,
+    temperature: input.temperature,
+    top_p: input.topP,
+    frequency_penalty: input.frequencyPenalty,
+    presence_penalty: input.presencePenalty,
+    stream: true
+  }, { 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-openai/common/OpenAI_TextRewriter.ts
+import { getLogger as getLogger4 } from "@workglow/util/worker";
+var OpenAI_TextRewriter = async (input, model, update_progress, signal) => {
+  if (Array.isArray(input.text)) {
+    getLogger4().warn("OpenAI_TextRewriter: array input received; processing sequentially (no native batch support)");
+    const texts = input.text;
+    const results = [];
+    for (const item of texts) {
+      const r = await OpenAI_TextRewriter({ ...input, text: item }, model, update_progress, signal);
+      results.push(r.text);
+    }
+    return { text: results };
+  }
+  update_progress(0, "Starting OpenAI text rewriting");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const response = await client.chat.completions.create({
+    model: modelName,
+    messages: [
+      { role: "system", content: input.prompt },
+      { role: "user", content: input.text }
+    ]
+  }, { signal });
+  update_progress(100, "Completed OpenAI text rewriting");
+  return { text: response.choices[0]?.message?.content ?? "" };
+};
+var OpenAI_TextRewriter_Stream = async function* (input, model, signal) {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const stream = await client.chat.completions.create({
+    model: modelName,
+    messages: [
+      { role: "system", content: input.prompt },
+      { role: "user", content: input.text }
+    ],
+    stream: true
+  }, { 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-openai/common/OpenAI_TextSummary.ts
+import { getLogger as getLogger5 } from "@workglow/util/worker";
+var OpenAI_TextSummary = async (input, model, update_progress, signal) => {
+  if (Array.isArray(input.text)) {
+    getLogger5().warn("OpenAI_TextSummary: array input received; processing sequentially (no native batch support)");
+    const texts = input.text;
+    const results = [];
+    for (const item of texts) {
+      const r = await OpenAI_TextSummary({ ...input, text: item }, model, update_progress, signal);
+      results.push(r.text);
+    }
+    return { text: results };
+  }
+  update_progress(0, "Starting OpenAI text summarization");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const response = await client.chat.completions.create({
+    model: modelName,
+    messages: [
+      { role: "system", content: "Summarize the following text concisely." },
+      { role: "user", content: input.text }
+    ]
+  }, { signal });
+  update_progress(100, "Completed OpenAI text summarization");
+  return { text: response.choices[0]?.message?.content ?? "" };
+};
+var OpenAI_TextSummary_Stream = async function* (input, model, signal) {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const stream = await client.chat.completions.create({
+    model: modelName,
+    messages: [
+      { role: "system", content: "Summarize the following text concisely." },
+      { role: "user", content: input.text }
+    ],
+    stream: true
+  }, { 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-openai/common/OpenAI_ToolCalling.ts
+import { buildToolDescription, filterValidToolCalls, toOpenAIMessages } from "@workglow/ai/worker";
+import { getLogger as getLogger6, parsePartialJson as parsePartialJson2 } from "@workglow/util/worker";
+function mapOpenAIToolChoice(toolChoice) {
+  if (!toolChoice || toolChoice === "auto")
+    return "auto";
+  if (toolChoice === "none")
+    return "none";
+  if (toolChoice === "required")
+    return "required";
+  return { type: "function", function: { name: toolChoice } };
+}
+var OpenAI_ToolCalling = async (input, model, update_progress, signal) => {
+  if (Array.isArray(input.prompt)) {
+    getLogger6().warn("OpenAI_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 OpenAI_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 OpenAI tool calling");
+  const client = await getClient(model);
+  const modelName = getModelName(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 = mapOpenAIToolChoice(input.toolChoice);
+  const params = {
+    model: modelName,
+    messages,
+    max_completion_tokens: input.maxTokens,
+    temperature: input.temperature
+  };
+  if (toolChoice !== undefined) {
+    params.tools = tools;
+    params.tool_choice = toolChoice;
+  }
+  const response = await client.chat.completions.create(params, { signal });
+  const text = response.choices[0]?.message?.content ?? "";
+  const toolCalls = [];
+  for (const tc of response.choices[0]?.message?.tool_calls ?? []) {
+    if (!("function" in tc))
+      continue;
+    const id = tc.id;
+    const name = tc.function.name;
+    let inputArgs = {};
+    const rawArgs = tc.function.arguments;
+    if (typeof rawArgs === "string") {
+      try {
+        inputArgs = JSON.parse(rawArgs);
+      } catch {
+        try {
+          const partial = parsePartialJson2(rawArgs);
+          if (partial && typeof partial === "object") {
+            inputArgs = partial;
+          }
+        } catch {
+          inputArgs = {};
+        }
+      }
+    }
+    toolCalls.push({ id, name, input: inputArgs });
+  }
+  update_progress(100, "Completed OpenAI tool calling");
+  return { text, toolCalls: filterValidToolCalls(toolCalls, input.tools) };
+};
+var OpenAI_ToolCalling_Stream = async function* (input, model, signal) {
+  const client = await getClient(model);
+  const modelName = getModelName(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 = mapOpenAIToolChoice(input.toolChoice);
+  const stream = await client.chat.completions.create({
+    model: modelName,
+    messages,
+    max_completion_tokens: input.maxTokens,
+    temperature: input.temperature,
+    stream: true,
+    ...toolChoice !== undefined ? { tools, tool_choice: toolChoice } : {}
+  }, { 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 = parsePartialJson2(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 = parsePartialJson2(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-openai/common/OpenAI_JobRunFns.browser.ts
+var OPENAI_TASKS = {
+  TextGenerationTask: OpenAI_TextGeneration,
+  ModelInfoTask: OpenAI_ModelInfo,
+  TextEmbeddingTask: OpenAI_TextEmbedding,
+  TextRewriterTask: OpenAI_TextRewriter,
+  TextSummaryTask: OpenAI_TextSummary,
+  CountTokensTask: OpenAI_CountTokens,
+  StructuredGenerationTask: OpenAI_StructuredGeneration,
+  ToolCallingTask: OpenAI_ToolCalling,
+  ModelSearchTask: OpenAI_ModelSearch
+};
+var OPENAI_STREAM_TASKS = {
+  TextGenerationTask: OpenAI_TextGeneration_Stream,
+  TextRewriterTask: OpenAI_TextRewriter_Stream,
+  TextSummaryTask: OpenAI_TextSummary_Stream,
+  StructuredGenerationTask: OpenAI_StructuredGeneration_Stream,
+  ToolCallingTask: OpenAI_ToolCalling_Stream
+};
+var OPENAI_REACTIVE_TASKS = {
+  CountTokensTask: OpenAI_CountTokens_Reactive
+};
+
+// src/provider-openai/OpenAiQueuedProvider.ts
+import {
+  QueuedAiProvider
+} from "@workglow/ai";
+class OpenAiQueuedProvider extends QueuedAiProvider {
+  name = OPENAI;
+  isLocal = false;
+  supportsBrowser = true;
+  taskTypes = [
+    "TextGenerationTask",
+    "TextEmbeddingTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "CountTokensTask",
+    "ModelInfoTask",
+    "StructuredGenerationTask",
+    "ToolCallingTask",
+    "ModelSearchTask"
+  ];
+  constructor(tasks, streamTasks, reactiveTasks) {
+    super(tasks, streamTasks, reactiveTasks);
+  }
+}
+
+// src/provider-openai/registerOpenAiInline.browser.ts
+async function registerOpenAiInline(options) {
+  await new OpenAiQueuedProvider(OPENAI_TASKS, OPENAI_STREAM_TASKS, OPENAI_REACTIVE_TASKS).register(options ?? {});
+}
+// src/provider-openai/registerOpenAiWorker.browser.ts
+import { getLogger as getLogger7, globalServiceRegistry, WORKER_SERVER } from "@workglow/util/worker";
+
+// src/provider-openai/OpenAiProvider.ts
+import {
+  AiProvider
+} from "@workglow/ai/worker";
+class OpenAiProvider extends AiProvider {
+  name = OPENAI;
+  isLocal = false;
+  supportsBrowser = true;
+  taskTypes = [
+    "TextGenerationTask",
+    "TextEmbeddingTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "CountTokensTask",
+    "ModelInfoTask",
+    "StructuredGenerationTask",
+    "ToolCallingTask",
+    "ModelSearchTask"
+  ];
+  constructor(tasks, streamTasks, reactiveTasks) {
+    super(tasks, streamTasks, reactiveTasks);
+  }
+}
+
+// src/provider-openai/registerOpenAiWorker.browser.ts
+async function registerOpenAiWorker() {
+  const workerServer = globalServiceRegistry.get(WORKER_SERVER);
+  new OpenAiProvider(OPENAI_TASKS, OPENAI_STREAM_TASKS, OPENAI_REACTIVE_TASKS).registerOnWorkerServer(workerServer);
+  workerServer.sendReady();
+  getLogger7().info("OpenAI worker job run functions registered");
+}
+export {
+  registerOpenAiWorker,
+  registerOpenAiInline,
+  loadOpenAISDK,
+  getModelName,
+  getClient
+};
+
+//# debugId=866D6CD3BDFA2E1164756E2164756E21