@providerprotocol/ai 0.0.25 → 0.0.27

package/dist/proxy/index.js

@@ -1,6 +1,9 @@
 import {
   emptyUsage
 } from "../chunk-MKDLXV4O.js";
+import {
+  Image
+} from "../chunk-WAKD3OO5.js";
 import {
   parseJsonResponse
 } from "../chunk-Z6DKC37J.js";
@@ -20,6 +23,19 @@ import {
   toError
 } from "../chunk-QNJO7DSD.js";
 
+// src/providers/proxy/headers.ts
+function mergeHeaders(requestHeaders, defaultHeaders) {
+  const headers = { ...defaultHeaders };
+  if (requestHeaders) {
+    for (const [key, value] of Object.entries(requestHeaders)) {
+      if (value !== void 0) {
+        headers[key] = value;
+      }
+    }
+  }
+  return headers;
+}
+
 // src/providers/proxy/serialization.ts
 function serializeMessage(m) {
   const base = {
@@ -117,7 +133,8 @@ function createLLMHandler(options) {
       providerRef = provider;
     },
     bind(modelId) {
-      if (!providerRef) {
+      const provider = providerRef;
+      if (!provider) {
         throw new UPPError(
           "Provider reference not set. Handler must be used with createProvider().",
           ErrorCode.InvalidRequest,
@@ -129,10 +146,10 @@ function createLLMHandler(options) {
         modelId,
         capabilities: PROXY_CAPABILITIES,
         get provider() {
-          return providerRef;
+          return provider;
         },
         async complete(request) {
-          const body = serializeRequest(request);
+          const body = serializeRequest(request, modelId);
           const headers = mergeHeaders(request.config.headers, defaultHeaders);
           const response = await doFetch(
             endpoint,
@@ -154,13 +171,24 @@ function createLLMHandler(options) {
           return turnJSONToLLMResponse(data);
         },
         stream(request) {
-          const body = serializeRequest(request);
+          const body = serializeRequest(request, modelId);
           const headers = mergeHeaders(request.config.headers, defaultHeaders);
           let resolveResponse;
           let rejectResponse;
+          let responseSettled = false;
           const responsePromise = new Promise((resolve, reject) => {
-            resolveResponse = resolve;
-            rejectResponse = reject;
+            resolveResponse = (value) => {
+              if (!responseSettled) {
+                responseSettled = true;
+                resolve(value);
+              }
+            };
+            rejectResponse = (error) => {
+              if (!responseSettled) {
+                responseSettled = true;
+                reject(error);
+              }
+            };
           });
           const generator = async function* () {
             try {
@@ -245,6 +273,14 @@ function createLLMHandler(options) {
                   }
                 }
               }
+              if (!responseSettled) {
+                rejectResponse(new UPPError(
+                  "Stream ended without final response",
+                  ErrorCode.InvalidResponse,
+                  "proxy",
+                  ModalityType.LLM
+                ));
+              }
             } catch (error) {
               rejectResponse(toError(error));
               throw error;
@@ -260,8 +296,9 @@ function createLLMHandler(options) {
     }
   };
 }
-function serializeRequest(request) {
+function serializeRequest(request, modelId) {
   return {
+    model: modelId,
     messages: request.messages.map(serializeMessage),
     system: request.system,
     params: request.params,
@@ -274,17 +311,6 @@ function serializeRequest(request) {
     structure: request.structure
   };
 }
-function mergeHeaders(requestHeaders, defaultHeaders) {
-  const headers = { ...defaultHeaders };
-  if (requestHeaders) {
-    for (const [key, value] of Object.entries(requestHeaders)) {
-      if (value !== void 0) {
-        headers[key] = value;
-      }
-    }
-  }
-  return headers;
-}
 function turnJSONToLLMResponse(data) {
   const messages = data.messages.map(deserializeMessage);
   const lastAssistant = messages.filter((m) => m.type === "assistant").pop();
@@ -400,11 +426,542 @@ function mapOllamaStopReason(reason) {
   return "end_turn";
 }
 
+// src/providers/proxy/serialization.media.ts
+function serializeEmbeddingInput(input) {
+  if (typeof input === "string") {
+    return input;
+  }
+  if (input.type === "text") {
+    return { type: "text", text: input.text };
+  }
+  if (input.type === "image") {
+    const source = serializeUnknownImageSource(input.source, input.mimeType);
+    return { type: "image", source, mimeType: input.mimeType };
+  }
+  throw new UPPError(
+    "Unsupported embedding input type",
+    ErrorCode.InvalidRequest,
+    "proxy",
+    ModalityType.Embedding
+  );
+}
+function deserializeEmbeddingInput(input) {
+  if (typeof input === "string") {
+    return input;
+  }
+  if (input.type === "text") {
+    return { type: "text", text: input.text };
+  }
+  if (input.type === "image") {
+    return {
+      type: "image",
+      mimeType: input.mimeType,
+      source: deserializeImageSource(input.source)
+    };
+  }
+  throw new UPPError(
+    "Unsupported embedding input type",
+    ErrorCode.InvalidResponse,
+    "proxy",
+    ModalityType.Embedding
+  );
+}
+function serializeImage(image) {
+  const block = image.toBlock();
+  return {
+    source: serializeImageSource(block.source),
+    mimeType: block.mimeType,
+    width: block.width,
+    height: block.height
+  };
+}
+function deserializeImage(image) {
+  const block = {
+    type: "image",
+    source: deserializeImageSource(image.source),
+    mimeType: image.mimeType,
+    width: image.width,
+    height: image.height
+  };
+  return Image.fromBlock(block);
+}
+function serializeGeneratedImage(image) {
+  return {
+    image: serializeImage(image.image),
+    metadata: image.metadata
+  };
+}
+function deserializeGeneratedImage(image) {
+  return {
+    image: deserializeImage(image.image),
+    metadata: image.metadata
+  };
+}
+function serializeImageResult(result) {
+  return {
+    images: result.images.map(serializeGeneratedImage),
+    metadata: result.metadata,
+    usage: result.usage
+  };
+}
+function deserializeImageResponse(response) {
+  if (!response || typeof response !== "object" || !Array.isArray(response.images)) {
+    throw new UPPError(
+      "Invalid image response",
+      ErrorCode.InvalidResponse,
+      "proxy",
+      ModalityType.Image
+    );
+  }
+  return {
+    images: response.images.map(deserializeGeneratedImage),
+    metadata: response.metadata,
+    usage: response.usage
+  };
+}
+function serializeImageStreamEvent(event) {
+  if (event.type === "preview") {
+    return {
+      type: "preview",
+      index: event.index,
+      image: serializeImage(event.image),
+      metadata: event.metadata
+    };
+  }
+  return {
+    type: "complete",
+    index: event.index,
+    image: serializeGeneratedImage(event.image)
+  };
+}
+function deserializeImageStreamEvent(event) {
+  if (event.type === "preview") {
+    return {
+      type: "preview",
+      index: event.index,
+      image: deserializeImage(event.image),
+      metadata: event.metadata
+    };
+  }
+  return {
+    type: "complete",
+    index: event.index,
+    image: deserializeGeneratedImage(event.image)
+  };
+}
+function serializeImageSource(source) {
+  if (source.type === "base64") {
+    return { type: "base64", data: source.data };
+  }
+  if (source.type === "url") {
+    return { type: "url", url: source.url };
+  }
+  if (typeof source.data === "string") {
+    return { type: "base64", data: source.data };
+  }
+  if (source.data instanceof Uint8Array) {
+    return { type: "base64", data: bytesToBase64(source.data) };
+  }
+  return { type: "base64", data: bytesToBase64(Uint8Array.from(source.data)) };
+}
+function serializeUnknownImageSource(source, mimeType) {
+  if (source instanceof Image) {
+    return serializeImage(source).source;
+  }
+  if (isImageSource(source)) {
+    return serializeImageSource(source);
+  }
+  if (typeof source === "string") {
+    return { type: "base64", data: source };
+  }
+  throw new UPPError(
+    `Unsupported image source for ${mimeType}`,
+    ErrorCode.InvalidRequest,
+    "proxy",
+    ModalityType.Embedding
+  );
+}
+function deserializeImageSource(source) {
+  if (source.type === "base64") {
+    return { type: "base64", data: source.data };
+  }
+  if (source.type === "url") {
+    return { type: "url", url: source.url };
+  }
+  return { type: "bytes", data: coerceBytes(source.data) };
+}
+function isImageSource(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const source = value;
+  if (source.type === "base64") {
+    return typeof source.data === "string";
+  }
+  if (source.type === "url") {
+    return typeof source.url === "string";
+  }
+  if (source.type === "bytes") {
+    return source.data instanceof Uint8Array || Array.isArray(source.data) || typeof source.data === "string";
+  }
+  return false;
+}
+function coerceBytes(data) {
+  if (typeof data === "string") {
+    return base64ToBytes(data);
+  }
+  return Uint8Array.from(data);
+}
+function bytesToBase64(bytes) {
+  const binary = Array.from(bytes).map((b) => String.fromCharCode(b)).join("");
+  return btoa(binary);
+}
+function base64ToBytes(base64) {
+  const binaryString = atob(base64);
+  return Uint8Array.from(binaryString, (c) => c.charCodeAt(0));
+}
+
+// src/providers/proxy/embedding.ts
+var DEFAULT_MAX_BATCH_SIZE = Number.MAX_SAFE_INTEGER;
+var DEFAULT_MAX_INPUT_LENGTH = Number.MAX_SAFE_INTEGER;
+var DEFAULT_DIMENSIONS = 0;
+function createEmbeddingHandler(options) {
+  const { endpoint, headers: defaultHeaders = {} } = options;
+  let providerRef = null;
+  return {
+    supportedInputs: ["text", "image"],
+    _setProvider(provider) {
+      providerRef = provider;
+    },
+    bind(modelId) {
+      const provider = providerRef;
+      if (!provider) {
+        throw new UPPError(
+          "Provider reference not set. Handler must be used with createProvider().",
+          ErrorCode.InvalidRequest,
+          "proxy",
+          ModalityType.Embedding
+        );
+      }
+      const model = {
+        modelId,
+        maxBatchSize: DEFAULT_MAX_BATCH_SIZE,
+        maxInputLength: DEFAULT_MAX_INPUT_LENGTH,
+        dimensions: DEFAULT_DIMENSIONS,
+        get provider() {
+          return provider;
+        },
+        async embed(request) {
+          const body = {
+            model: modelId,
+            inputs: request.inputs.map(serializeEmbeddingInput),
+            params: request.params
+          };
+          const headers = mergeHeaders(request.config.headers, defaultHeaders);
+          const response = await doFetch(
+            endpoint,
+            {
+              method: "POST",
+              headers: {
+                ...headers,
+                "Content-Type": "application/json",
+                Accept: "application/json"
+              },
+              body: JSON.stringify(body),
+              signal: request.signal
+            },
+            request.config,
+            "proxy",
+            "embedding"
+          );
+          const data = await parseJsonResponse(
+            response,
+            "proxy",
+            "embedding"
+          );
+          return normalizeEmbeddingResponse(data);
+        }
+      };
+      return model;
+    }
+  };
+}
+function normalizeEmbeddingResponse(data) {
+  if (!data || typeof data !== "object" || !Array.isArray(data.embeddings)) {
+    throw new UPPError(
+      "Invalid embedding response",
+      ErrorCode.InvalidResponse,
+      "proxy",
+      ModalityType.Embedding
+    );
+  }
+  const embeddings = data.embeddings.map((embedding, index) => {
+    if (!embedding || typeof embedding !== "object") {
+      throw new UPPError(
+        "Invalid embedding entry",
+        ErrorCode.InvalidResponse,
+        "proxy",
+        ModalityType.Embedding
+      );
+    }
+    const vector = embedding.vector;
+    if (!Array.isArray(vector) && typeof vector !== "string") {
+      throw new UPPError(
+        "Invalid embedding vector",
+        ErrorCode.InvalidResponse,
+        "proxy",
+        ModalityType.Embedding
+      );
+    }
+    const resolvedIndex = typeof embedding.index === "number" ? embedding.index : index;
+    const tokens = typeof embedding.tokens === "number" ? embedding.tokens : void 0;
+    return {
+      vector,
+      index: resolvedIndex,
+      tokens,
+      metadata: embedding.metadata
+    };
+  });
+  const totalTokens = typeof data.usage?.totalTokens === "number" ? data.usage.totalTokens : 0;
+  return {
+    embeddings,
+    usage: { totalTokens },
+    metadata: data.metadata
+  };
+}
+
+// src/providers/proxy/image.ts
+var PROXY_IMAGE_CAPABILITIES = {
+  generate: true,
+  streaming: true,
+  edit: true
+};
+function createImageHandler(options) {
+  const { endpoint, headers: defaultHeaders = {} } = options;
+  let providerRef = null;
+  return {
+    _setProvider(provider) {
+      providerRef = provider;
+    },
+    bind(modelId) {
+      const provider = providerRef;
+      if (!provider) {
+        throw new UPPError(
+          "Provider reference not set. Handler must be used with createProvider().",
+          ErrorCode.InvalidRequest,
+          "proxy",
+          ModalityType.Image
+        );
+      }
+      const model = {
+        modelId,
+        capabilities: PROXY_IMAGE_CAPABILITIES,
+        get provider() {
+          return provider;
+        },
+        async generate(request) {
+          const body = buildImageRequestBody(modelId, request);
+          return executeImageRequest(endpoint, body, request, defaultHeaders);
+        },
+        async edit(request) {
+          const body = buildImageEditRequestBody(modelId, request);
+          return executeImageRequest(endpoint, body, request, defaultHeaders);
+        }
+      };
+      model.stream = function stream(request) {
+        const body = buildImageRequestBody(modelId, request);
+        return executeImageStream(endpoint, body, request, defaultHeaders);
+      };
+      return model;
+    }
+  };
+}
+function buildImageRequestBody(modelId, request) {
+  return {
+    model: modelId,
+    prompt: request.prompt,
+    params: request.params
+  };
+}
+function buildImageEditRequestBody(modelId, request) {
+  return {
+    model: modelId,
+    prompt: request.prompt,
+    params: request.params,
+    image: serializeImage(request.image),
+    mask: request.mask ? serializeImage(request.mask) : void 0
+  };
+}
+async function executeImageRequest(endpoint, body, request, defaultHeaders) {
+  const headers = mergeHeaders(request.config.headers, defaultHeaders);
+  const response = await doFetch(
+    endpoint,
+    {
+      method: "POST",
+      headers: {
+        ...headers,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: request.signal
+    },
+    request.config,
+    "proxy",
+    "image"
+  );
+  const data = await parseJsonResponse(
+    response,
+    "proxy",
+    "image"
+  );
+  return deserializeImageResponse(data);
+}
+function executeImageStream(endpoint, body, request, defaultHeaders) {
+  const headers = mergeHeaders(request.config.headers, defaultHeaders);
+  let resolveResponse;
+  let rejectResponse;
+  let responseSettled = false;
+  const responsePromise = new Promise((resolve, reject) => {
+    resolveResponse = (value) => {
+      if (!responseSettled) {
+        responseSettled = true;
+        resolve(value);
+      }
+    };
+    rejectResponse = (error) => {
+      if (!responseSettled) {
+        responseSettled = true;
+        reject(error);
+      }
+    };
+  });
+  const generator = async function* generator2() {
+    try {
+      const response = await doStreamFetch(
+        endpoint,
+        {
+          method: "POST",
+          headers: {
+            ...headers,
+            "Content-Type": "application/json",
+            Accept: "text/event-stream"
+          },
+          body: JSON.stringify(body),
+          signal: request.signal
+        },
+        request.config,
+        "proxy",
+        "image"
+      );
+      if (!response.ok) {
+        throw await normalizeHttpError(response, "proxy", "image");
+      }
+      if (!response.body) {
+        throw new UPPError(
+          "Response body is null",
+          ErrorCode.ProviderError,
+          "proxy",
+          ModalityType.Image
+        );
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      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.trim() || line.startsWith(":")) continue;
+          if (line.startsWith("data:")) {
+            let data = line.slice(5);
+            if (data.startsWith(" ")) {
+              data = data.slice(1);
+            }
+            if (data === "[DONE]") continue;
+            try {
+              const parsed = JSON.parse(data);
+              if (isImageResponsePayload(parsed)) {
+                resolveResponse(deserializeImageResponse(parsed));
+              } else {
+                yield deserializeImageStreamEvent(parsed);
+              }
+            } catch {
+            }
+          }
+        }
+      }
+      const remaining = decoder.decode();
+      if (remaining) {
+        buffer += remaining;
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.trim() || line.startsWith(":")) continue;
+          if (line.startsWith("data:")) {
+            let data = line.slice(5);
+            if (data.startsWith(" ")) {
+              data = data.slice(1);
+            }
+            if (data === "[DONE]") continue;
+            try {
+              const parsed = JSON.parse(data);
+              if (isImageResponsePayload(parsed)) {
+                resolveResponse(deserializeImageResponse(parsed));
+              } else {
+                yield deserializeImageStreamEvent(parsed);
+              }
+            } catch {
+            }
+          }
+        }
+      }
+      if (!responseSettled) {
+        rejectResponse(new UPPError(
+          "Stream ended without final response",
+          ErrorCode.InvalidResponse,
+          "proxy",
+          ModalityType.Image
+        ));
+      }
+    } catch (error) {
+      rejectResponse(toError(error));
+      throw error;
+    }
+  };
+  return {
+    [Symbol.asyncIterator]: generator,
+    response: responsePromise
+  };
+}
+function isImageResponsePayload(payload) {
+  return !!payload && typeof payload === "object" && "images" in payload && Array.isArray(payload.images);
+}
+
+// src/providers/proxy/server/image-stream.ts
+function resolveImageResult(stream) {
+  if ("result" in stream) {
+    return stream.result;
+  }
+  return stream.response;
+}
+
 // src/providers/proxy/server/express.ts
 function sendJSON(turn, res) {
   res.setHeader("Content-Type", "application/json");
   res.json(serializeTurn(turn));
 }
+function sendEmbeddingJSON(result, res) {
+  res.setHeader("Content-Type", "application/json");
+  res.json(result);
+}
+function sendImageJSON(result, res) {
+  res.setHeader("Content-Type", "application/json");
+  res.json(serializeImageResult(result));
+}
 function streamSSE(stream, res) {
   res.setHeader("Content-Type", "text/event-stream");
   res.setHeader("Cache-Control", "no-cache");
@@ -426,6 +983,33 @@ function streamSSE(stream, res) {
       const message = error instanceof Error ? error.message : String(error);
       res.write(`data: ${JSON.stringify({ error: message })}
 
+`);
+    } finally {
+      res.end();
+    }
+  })();
+}
+function streamImageSSE(stream, res) {
+  res.setHeader("Content-Type", "text/event-stream");
+  res.setHeader("Cache-Control", "no-cache");
+  res.setHeader("Connection", "keep-alive");
+  (async () => {
+    try {
+      for await (const event of stream) {
+        const serialized = serializeImageStreamEvent(event);
+        res.write(`data: ${JSON.stringify(serialized)}
+
+`);
+      }
+      const result = await resolveImageResult(stream);
+      res.write(`data: ${JSON.stringify(serializeImageResult(result))}
+
+`);
+      res.write("data: [DONE]\n\n");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      res.write(`data: ${JSON.stringify({ error: message })}
+
 `);
     } finally {
       res.end();
@@ -437,7 +1021,10 @@ function sendError(message, status, res) {
 }
 var express = {
   sendJSON,
+  sendEmbeddingJSON,
+  sendImageJSON,
   streamSSE,
+  streamImageSSE,
   sendError
 };
 
@@ -445,6 +1032,12 @@ var express = {
 function sendJSON2(turn, reply) {
   return reply.header("Content-Type", "application/json").send(serializeTurn(turn));
 }
+function sendEmbeddingJSON2(result, reply) {
+  return reply.header("Content-Type", "application/json").send(result);
+}
+function sendImageJSON2(result, reply) {
+  return reply.header("Content-Type", "application/json").send(serializeImageResult(result));
+}
 function streamSSE2(stream, reply) {
   reply.header("Content-Type", "text/event-stream").header("Cache-Control", "no-cache").header("Connection", "keep-alive");
   const raw = reply.raw;
@@ -465,6 +1058,33 @@ function streamSSE2(stream, reply) {
       const message = error instanceof Error ? error.message : String(error);
       raw.write(`data: ${JSON.stringify({ error: message })}
 
+`);
+    } finally {
+      raw.end();
+    }
+  })();
+  return reply;
+}
+function streamImageSSE2(stream, reply) {
+  reply.header("Content-Type", "text/event-stream").header("Cache-Control", "no-cache").header("Connection", "keep-alive");
+  const raw = reply.raw;
+  (async () => {
+    try {
+      for await (const event of stream) {
+        const serialized = serializeImageStreamEvent(event);
+        raw.write(`data: ${JSON.stringify(serialized)}
+
+`);
+      }
+      const result = await resolveImageResult(stream);
+      raw.write(`data: ${JSON.stringify(serializeImageResult(result))}
+
+`);
+      raw.write("data: [DONE]\n\n");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      raw.write(`data: ${JSON.stringify({ error: message })}
+
 `);
     } finally {
       raw.end();
@@ -477,7 +1097,10 @@ function sendError2(message, status, reply) {
 }
 var fastify = {
   sendJSON: sendJSON2,
+  sendEmbeddingJSON: sendEmbeddingJSON2,
+  sendImageJSON: sendImageJSON2,
   streamSSE: streamSSE2,
+  streamImageSSE: streamImageSSE2,
   sendError: sendError2
 };
 
@@ -486,6 +1109,14 @@ function sendJSON3(turn, event) {
   event.node.res.setHeader("Content-Type", "application/json");
   return serializeTurn(turn);
 }
+function sendEmbeddingJSON3(result, event) {
+  event.node.res.setHeader("Content-Type", "application/json");
+  return result;
+}
+function sendImageJSON3(result, event) {
+  event.node.res.setHeader("Content-Type", "application/json");
+  return serializeImageResult(result);
+}
 function streamSSE3(stream, event) {
   const res = event.node.res;
   res.setHeader("Content-Type", "text/event-stream");
@@ -508,6 +1139,34 @@ function streamSSE3(stream, event) {
       const message = error instanceof Error ? error.message : String(error);
       res.write(`data: ${JSON.stringify({ error: message })}
 
+`);
+    } finally {
+      res.end();
+    }
+  })();
+}
+function streamImageSSE3(stream, event) {
+  const res = event.node.res;
+  res.setHeader("Content-Type", "text/event-stream");
+  res.setHeader("Cache-Control", "no-cache");
+  res.setHeader("Connection", "keep-alive");
+  (async () => {
+    try {
+      for await (const evt of stream) {
+        const serialized = serializeImageStreamEvent(evt);
+        res.write(`data: ${JSON.stringify(serialized)}
+
+`);
+      }
+      const result = await resolveImageResult(stream);
+      res.write(`data: ${JSON.stringify(serializeImageResult(result))}
+
+`);
+      res.write("data: [DONE]\n\n");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      res.write(`data: ${JSON.stringify({ error: message })}
+
 `);
     } finally {
       res.end();
@@ -534,6 +1193,33 @@ function createSSEStream(stream) {
         const message = error instanceof Error ? error.message : String(error);
         controller.enqueue(encoder.encode(`data: ${JSON.stringify({ error: message })}
 
+`));
+      } finally {
+        controller.close();
+      }
+    }
+  });
+}
+function createImageSSEStream(stream) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        for await (const event of stream) {
+          const serialized = serializeImageStreamEvent(event);
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(serialized)}
+
+`));
+        }
+        const result = await resolveImageResult(stream);
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(serializeImageResult(result))}
+
+`));
+        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ error: message })}
+
 `));
       } finally {
         controller.close();
@@ -546,8 +1232,12 @@ function sendError3(message, status, event) {
 }
 var h3 = {
   sendJSON: sendJSON3,
+  sendEmbeddingJSON: sendEmbeddingJSON3,
+  sendImageJSON: sendImageJSON3,
   streamSSE: streamSSE3,
+  streamImageSSE: streamImageSSE3,
   createSSEStream,
+  createImageSSEStream,
   sendError: sendError3
 };
 
@@ -582,15 +1272,71 @@ function parseBody(body) {
     messages: data.messages.map(deserializeMessage),
     system: data.system,
     params: data.params,
+    model: typeof data.model === "string" ? data.model : void 0,
     tools: data.tools,
     structure: data.structure
   };
 }
+function parseEmbeddingBody(body) {
+  if (!body || typeof body !== "object") {
+    throw new Error("Request body must be an object");
+  }
+  const data = body;
+  if (!Array.isArray(data.inputs)) {
+    throw new Error("Request body must have an inputs array");
+  }
+  const inputs = data.inputs.map(
+    (input) => deserializeEmbeddingInput(input)
+  );
+  return {
+    inputs,
+    params: data.params,
+    model: typeof data.model === "string" ? data.model : void 0
+  };
+}
+function parseImageBody(body) {
+  if (!body || typeof body !== "object") {
+    throw new Error("Request body must be an object");
+  }
+  const data = body;
+  const promptValue = data.prompt;
+  let prompt;
+  if (typeof promptValue === "string") {
+    prompt = promptValue;
+  } else if (promptValue && typeof promptValue === "object") {
+    const promptObj = promptValue;
+    if (typeof promptObj.prompt === "string") {
+      prompt = promptObj.prompt;
+    }
+  }
+  if (!prompt) {
+    throw new Error("Request body must have a prompt string");
+  }
+  const image = data.image ? deserializeImage(data.image) : void 0;
+  const mask = data.mask ? deserializeImage(data.mask) : void 0;
+  return {
+    prompt,
+    params: data.params,
+    model: typeof data.model === "string" ? data.model : void 0,
+    image,
+    mask
+  };
+}
 function toJSON(turn) {
   return new Response(JSON.stringify(serializeTurn(turn)), {
     headers: { "Content-Type": "application/json" }
   });
 }
+function toEmbeddingJSON(result) {
+  return new Response(JSON.stringify(result), {
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function toImageJSON(result) {
+  return new Response(JSON.stringify(serializeImageResult(result)), {
+    headers: { "Content-Type": "application/json" }
+  });
+}
 function toSSE(stream) {
   const encoder = new TextEncoder();
   const readable = new ReadableStream({
@@ -612,7 +1358,43 @@ function toSSE(stream) {
         controller.close();
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        controller.enqueue(encoder.encode(`data: {"error":"${errorMsg}"}
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ error: errorMsg })}
+
+`));
+        controller.close();
+      }
+    }
+  });
+  return new Response(readable, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
+}
+function toImageSSE(stream) {
+  const encoder = new TextEncoder();
+  const readable = new ReadableStream({
+    async start(controller) {
+      try {
+        for await (const event of stream) {
+          const serialized = serializeImageStreamEvent(event);
+          const data = `data: ${JSON.stringify(serialized)}
+
+`;
+          controller.enqueue(encoder.encode(data));
+        }
+        const result = await resolveImageResult(stream);
+        const resultData = serializeImageResult(result);
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(resultData)}
+
+`));
+        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+        controller.close();
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ error: errorMsg })}
 
 `));
         controller.close();
@@ -645,8 +1427,13 @@ function bindTools(schemas, implementations) {
 }
 var webapi = {
   parseBody,
+  parseEmbeddingBody,
+  parseImageBody,
   toJSON,
+  toEmbeddingJSON,
+  toImageJSON,
   toSSE,
+  toImageSSE,
   toError: toError2,
   bindTools
 };
@@ -669,7 +1456,9 @@ function proxy(options) {
     name: "proxy",
     version: "1.0.0",
     handlers: {
-      llm: createLLMHandler(options)
+      llm: createLLMHandler(options),
+      embedding: createEmbeddingHandler(options),
+      image: createImageHandler(options)
     }
   });
 }
@@ -684,13 +1473,18 @@ export {
   fastify,
   h3,
   parseBody,
+  parseEmbeddingBody,
+  parseImageBody,
   proxy,
   proxyModel,
   serializeMessage,
   serializeStreamEvent,
   serializeTurn,
   server,
+  toEmbeddingJSON,
   toError2 as toError,
+  toImageJSON,
+  toImageSSE,
   toJSON,
   toSSE,
   webapi