@workglow/openai 0.2.34 → 0.2.35

package/dist/ai-runtime.browser.js

@@ -46,6 +46,290 @@ function getModelName(model) {
 // src/ai/registerOpenAiInline.browser.ts
 import { registerProviderInline } from "@workglow/ai/provider-utils";
 
+// src/ai/common/OpenAI_CapabilitySets.ts
+var OPENAI_TEXT_GENERATION = ["text.generation"];
+var OPENAI_TOOL_USE = ["text.generation", "tool-use"];
+var OPENAI_JSON_MODE = ["text.generation", "json-mode"];
+var OPENAI_TEXT_REWRITER = ["text.rewriter"];
+var OPENAI_TEXT_SUMMARY = ["text.summary"];
+var OPENAI_TEXT_EMBEDDING = ["text.embedding"];
+var OPENAI_IMAGE_GENERATION = ["image.generation"];
+var OPENAI_IMAGE_EDITING = ["image.editing"];
+var OPENAI_COUNT_TOKENS = ["model.count-tokens"];
+var OPENAI_MODEL_SEARCH = ["model.search"];
+var OPENAI_MODEL_INFO = ["model.info"];
+var OPENAI_CAPABILITY_SETS = [
+  OPENAI_TEXT_GENERATION,
+  OPENAI_TOOL_USE,
+  OPENAI_JSON_MODE,
+  OPENAI_TEXT_REWRITER,
+  OPENAI_TEXT_SUMMARY,
+  OPENAI_TEXT_EMBEDDING,
+  OPENAI_IMAGE_GENERATION,
+  OPENAI_IMAGE_EDITING,
+  OPENAI_COUNT_TOKENS,
+  OPENAI_MODEL_SEARCH,
+  OPENAI_MODEL_INFO
+];
+
+// src/ai/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);
+}
+async function countTokens(input, model) {
+  const enc = await getEncoder(getModelName(model));
+  const tokens = enc.encode(input.text);
+  return { count: tokens.length };
+}
+var OpenAI_CountTokens_Stream = async (input, model, _signal, emit) => {
+  const result = await countTokens(input, model);
+  emit({ type: "finish", data: result });
+};
+var OpenAI_CountTokens_Preview = async (input, model) => {
+  return countTokens(input, model);
+};
+
+// src/ai/common/OpenAI_ImageEdit.ts
+import { ImageGenerationContentPolicyError, ImageGenerationProviderError } from "@workglow/ai";
+import { dataUriToImageValue, imageValueToPngBytes } from "@workglow/ai/provider-utils";
+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";
+  }
+}
+function modelIdOf(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 decodeB64Png(b64) {
+  return dataUriToImageValue(`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: aspectRatioToSize(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_Stream = async (input, model, signal, emit) => {
+  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 decodeB64Png(b64);
+      emit({ type: "snapshot", data: { image } });
+    }
+    emit({ 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/common/OpenAI_ImageGenerate.ts
+import { ImageGenerationContentPolicyError as ImageGenerationContentPolicyError2, ImageGenerationProviderError as ImageGenerationProviderError2 } from "@workglow/ai";
+import { dataUriToImageValue as dataUriToImageValue2 } from "@workglow/ai/provider-utils";
+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";
+  }
+}
+async function decodeB64Png2(b64) {
+  return dataUriToImageValue2(`data:image/png;base64,${b64}`);
+}
+function modelIdOf2(model) {
+  return model?.model_id ?? model?.provider_config?.model_name ?? "openai";
+}
+var OpenAI_ImageGenerate_Stream = async (input, model, signal, emit) => {
+  const client = await getClient(model);
+  const modelName = getModelName(model);
+  const size = aspectRatioToSize2(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 ImageGenerationProviderError2(modelIdOf2(model), "Empty response (no b64_json)");
+      }
+      const image = await decodeB64Png2(b64);
+      emit({ type: "snapshot", data: { image } });
+      emit({ type: "finish", data: {} });
+      return;
+    } 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 });
+    }
+  }
+  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 decodeB64Png2(b64);
+      emit({ type: "snapshot", data: { image } });
+    }
+    emit({ 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/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_Stream = async (input, model, _signal, emit) => {
+  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;
+      }
+    }
+    emit({
+      type: "finish",
+      data: {
+        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;
+  }
+  emit({
+    type: "finish",
+    data: {
+      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/common/OpenAI_ModelSearch.ts
 import { filterLabeledModelsByQuery } from "@workglow/ai/provider-utils";
 
@@ -69,8 +353,8 @@ var OPENAI_FALLBACK = [
   { label: "o1-mini", value: "o1-mini" }
 ];
 var OPENAI_IMAGE_MODELS = [
-  { value: "gpt-image-2", tasks: ["ImageGenerateTask", "ImageEditTask"] },
-  { value: "dall-e-3", tasks: ["ImageGenerateTask"] }
+  { value: "gpt-image-2", capabilities: ["image.generation", "image.editing"] },
+  { value: "dall-e-3", capabilities: ["image.generation"] }
 ];
 async function listOpenAiModels(credentialKey) {
   const client = await getClient({
@@ -102,7 +386,7 @@ function mapModelList(models) {
         provider: OPENAI,
         title: m.value,
         description: "",
-        tasks: imageEntry?.tasks ?? [],
+        capabilities: imageEntry?.capabilities ?? [],
         provider_config: { model_name: m.value },
         metadata: {}
       },
@@ -110,7 +394,7 @@ function mapModelList(models) {
     };
   });
 }
-var OpenAI_ModelSearch = async (input) => {
+var OpenAI_ModelSearch_Stream = async (input, _model, _signal, emit) => {
   let models;
   if (!input.credential_key) {
     models = OPENAI_FALLBACK;
@@ -118,116 +402,12 @@ var OpenAI_ModelSearch = async (input) => {
     models = await listOpenAiModels(input.credential_key);
   }
   models = filterLabeledModelsByQuery(models, input.query);
-  return { results: mapModelList(models) };
-};
-
-// src/ai/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/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
-  };
+  emit({ type: "finish", data: { results: mapModelList(models) } });
 };
 
 // src/ai/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) {
+var OpenAI_StructuredGeneration_Stream = async (input, model, signal, emit, outputSchema) => {
   const client = await getClient(model);
   const modelName = getModelName(model);
   const schema = input.outputSchema ?? outputSchema;
@@ -253,7 +433,7 @@ var OpenAI_StructuredGeneration_Stream = async function* (input, model, signal,
       accumulatedJson += delta;
       const partial = parsePartialJson(accumulatedJson);
       if (partial !== undefined) {
-        yield { type: "object-delta", port: "object", objectDelta: partial };
+        emit({ type: "object-delta", port: "object", objectDelta: partial });
       }
     }
   }
@@ -263,92 +443,80 @@ var OpenAI_StructuredGeneration_Stream = async function* (input, model, signal,
   } catch {
     finalObject = parsePartialJson(accumulatedJson) ?? {};
   }
-  yield { type: "finish", data: { object: finalObject } };
+  emit({ type: "finish", data: { object: finalObject } });
 };
 
 // src/ai/common/OpenAI_TextEmbedding.ts
 import { getLogger } from "@workglow/util/worker";
-var OpenAI_TextEmbedding = async (input, model, update_progress, signal) => {
+var OpenAI_TextEmbedding_Stream = async (input, model, signal, emit) => {
   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 {
+  const timerLabel = `openai:TextEmbedding:${getModelName(model)}`;
+  logger.time(timerLabel, { model: getModelName(model) });
+  try {
+    const client = await getClient(model);
+    const modelName = getModelName(model);
+    const response = await client.embeddings.create({
+      model: modelName,
+      input: input.text
+    }, { signal });
+    const result = Array.isArray(input.text) ? {
       vector: response.data.map((item) => new Float32Array(item.embedding))
-    };
+    } : { vector: new Float32Array(response.data[0].embedding) };
+    emit({ type: "finish", data: result });
+  } finally {
+    logger.timeEnd(timerLabel, { model: getModelName(model) });
   }
-  return { vector: new Float32Array(response.data[0].embedding) };
 };
 
 // src/ai/common/OpenAI_TextGeneration.ts
+import { toOpenAIMessages } from "@workglow/ai/worker";
 import { getLogger as getLogger2 } from "@workglow/util/worker";
-var OpenAI_TextGeneration = async (input, model, update_progress, signal) => {
+function buildChatParams(input, model) {
+  const hasMessages = Array.isArray(input.messages) && input.messages.length > 0;
+  const messages = hasMessages ? toOpenAIMessages({
+    messages: input.messages,
+    systemPrompt: input.systemPrompt,
+    prompt: "",
+    tools: []
+  }) : [{ role: "user", content: input.prompt }];
+  const params = {
+    model: getModelName(model),
+    messages
+  };
+  if (input.maxTokens !== undefined)
+    params.max_completion_tokens = input.maxTokens;
+  if (input.temperature !== undefined)
+    params.temperature = input.temperature;
+  if (input.topP !== undefined)
+    params.top_p = input.topP;
+  if (input.frequencyPenalty !== undefined)
+    params.frequency_penalty = input.frequencyPenalty;
+  if (input.presencePenalty !== undefined)
+    params.presence_penalty = input.presencePenalty;
+  return params;
+}
+var OpenAI_TextGeneration_Stream = async (input, model, signal, emit) => {
   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 };
+  const timerLabel = `openai:TextGeneration:${getModelName(model)}`;
+  logger.time(timerLabel, { model: getModelName(model) });
+  try {
+    const client = await getClient(model);
+    const params = buildChatParams(input, model);
+    const stream = await client.chat.completions.create({ ...params, stream: true }, { signal });
+    for await (const chunk of stream) {
+      const delta = chunk.choices?.[0]?.delta?.content ?? "";
+      if (delta) {
+        emit({ type: "text-delta", port: "text", textDelta: delta });
+      }
     }
+    emit({ type: "finish", data: {} });
+  } finally {
+    logger.timeEnd(timerLabel, { model: getModelName(model) });
   }
-  yield { type: "finish", data: {} };
 };
 
 // src/ai/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) {
+var OpenAI_TextRewriter_Stream = async (input, model, signal, emit) => {
   const client = await getClient(model);
   const modelName = getModelName(model);
   const stream = await client.chat.completions.create({
@@ -362,28 +530,14 @@ var OpenAI_TextRewriter_Stream = async function* (input, model, signal) {
   for await (const chunk of stream) {
     const delta = chunk.choices[0]?.delta?.content ?? "";
     if (delta) {
-      yield { type: "text-delta", port: "text", textDelta: delta };
+      emit({ type: "text-delta", port: "text", textDelta: delta });
     }
   }
-  yield { type: "finish", data: {} };
+  emit({ type: "finish", data: {} });
 };
 
 // src/ai/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) {
+var OpenAI_TextSummary_Stream = async (input, model, signal, emit) => {
   const client = await getClient(model);
   const modelName = getModelName(model);
   const stream = await client.chat.completions.create({
@@ -397,45 +551,24 @@ var OpenAI_TextSummary_Stream = async function* (input, model, signal) {
   for await (const chunk of stream) {
     const delta = chunk.choices[0]?.delta?.content ?? "";
     if (delta) {
-      yield { type: "text-delta", port: "text", textDelta: delta };
+      emit({ type: "text-delta", port: "text", textDelta: delta });
     }
   }
-  yield { type: "finish", data: {} };
+  emit({ type: "finish", data: {} });
 };
 
 // src/ai/common/OpenAI_ToolCalling.ts
-import { filterValidToolCalls, toOpenAIMessages } from "@workglow/ai/worker";
+import { filterValidToolCalls, toOpenAIMessages as toOpenAIMessages2 } from "@workglow/ai/worker";
 import {
   accumulateOpenAIStream,
   buildOpenAITools,
-  mapOpenAIToolChoice,
-  parseOpenAIToolCallMessage
+  mapOpenAIToolChoice
 } from "@workglow/ai/provider-utils";
-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 = buildOpenAITools(input.tools);
-  const messages = toOpenAIMessages(input);
-  const toolChoice = mapOpenAIToolChoice(input.toolChoice, true);
-  const response = await client.chat.completions.create({
-    model: modelName,
-    messages,
-    max_completion_tokens: input.maxTokens,
-    temperature: input.temperature,
-    tools,
-    tool_choice: toolChoice
-  }, { signal });
-  const text = response.choices[0]?.message?.content ?? "";
-  const toolCalls = parseOpenAIToolCallMessage(response.choices[0]?.message?.tool_calls);
-  update_progress(100, "Completed OpenAI tool calling");
-  return { text, toolCalls: filterValidToolCalls(toolCalls, input.tools) };
-};
-var OpenAI_ToolCalling_Stream = async function* (input, model, signal) {
+var OpenAI_ToolCalling_Stream = async (input, model, signal, emit) => {
   const client = await getClient(model);
   const modelName = getModelName(model);
   const tools = buildOpenAITools(input.tools);
-  const messages = toOpenAIMessages(input);
+  const messages = toOpenAIMessages2(input);
   const toolChoice = mapOpenAIToolChoice(input.toolChoice, true);
   const stream = await client.chat.completions.create({
     model: modelName,
@@ -446,265 +579,32 @@ var OpenAI_ToolCalling_Stream = async function* (input, model, signal) {
     tools,
     tool_choice: toolChoice
   }, { signal });
-  yield* accumulateOpenAIStream(stream);
-};
-
-// src/ai/common/OpenAI_ImageGenerate.ts
-import { ImageGenerationContentPolicyError, ImageGenerationProviderError } from "@workglow/ai";
-import { getLogger as getLogger3 } from "@workglow/util/worker";
-import { dataUriToImageValue } from "@workglow/ai/provider-utils";
-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);
+  for await (const event of accumulateOpenAIStream(stream)) {
+    if (event.type === "object-delta" && event.port === "toolCalls") {
+      const validated = filterValidToolCalls(event.objectDelta, input.tools);
+      if (validated.length > 0) {
+        emit({ type: "object-delta", port: "toolCalls", objectDelta: validated });
       }
-      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/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-utils";
-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;
+      continue;
     }
-    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 });
+    emit(event);
   }
 };
 
 // src/ai/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_RUN_FNS = [
+  { serves: OPENAI_TEXT_GENERATION, runFn: OpenAI_TextGeneration_Stream },
+  { serves: OPENAI_TOOL_USE, runFn: OpenAI_ToolCalling_Stream },
+  { serves: OPENAI_JSON_MODE, runFn: OpenAI_StructuredGeneration_Stream },
+  { serves: OPENAI_TEXT_REWRITER, runFn: OpenAI_TextRewriter_Stream },
+  { serves: OPENAI_TEXT_SUMMARY, runFn: OpenAI_TextSummary_Stream },
+  { serves: OPENAI_TEXT_EMBEDDING, runFn: OpenAI_TextEmbedding_Stream },
+  { serves: OPENAI_IMAGE_GENERATION, runFn: OpenAI_ImageGenerate_Stream },
+  { serves: OPENAI_IMAGE_EDITING, runFn: OpenAI_ImageEdit_Stream },
+  { serves: OPENAI_COUNT_TOKENS, runFn: OpenAI_CountTokens_Stream },
+  { serves: OPENAI_MODEL_SEARCH, runFn: OpenAI_ModelSearch_Stream },
+  { serves: OPENAI_MODEL_INFO, runFn: OpenAI_ModelInfo_Stream }
+];
 var OPENAI_PREVIEW_TASKS = {
   CountTokensTask: OpenAI_CountTokens_Preview
 };
@@ -712,30 +612,62 @@ var OPENAI_PREVIEW_TASKS = {
 // src/ai/OpenAiQueuedProvider.ts
 import { AiProvider } from "@workglow/ai";
 import { createCloudProviderClass } from "@workglow/ai/provider-utils";
-var OPENAI_QUEUED_TASK_TYPES = [
-  "TextGenerationTask",
-  "TextEmbeddingTask",
-  "TextRewriterTask",
-  "TextSummaryTask",
-  "CountTokensTask",
-  "ModelInfoTask",
-  "StructuredGenerationTask",
-  "ToolCallingTask",
-  "ModelSearchTask",
-  "ImageGenerateTask",
-  "ImageEditTask"
-];
 
+// src/ai/common/OpenAI_Capabilities.ts
+var OPENAI_RUN_FN_SPECS = OPENAI_CAPABILITY_SETS.map((serves) => ({ serves }));
+function openAiWorkerRunFnSpecs() {
+  return OPENAI_RUN_FN_SPECS;
+}
+function inferOpenAiCapabilities(model) {
+  const id = String(model.model_id ?? model.provider_config?.model_name ?? "");
+  if (/^text-embedding/i.test(id)) {
+    return ["text.embedding", "model.count-tokens", "model.info", "model.search"];
+  }
+  if (/^dall-e/i.test(id)) {
+    return ["image.generation", "model.info", "model.search"];
+  }
+  if (/^gpt-image/i.test(id)) {
+    return ["image.generation", "image.editing", "model.info", "model.search"];
+  }
+  if (/^gpt-/i.test(id) || /^o\d/i.test(id)) {
+    const caps = [
+      "text.generation",
+      "text.rewriter",
+      "text.summary",
+      "tool-use",
+      "json-mode",
+      "model.count-tokens",
+      "model.info",
+      "model.search"
+    ];
+    const supportsVision = /gpt-4o|gpt-4\.1|gpt-5|gpt-4-vision|gpt-4-turbo/i.test(id) || /^o\d/i.test(id);
+    if (supportsVision) {
+      caps.push("vision-input");
+    }
+    return caps;
+  }
+  const declared = model.capabilities ?? [];
+  if (declared.length > 0)
+    return declared;
+  return ["model.search", "model.info"];
+}
+
+// src/ai/OpenAiQueuedProvider.ts
 class OpenAiQueuedProvider extends createCloudProviderClass(AiProvider, {
   name: OPENAI,
-  displayName: "OpenAI",
-  taskTypes: OPENAI_QUEUED_TASK_TYPES
+  displayName: "OpenAI"
 }) {
+  inferCapabilities(model) {
+    return inferOpenAiCapabilities(model);
+  }
+  workerRunFnSpecs() {
+    return openAiWorkerRunFnSpecs();
+  }
 }
 
 // src/ai/registerOpenAiInline.browser.ts
 async function registerOpenAiInline(options) {
-  await registerProviderInline(new OpenAiQueuedProvider(OPENAI_TASKS, OPENAI_STREAM_TASKS, OPENAI_PREVIEW_TASKS), "OpenAI", options);
+  await registerProviderInline(new OpenAiQueuedProvider(OPENAI_RUN_FNS, OPENAI_PREVIEW_TASKS), "OpenAI", options);
 }
 
 // src/ai/registerOpenAiWorker.browser.ts
@@ -744,28 +676,21 @@ import { registerProviderWorker } from "@workglow/ai/provider-utils";
 // src/ai/OpenAiProvider.ts
 import { AiProvider as AiProvider2 } from "@workglow/ai/worker";
 import { createCloudProviderClass as createCloudProviderClass2 } from "@workglow/ai/provider-utils";
-var OPENAI_WORKER_TASK_TYPES = [
-  "TextGenerationTask",
-  "TextEmbeddingTask",
-  "TextRewriterTask",
-  "TextSummaryTask",
-  "CountTokensTask",
-  "ModelInfoTask",
-  "StructuredGenerationTask",
-  "ToolCallingTask",
-  "ModelSearchTask"
-];
-
 class OpenAiProvider extends createCloudProviderClass2(AiProvider2, {
   name: OPENAI,
-  displayName: "OpenAI",
-  taskTypes: OPENAI_WORKER_TASK_TYPES
+  displayName: "OpenAI"
 }) {
+  inferCapabilities(model) {
+    return inferOpenAiCapabilities(model);
+  }
+  workerRunFnSpecs() {
+    return openAiWorkerRunFnSpecs();
+  }
 }
 
 // src/ai/registerOpenAiWorker.browser.ts
 async function registerOpenAiWorker() {
-  await registerProviderWorker((ws) => new OpenAiProvider(OPENAI_TASKS, OPENAI_STREAM_TASKS, OPENAI_PREVIEW_TASKS).registerOnWorkerServer(ws), "OpenAI");
+  await registerProviderWorker((ws) => new OpenAiProvider(OPENAI_RUN_FNS, OPENAI_PREVIEW_TASKS).registerOnWorkerServer(ws), "OpenAI");
 }
 export {
   registerOpenAiWorker,
@@ -775,4 +700,4 @@ export {
   getClient
 };
 
-//# debugId=0886E9199E9CDB5F64756E2164756E21
+//# debugId=A7B7CD37536FC05864756E2164756E21