@providerprotocol/ai 0.0.17 → 0.0.19

package/dist/openai/index.js

@@ -1,19 +1,24 @@
+import {
+  Image
+} from "../chunk-WAKD3OO5.js";
 import {
   AssistantMessage,
   isAssistantMessage,
   isToolResultMessage,
   isUserMessage
-} from "../chunk-SVYROCLD.js";
+} from "../chunk-UMKWXGO3.js";
 import {
   parseSSEStream
 } from "../chunk-Z7RBRCRN.js";
 import {
-  UPPError,
   doFetch,
   doStreamFetch,
   normalizeHttpError,
   resolveApiKey
-} from "../chunk-MOU4U3PO.js";
+} from "../chunk-5FEAOEXV.js";
+import {
+  UPPError
+} from "../chunk-DZQHVGNV.js";
 
 // src/providers/openai/transform.completions.ts
 function transformRequest(request, modelId) {
@@ -1379,6 +1384,303 @@ function createEmbeddingHandler() {
   };
 }
 
+// src/providers/openai/image.ts
+var OPENAI_IMAGES_API_URL = "https://api.openai.com/v1/images/generations";
+var OPENAI_IMAGES_EDIT_URL = "https://api.openai.com/v1/images/edits";
+function getCapabilities(modelId) {
+  const isGptImage = modelId.startsWith("gpt-image");
+  const isDalle2 = modelId === "dall-e-2";
+  return {
+    generate: true,
+    streaming: isGptImage,
+    edit: true,
+    maxImages: isDalle2 ? 10 : isGptImage ? 10 : 1
+  };
+}
+function createImageHandler() {
+  let providerRef = null;
+  return {
+    _setProvider(provider) {
+      providerRef = provider;
+    },
+    bind(modelId) {
+      if (!providerRef) {
+        throw new UPPError(
+          "Provider reference not set. Handler must be used with createProvider().",
+          "INVALID_REQUEST",
+          "openai",
+          "image"
+        );
+      }
+      const capabilities = getCapabilities(modelId);
+      const model = {
+        modelId,
+        capabilities,
+        get provider() {
+          return providerRef;
+        },
+        async generate(request) {
+          return executeGenerate(modelId, request);
+        },
+        async edit(request) {
+          return executeEdit(modelId, request);
+        }
+      };
+      if (capabilities.streaming) {
+        model.stream = function(request) {
+          return executeStream(modelId, request);
+        };
+      }
+      return model;
+    }
+  };
+}
+async function executeGenerate(modelId, request) {
+  const apiKey = await resolveApiKey(
+    request.config,
+    "OPENAI_API_KEY",
+    "openai",
+    "image"
+  );
+  const baseUrl = request.config.baseUrl ? `${request.config.baseUrl.replace(/\/$/, "")}/v1/images/generations` : OPENAI_IMAGES_API_URL;
+  const body = {
+    model: modelId,
+    prompt: request.prompt
+  };
+  if (request.params) {
+    const { n, size, quality, style, background, output_format, output_compression, response_format, moderation, user } = request.params;
+    if (n !== void 0) body.n = n;
+    if (size !== void 0) body.size = size;
+    if (quality !== void 0) body.quality = quality;
+    if (style !== void 0) body.style = style;
+    if (background !== void 0) body.background = background;
+    if (output_format !== void 0) body.output_format = output_format;
+    if (output_compression !== void 0) body.output_compression = output_compression;
+    if (response_format !== void 0) body.response_format = response_format;
+    if (moderation !== void 0) body.moderation = moderation;
+    if (user !== void 0) body.user = user;
+  }
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${apiKey}`
+  };
+  if (request.config.headers) {
+    for (const [key, value] of Object.entries(request.config.headers)) {
+      if (value !== void 0) {
+        headers[key] = value;
+      }
+    }
+  }
+  const response = await doFetch(baseUrl, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+    signal: request.signal
+  }, request.config, "openai", "image");
+  const data = await response.json();
+  return transformResponse3(data);
+}
+async function executeEdit(modelId, request) {
+  const apiKey = await resolveApiKey(
+    request.config,
+    "OPENAI_API_KEY",
+    "openai",
+    "image"
+  );
+  const baseUrl = request.config.baseUrl ? `${request.config.baseUrl.replace(/\/$/, "")}/v1/images/edits` : OPENAI_IMAGES_EDIT_URL;
+  const formData = new FormData();
+  formData.append("model", modelId);
+  formData.append("prompt", request.prompt);
+  const imageBytes = request.image.toBytes();
+  const imageBlob = new Blob([imageBytes], { type: request.image.mimeType });
+  formData.append("image", imageBlob, "image.png");
+  if (request.mask) {
+    const maskBytes = request.mask.toBytes();
+    const maskBlob = new Blob([maskBytes], { type: request.mask.mimeType });
+    formData.append("mask", maskBlob, "mask.png");
+  }
+  if (request.params) {
+    const { n, size, response_format, user } = request.params;
+    if (n !== void 0) formData.append("n", String(n));
+    if (size !== void 0) formData.append("size", size);
+    if (response_format !== void 0) formData.append("response_format", response_format);
+    if (user !== void 0) formData.append("user", user);
+  }
+  const headers = {
+    Authorization: `Bearer ${apiKey}`
+  };
+  if (request.config.headers) {
+    for (const [key, value] of Object.entries(request.config.headers)) {
+      if (value !== void 0) {
+        headers[key] = value;
+      }
+    }
+  }
+  const response = await doFetch(baseUrl, {
+    method: "POST",
+    headers,
+    body: formData,
+    signal: request.signal
+  }, request.config, "openai", "image");
+  const data = await response.json();
+  return transformResponse3(data);
+}
+function executeStream(modelId, request) {
+  const abortController = new AbortController();
+  let resolveResponse;
+  let rejectResponse;
+  const responsePromise = new Promise((resolve, reject) => {
+    resolveResponse = resolve;
+    rejectResponse = reject;
+  });
+  async function* generateStream() {
+    try {
+      const apiKey = await resolveApiKey(
+        request.config,
+        "OPENAI_API_KEY",
+        "openai",
+        "image"
+      );
+      const baseUrl = request.config.baseUrl ? `${request.config.baseUrl.replace(/\/$/, "")}/v1/images/generations` : OPENAI_IMAGES_API_URL;
+      const body = {
+        model: modelId,
+        prompt: request.prompt,
+        stream: true
+      };
+      if (request.params) {
+        const { n, size, quality, background, output_format, partial_images, moderation, user } = request.params;
+        if (n !== void 0) body.n = n;
+        if (size !== void 0) body.size = size;
+        if (quality !== void 0) body.quality = quality;
+        if (background !== void 0) body.background = background;
+        if (output_format !== void 0) body.output_format = output_format;
+        if (partial_images !== void 0) body.partial_images = partial_images;
+        if (moderation !== void 0) body.moderation = moderation;
+        if (user !== void 0) body.user = user;
+      }
+      const headers = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "text/event-stream"
+      };
+      if (request.config.headers) {
+        for (const [key, value] of Object.entries(request.config.headers)) {
+          if (value !== void 0) {
+            headers[key] = value;
+          }
+        }
+      }
+      const mergedSignal = request.signal ? AbortSignal.any([abortController.signal, request.signal]) : abortController.signal;
+      const response = await doFetch(baseUrl, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: mergedSignal
+      }, request.config, "openai", "image");
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new UPPError(
+          "No response body for streaming",
+          "PROVIDER_ERROR",
+          "openai",
+          "image"
+        );
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      const generatedImages = [];
+      let responseMetadata = {};
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6);
+            if (data === "[DONE]") {
+              continue;
+            }
+            try {
+              const chunk = JSON.parse(data);
+              if (chunk.type === "image_generation.partial_image" && chunk.data?.b64_json) {
+                const previewImage = Image.fromBase64(chunk.data.b64_json, "image/png");
+                yield {
+                  type: "preview",
+                  image: previewImage,
+                  index: chunk.index ?? 0
+                };
+              } else if (chunk.type === "image_generation.completed" && chunk.data) {
+                const image = chunk.data.b64_json ? Image.fromBase64(chunk.data.b64_json, "image/png") : Image.fromUrl(chunk.data.url ?? "", "image/png");
+                const genImage = {
+                  image,
+                  metadata: chunk.data.revised_prompt ? { revised_prompt: chunk.data.revised_prompt } : void 0
+                };
+                generatedImages.push(genImage);
+                yield {
+                  type: "complete",
+                  image: genImage,
+                  index: chunk.index ?? generatedImages.length - 1
+                };
+              } else if (chunk.type === "response.done") {
+                responseMetadata = chunk.data;
+              }
+            } catch {
+            }
+          }
+        }
+      }
+      resolveResponse({
+        images: generatedImages,
+        metadata: responseMetadata,
+        usage: {
+          imagesGenerated: generatedImages.length
+        }
+      });
+    } catch (error) {
+      rejectResponse(error);
+      throw error;
+    }
+  }
+  const generator = generateStream();
+  return {
+    [Symbol.asyncIterator]: () => generator,
+    response: responsePromise
+  };
+}
+function transformResponse3(data) {
+  const images = data.data.map((item) => {
+    let image;
+    if (item.b64_json) {
+      image = Image.fromBase64(item.b64_json, "image/png");
+    } else if (item.url) {
+      image = Image.fromUrl(item.url, "image/png");
+    } else {
+      throw new UPPError(
+        "No image data in response",
+        "PROVIDER_ERROR",
+        "openai",
+        "image"
+      );
+    }
+    return {
+      image,
+      metadata: item.revised_prompt ? { revised_prompt: item.revised_prompt } : void 0
+    };
+  });
+  return {
+    images,
+    usage: data.usage ? {
+      imagesGenerated: images.length,
+      inputTokens: data.usage.input_tokens,
+      outputTokens: data.usage.output_tokens
+    } : {
+      imagesGenerated: images.length
+    }
+  };
+}
+
 // src/providers/openai/types.ts
 function webSearchTool(options) {
   if (options) {
@@ -1452,6 +1754,7 @@ function createOpenAIProvider() {
   const responsesHandler = createResponsesLLMHandler();
   const completionsHandler = createCompletionsLLMHandler();
   const embeddingHandler = createEmbeddingHandler();
+  const imageHandler = createImageHandler();
   const fn = function(modelId, options) {
     const apiMode = options?.api ?? "responses";
     currentApiMode = apiMode;
@@ -1461,7 +1764,8 @@ function createOpenAIProvider() {
     get llm() {
       return currentApiMode === "completions" ? completionsHandler : responsesHandler;
     },
-    embedding: embeddingHandler
+    embedding: embeddingHandler,
+    image: imageHandler
   };
   Object.defineProperties(fn, {
     name: {
@@ -1484,6 +1788,7 @@ function createOpenAIProvider() {
   responsesHandler._setProvider?.(provider);
   completionsHandler._setProvider?.(provider);
   embeddingHandler._setProvider?.(provider);
+  imageHandler._setProvider?.(provider);
   return provider;
 }
 var openai = createOpenAIProvider();