@workglow/ai-provider 0.0.121 → 0.0.123

package/dist/provider-openai/index.js

@@ -1,531 +1,120 @@
-import {
-  OPENAI,
-  OpenAiModelConfigSchema,
-  OpenAiModelRecordSchema,
-  OpenAiModelSchema,
-  OpenAiProvider
-} from "../index-q2t627d5.js";
-import {
-  __require
-} from "../index-6j5pq722.js";
-// src/provider-openai/common/OpenAI_JobRunFns.ts
-import { buildToolDescription, filterValidToolCalls, toOpenAIMessages } from "@workglow/ai";
-import { getLogger, parsePartialJson } from "@workglow/util";
-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;
-}
-var OpenAI_TextGeneration = async (input, model, update_progress, signal) => {
-  if (Array.isArray(input.prompt)) {
-    getLogger().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 = getLogger();
-  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_TextEmbedding = async (input, model, update_progress, signal) => {
-  const logger = getLogger();
-  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) };
-};
-var OpenAI_TextRewriter = async (input, model, update_progress, signal) => {
-  if (Array.isArray(input.text)) {
-    getLogger().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_TextSummary = async (input, model, update_progress, signal) => {
-  if (Array.isArray(input.text)) {
-    getLogger().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_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: {} };
-};
-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: {} };
-};
-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: {} };
-};
-var _tiktoken;
-async function loadTiktoken() {
-  if (!_tiktoken) {
-    try {
-      _tiktoken = await import("tiktoken");
-    } catch {
-      throw new Error("tiktoken is required for OpenAI token counting. Install it with: bun add tiktoken");
-    }
-  }
-  return _tiktoken;
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
 }
-var _encoderCache = new Map;
-async function getEncoder(modelName) {
-  const tiktoken = await loadTiktoken();
-  if (!_encoderCache.has(modelName)) {
-    try {
-      _encoderCache.set(modelName, tiktoken.encoding_for_model(modelName));
-    } catch {
-      const fallback = "cl100k_base";
-      if (!_encoderCache.has(fallback)) {
-        _encoderCache.set(fallback, tiktoken.get_encoding(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);
-};
-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
-      }
+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-openai/common/OpenAI_Constants.ts
+var OPENAI = "OPENAI";
+// src/provider-openai/common/OpenAI_ModelSchema.ts
+import { ModelConfigSchema, ModelRecordSchema } from "@workglow/ai/worker";
+var OpenAiModelSchema = {
+  type: "object",
+  properties: {
+    provider: {
+      const: OPENAI,
+      description: "Discriminator: OpenAI cloud provider."
     },
-    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 } };
-};
-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)) {
-    getLogger().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 input2 = {};
-    const rawArgs = tc.function.arguments;
-    if (typeof rawArgs === "string") {
-      try {
-        input2 = JSON.parse(rawArgs);
-      } catch {
-        try {
-          const partial = parsePartialJson(rawArgs);
-          if (partial && typeof partial === "object") {
-            input2 = partial;
-          }
-        } catch {
-          input2 = {};
+    provider_config: {
+      type: "object",
+      description: "OpenAI-specific configuration.",
+      properties: {
+        model_name: {
+          type: "string",
+          description: "The OpenAI model identifier (e.g., 'gpt-4o', 'text-embedding-3-small')."
+        },
+        credential_key: {
+          type: "string",
+          format: "credential",
+          description: "Key to look up in the credential store for the API key.",
+          "x-ui-hidden": true
+        },
+        base_url: {
+          type: "string",
+          description: "Base URL for the OpenAI API. Useful for Azure OpenAI or proxy servers.",
+          default: "https://api.openai.com/v1"
+        },
+        organization: {
+          type: "string",
+          description: "OpenAI organization ID (optional)."
         }
-      }
-    }
-    toolCalls.push({ id, name, input: input2 });
-  }
-  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 = 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 });
+      },
+      required: ["model_name"],
+      additionalProperties: false
+    }
+  },
+  required: ["provider", "provider_config"],
+  additionalProperties: true
+};
+var OpenAiModelRecordSchema = {
+  type: "object",
+  properties: {
+    ...ModelRecordSchema.properties,
+    ...OpenAiModelSchema.properties
+  },
+  required: [...ModelRecordSchema.required, ...OpenAiModelSchema.required],
+  additionalProperties: false
+};
+var OpenAiModelConfigSchema = {
+  type: "object",
+  properties: {
+    ...ModelConfigSchema.properties,
+    ...OpenAiModelSchema.properties
+  },
+  required: [...ModelConfigSchema.required, ...OpenAiModelSchema.required],
+  additionalProperties: false
+};
+// 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);
   }
-  const validToolCalls = filterValidToolCalls(toolCalls, input.tools);
-  yield {
-    type: "finish",
-    data: { text: accumulatedText, toolCalls: validToolCalls }
-  };
-};
-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
-  };
-};
-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
-};
-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/OpenAI_Worker.ts
-import { getLogger as getLogger2, globalServiceRegistry, WORKER_SERVER } from "@workglow/util";
-function OPENAI_WORKER_JOBRUN_REGISTER() {
-  const workerServer = globalServiceRegistry.get(WORKER_SERVER);
-  new OpenAiProvider(OPENAI_TASKS, OPENAI_STREAM_TASKS, OPENAI_REACTIVE_TASKS).registerOnWorkerServer(workerServer);
-  workerServer.sendReady();
-  getLogger2().info("OPENAI_WORKER_JOBRUN registered");
+}
+
+// src/provider-openai/registerOpenAi.ts
+async function registerOpenAi(options) {
+  await new OpenAiQueuedProvider().register(options);
 }
 export {
-  OpenAiProvider,
+  registerOpenAi,
   OpenAiModelSchema,
   OpenAiModelRecordSchema,
   OpenAiModelConfigSchema,
-  OpenAI_ToolCalling_Stream,
-  OpenAI_ToolCalling,
-  OpenAI_TextSummary_Stream,
-  OpenAI_TextSummary,
-  OpenAI_TextRewriter_Stream,
-  OpenAI_TextRewriter,
-  OpenAI_TextGeneration_Stream,
-  OpenAI_TextGeneration,
-  OpenAI_TextEmbedding,
-  OpenAI_StructuredGeneration_Stream,
-  OpenAI_StructuredGeneration,
-  OpenAI_ModelInfo,
-  OpenAI_CountTokens_Reactive,
-  OpenAI_CountTokens,
-  OPENAI_WORKER_JOBRUN_REGISTER,
-  OPENAI_TASKS,
-  OPENAI_STREAM_TASKS,
-  OPENAI_REACTIVE_TASKS,
   OPENAI
 };
 
-//# debugId=2A9DF0C31BD0127064756E2164756E21
+//# debugId=20B78D360783CD2F64756E2164756E21