@workglow/openai 0.2.28

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

@@ -0,0 +1,866 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/ai-provider/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.");
+  }
+  try {
+    return new OpenAI({
+      apiKey,
+      baseURL: config?.base_url || undefined,
+      organization: config?.organization || undefined,
+      dangerouslyAllowBrowser: typeof globalThis.document !== "undefined" || "WorkerGlobalScope" in globalThis
+    });
+  } catch (err) {
+    throw new Error(`Failed to create OpenAI client: ${err instanceof Error ? err.message : "unknown error"}`);
+  }
+}
+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/ai-provider/registerOpenAiInline.browser.ts
+import { registerProviderInline } from "@workglow/ai-provider/common";
+
+// src/ai-provider/common/OpenAI_ModelSearch.ts
+import { filterLabeledModelsByQuery } from "@workglow/ai-provider/common";
+
+// src/ai-provider/common/OpenAI_Constants.ts
+var OPENAI = "OPENAI";
+
+// src/ai-provider/common/OpenAI_ModelSearch.ts
+var OPENAI_FALLBACK = [
+  { label: "gpt-image-2", value: "gpt-image-2" },
+  { label: "dall-e-3", value: "dall-e-3" },
+  { label: "gpt-5.5", value: "gpt-5.5" },
+  { label: "gpt-5.4-mini", value: "gpt-5.4-mini" },
+  { label: "gpt-5.4-nano", value: "gpt-5.4-nano" },
+  { 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" }
+];
+var OPENAI_IMAGE_MODELS = [
+  { value: "gpt-image-2", tasks: ["ImageGenerateTask", "ImageEditTask"] },
+  { value: "dall-e-3", tasks: ["ImageGenerateTask"] }
+];
+async function listOpenAiModels(credentialKey) {
+  const client = await getClient({
+    provider: OPENAI,
+    provider_config: { model_name: "", credential_key: credentialKey }
+  });
+  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) => {
+    const imageEntry = OPENAI_IMAGE_MODELS.find((i) => i.value === m.value);
+    return {
+      id: m.value,
+      label: m.label,
+      description: "",
+      record: {
+        model_id: m.value,
+        provider: OPENAI,
+        title: m.value,
+        description: "",
+        tasks: imageEntry?.tasks ?? [],
+        provider_config: { model_name: m.value },
+        metadata: {}
+      },
+      raw: m
+    };
+  });
+}
+var OpenAI_ModelSearch = async (input) => {
+  let models;
+  if (!input.credential_key) {
+    models = OPENAI_FALLBACK;
+  } else {
+    models = await listOpenAiModels(input.credential_key);
+  }
+  models = filterLabeledModelsByQuery(models, input.query);
+  return { results: mapModelList(models) };
+};
+
+// src/ai-provider/common/OpenAI_CountTokens.browser.ts
+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) => {
+  const enc = await getEncoder(getModelName(model));
+  const tokens = enc.encode(input.text);
+  return { count: tokens.length };
+};
+var OpenAI_CountTokens_Preview = async (input, model) => {
+  return OpenAI_CountTokens(input, model, () => {}, new AbortController().signal);
+};
+
+// src/ai-provider/common/OpenAI_ModelInfo.ts
+var OPENAI_EMBEDDING_DIMENSIONS = {
+  "text-embedding-3-small": { native_dimensions: 1536, mrl: true },
+  "text-embedding-3-large": { native_dimensions: 3072, mrl: true },
+  "text-embedding-ada-002": { native_dimensions: 1536, mrl: false }
+};
+var OpenAI_ModelInfo = async (input, model) => {
+  if (input.detail === "dimensions") {
+    const pc = model?.provider_config;
+    let native_dimensions = typeof pc?.native_dimensions === "number" ? pc.native_dimensions : undefined;
+    let mrl = typeof pc?.mrl === "boolean" ? pc.mrl : undefined;
+    if (native_dimensions === undefined) {
+      const modelName = pc?.model_name ?? "";
+      const known = OPENAI_EMBEDDING_DIMENSIONS[modelName];
+      if (known) {
+        native_dimensions = known.native_dimensions;
+        mrl = mrl ?? known.mrl;
+      }
+    }
+    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,
+      ...native_dimensions !== undefined ? { native_dimensions } : {},
+      ...mrl !== undefined ? { mrl } : {}
+    };
+  }
+  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/ai-provider/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/ai-provider/common/OpenAI_TextEmbedding.ts
+import { getLogger } from "@workglow/util/worker";
+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) };
+};
+
+// src/ai-provider/common/OpenAI_TextGeneration.ts
+import { getLogger as getLogger2 } from "@workglow/util/worker";
+var OpenAI_TextGeneration = async (input, model, update_progress, signal) => {
+  const logger = getLogger2();
+  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/ai-provider/common/OpenAI_TextRewriter.ts
+var OpenAI_TextRewriter = async (input, model, update_progress, signal) => {
+  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/ai-provider/common/OpenAI_TextSummary.ts
+var OpenAI_TextSummary = async (input, model, update_progress, signal) => {
+  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/ai-provider/common/OpenAI_ToolCalling.ts
+import { buildToolDescription, filterValidToolCalls, toOpenAIMessages } from "@workglow/ai/worker";
+import { 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) => {
+  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
+  };
+  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 toolOptions = toolChoice === undefined ? {} : { tools, tool_choice: toolChoice };
+  const stream = await client.chat.completions.create({
+    model: modelName,
+    messages,
+    max_completion_tokens: input.maxTokens,
+    temperature: input.temperature,
+    stream: true,
+    ...toolOptions
+  }, { signal });
+  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) {
+      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;
+        let parsedInput;
+        try {
+          parsedInput = JSON.parse(acc.arguments);
+        } catch {
+          const partial = parsePartialJson2(acc.arguments);
+          parsedInput = partial ?? {};
+        }
+        yield {
+          type: "object-delta",
+          port: "toolCalls",
+          objectDelta: [{ id: acc.id, name: acc.name, input: parsedInput }]
+        };
+      }
+    }
+  }
+  yield { type: "finish", data: { text: "", toolCalls: [] } };
+};
+
+// src/ai-provider/common/OpenAI_ImageGenerate.ts
+import { ImageGenerationContentPolicyError, ImageGenerationProviderError } from "@workglow/ai";
+import { getLogger as getLogger3 } from "@workglow/util/worker";
+import { dataUriToImageValue } from "@workglow/ai-provider/common";
+function aspectRatioToSize(aspectRatio) {
+  switch (aspectRatio) {
+    case "16:9":
+    case "4:3":
+      return "1536x1024";
+    case "9:16":
+    case "3:4":
+      return "1024x1536";
+    case "1:1":
+    default:
+      return "1024x1024";
+  }
+}
+async function decodeB64Png(b64) {
+  return dataUriToImageValue(`data:image/png;base64,${b64}`);
+}
+function modelIdOf(model) {
+  return model?.model_id ?? model?.provider_config?.model_name ?? "openai";
+}
+var OpenAI_ImageGenerate = async (input, model, update_progress, signal) => {
+  const logger = getLogger3();
+  const timer = `openai:ImageGenerate:${getModelName(model)}`;
+  logger.time(timer);
+  update_progress(0, "Starting OpenAI image generation");
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const size = aspectRatioToSize(input.aspectRatio);
+  try {
+    const resp = await client.images.generate({
+      model: modelName,
+      prompt: input.prompt,
+      size,
+      quality: input.quality,
+      n: 1,
+      response_format: "b64_json",
+      ...input.providerOptions ?? {}
+    }, { signal });
+    const b64 = resp.data?.[0]?.b64_json;
+    if (!b64) {
+      throw new ImageGenerationProviderError(modelIdOf(model), "Empty response (no b64_json)");
+    }
+    const image = await decodeB64Png(b64);
+    update_progress(100, "Completed OpenAI image generation");
+    logger.timeEnd(timer);
+    return { image };
+  } catch (err) {
+    if (err instanceof ImageGenerationProviderError || err instanceof ImageGenerationContentPolicyError) {
+      throw err;
+    }
+    const msg = err instanceof Error ? err.message : "unknown error";
+    if (/safety|policy|moderation/i.test(msg)) {
+      throw new ImageGenerationContentPolicyError(modelIdOf(model), msg);
+    }
+    throw new ImageGenerationProviderError(modelIdOf(model), msg, { cause: err });
+  }
+};
+var OpenAI_ImageGenerate_Stream = async function* (input, model, signal) {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const size = aspectRatioToSize(input.aspectRatio);
+  if (modelName.startsWith("dall-e")) {
+    try {
+      const resp = await client.images.generate({
+        model: modelName,
+        prompt: input.prompt,
+        size,
+        quality: input.quality,
+        n: 1,
+        response_format: "b64_json",
+        ...input.providerOptions ?? {}
+      }, { signal });
+      const b64 = resp.data?.[0]?.b64_json;
+      if (!b64) {
+        throw new ImageGenerationProviderError(modelIdOf(model), "Empty response (no b64_json)");
+      }
+      const image = await decodeB64Png(b64);
+      yield { type: "snapshot", data: { image } };
+      yield { type: "finish", data: {} };
+      return;
+    } catch (err) {
+      if (err instanceof ImageGenerationProviderError || err instanceof ImageGenerationContentPolicyError) {
+        throw err;
+      }
+      const msg = err instanceof Error ? err.message : "unknown error";
+      if (/safety|policy|moderation/i.test(msg)) {
+        throw new ImageGenerationContentPolicyError(modelIdOf(model), msg);
+      }
+      throw new ImageGenerationProviderError(modelIdOf(model), msg, { cause: err });
+    }
+  }
+  try {
+    const stream = await client.images.generate({
+      model: modelName,
+      prompt: input.prompt,
+      size,
+      quality: input.quality,
+      n: 1,
+      stream: true,
+      partial_images: 3,
+      ...input.providerOptions ?? {}
+    }, { signal });
+    for await (const event of stream) {
+      if (signal.aborted)
+        return;
+      const b64 = event.b64_json;
+      if (!b64)
+        continue;
+      const image = await decodeB64Png(b64);
+      yield { type: "snapshot", data: { image } };
+    }
+    yield { type: "finish", data: {} };
+  } catch (err) {
+    if (err instanceof ImageGenerationProviderError || err instanceof ImageGenerationContentPolicyError) {
+      throw err;
+    }
+    const msg = err instanceof Error ? err.message : "unknown error";
+    if (/safety|policy|moderation/i.test(msg)) {
+      throw new ImageGenerationContentPolicyError(modelIdOf(model), msg);
+    }
+    throw new ImageGenerationProviderError(modelIdOf(model), msg, { cause: err });
+  }
+};
+
+// src/ai-provider/common/OpenAI_ImageEdit.ts
+import { ImageGenerationContentPolicyError as ImageGenerationContentPolicyError2, ImageGenerationProviderError as ImageGenerationProviderError2 } from "@workglow/ai";
+import { getLogger as getLogger4 } from "@workglow/util/worker";
+import { dataUriToImageValue as dataUriToImageValue2, imageValueToPngBytes } from "@workglow/ai-provider/common";
+function aspectRatioToSize2(aspectRatio) {
+  switch (aspectRatio) {
+    case "16:9":
+    case "4:3":
+      return "1536x1024";
+    case "9:16":
+    case "3:4":
+      return "1024x1536";
+    case "1:1":
+    default:
+      return "1024x1024";
+  }
+}
+function modelIdOf2(model) {
+  return model?.model_id ?? model?.provider_config?.model_name ?? "openai";
+}
+async function gpuImageToOpenAiFile(image, name) {
+  const bytes = await imageValueToPngBytes(image);
+  const buffer = bytes.buffer instanceof ArrayBuffer ? bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) : new Uint8Array(bytes).buffer;
+  const sdk = await import("openai");
+  if (typeof sdk.toFile === "function") {
+    return sdk.toFile(new Blob([buffer], { type: "image/png" }), name, { type: "image/png" });
+  }
+  return new File([buffer], name, { type: "image/png" });
+}
+async function decodeB64Png2(b64) {
+  return dataUriToImageValue2(`data:image/png;base64,${b64}`);
+}
+async function buildEditPayload(input, model) {
+  const modelName = getModelName(model);
+  const primary = await gpuImageToOpenAiFile(input.image, "image.png");
+  const additionalFiles = input.additionalImages && input.additionalImages.length > 0 ? await Promise.all(input.additionalImages.map((g, i) => gpuImageToOpenAiFile(g, `image-${i + 1}.png`))) : [];
+  const imageField = additionalFiles.length === 0 ? primary : [primary, ...additionalFiles];
+  const payload = {
+    model: modelName,
+    prompt: input.prompt,
+    image: imageField,
+    size: aspectRatioToSize2(input.aspectRatio),
+    quality: input.quality,
+    n: 1,
+    ...input.providerOptions ?? {}
+  };
+  if (input.mask) {
+    payload.mask = await gpuImageToOpenAiFile(input.mask, "mask.png");
+  }
+  return payload;
+}
+var OpenAI_ImageEdit = async (input, model, update_progress, signal) => {
+  const logger = getLogger4();
+  const timer = `openai:ImageEdit:${getModelName(model)}`;
+  logger.time(timer);
+  update_progress(0, "Starting OpenAI image edit");
+  const client = await getClient(model);
+  try {
+    const payload = await buildEditPayload(input, model);
+    const resp = await client.images.edit(payload, { signal });
+    const b64 = resp.data?.[0]?.b64_json;
+    if (!b64) {
+      throw new ImageGenerationProviderError2(modelIdOf2(model), "Empty response (no b64_json)");
+    }
+    const image = await decodeB64Png2(b64);
+    update_progress(100, "Completed OpenAI image edit");
+    logger.timeEnd(timer);
+    return { image };
+  } catch (err) {
+    if (err instanceof ImageGenerationProviderError2 || err instanceof ImageGenerationContentPolicyError2) {
+      throw err;
+    }
+    const msg = err instanceof Error ? err.message : "unknown error";
+    if (/safety|policy|moderation/i.test(msg)) {
+      throw new ImageGenerationContentPolicyError2(modelIdOf2(model), msg);
+    }
+    throw new ImageGenerationProviderError2(modelIdOf2(model), msg, { cause: err });
+  }
+};
+var OpenAI_ImageEdit_Stream = async function* (input, model, signal) {
+  const client = await getClient(model);
+  try {
+    const payload = await buildEditPayload(input, model);
+    const stream = await client.images.edit({ ...payload, stream: true, partial_images: 3 }, { signal });
+    for await (const event of stream) {
+      if (signal.aborted)
+        return;
+      const b64 = event.b64_json;
+      if (!b64)
+        continue;
+      const image = await decodeB64Png2(b64);
+      yield { type: "snapshot", data: { image } };
+    }
+    yield { type: "finish", data: {} };
+  } catch (err) {
+    if (err instanceof ImageGenerationProviderError2 || err instanceof ImageGenerationContentPolicyError2) {
+      throw err;
+    }
+    const msg = err instanceof Error ? err.message : "unknown error";
+    if (/safety|policy|moderation/i.test(msg)) {
+      throw new ImageGenerationContentPolicyError2(modelIdOf2(model), msg);
+    }
+    throw new ImageGenerationProviderError2(modelIdOf2(model), msg, { cause: err });
+  }
+};
+
+// src/ai-provider/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,
+  ImageGenerateTask: OpenAI_ImageGenerate,
+  ImageEditTask: OpenAI_ImageEdit
+};
+var OPENAI_STREAM_TASKS = {
+  TextGenerationTask: OpenAI_TextGeneration_Stream,
+  TextRewriterTask: OpenAI_TextRewriter_Stream,
+  TextSummaryTask: OpenAI_TextSummary_Stream,
+  StructuredGenerationTask: OpenAI_StructuredGeneration_Stream,
+  ToolCallingTask: OpenAI_ToolCalling_Stream,
+  ImageGenerateTask: OpenAI_ImageGenerate_Stream,
+  ImageEditTask: OpenAI_ImageEdit_Stream
+};
+var OPENAI_PREVIEW_TASKS = {
+  CountTokensTask: OpenAI_CountTokens_Preview
+};
+
+// src/ai-provider/OpenAiQueuedProvider.ts
+import { AiProvider } from "@workglow/ai";
+class OpenAiQueuedProvider extends AiProvider {
+  name = OPENAI;
+  displayName = "OpenAI";
+  isLocal = false;
+  supportsBrowser = true;
+  taskTypes = [
+    "TextGenerationTask",
+    "TextEmbeddingTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "CountTokensTask",
+    "ModelInfoTask",
+    "StructuredGenerationTask",
+    "ToolCallingTask",
+    "ModelSearchTask",
+    "ImageGenerateTask",
+    "ImageEditTask"
+  ];
+  constructor(tasks, streamTasks, previewTasks) {
+    super(tasks, streamTasks, previewTasks);
+  }
+}
+
+// src/ai-provider/registerOpenAiInline.browser.ts
+async function registerOpenAiInline(options) {
+  await registerProviderInline(new OpenAiQueuedProvider(OPENAI_TASKS, OPENAI_STREAM_TASKS, OPENAI_PREVIEW_TASKS), "OpenAI", options);
+}
+
+// src/ai-provider/registerOpenAiWorker.browser.ts
+import { registerProviderWorker } from "@workglow/ai-provider/common";
+
+// src/ai-provider/OpenAiProvider.ts
+import { AiProvider as AiProvider2 } from "@workglow/ai/worker";
+class OpenAiProvider extends AiProvider2 {
+  name = OPENAI;
+  displayName = "OpenAI";
+  isLocal = false;
+  supportsBrowser = true;
+  taskTypes = [
+    "TextGenerationTask",
+    "TextEmbeddingTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "CountTokensTask",
+    "ModelInfoTask",
+    "StructuredGenerationTask",
+    "ToolCallingTask",
+    "ModelSearchTask"
+  ];
+  constructor(tasks, streamTasks, previewTasks) {
+    super(tasks, streamTasks, previewTasks);
+  }
+}
+
+// src/ai-provider/registerOpenAiWorker.browser.ts
+async function registerOpenAiWorker() {
+  await registerProviderWorker((ws) => new OpenAiProvider(OPENAI_TASKS, OPENAI_STREAM_TASKS, OPENAI_PREVIEW_TASKS).registerOnWorkerServer(ws), "OpenAI");
+}
+export {
+  registerOpenAiWorker,
+  registerOpenAiInline,
+  loadOpenAISDK,
+  getModelName,
+  getClient
+};
+
+//# debugId=745FF611DF3171FC64756E2164756E21