@providerprotocol/ai 0.0.34 → 0.0.35

package/dist/proxy/index.js

@@ -1,27 +1,68 @@
+import {
+  server
+} from "../chunk-IDZOVWP3.js";
+import {
+  fastify
+} from "../chunk-UFFJDYCE.js";
+import {
+  bindTools,
+  parseBody,
+  parseEmbeddingBody,
+  parseImageBody,
+  toEmbeddingJSON,
+  toError as toError2,
+  toImageJSON,
+  toImageSSE,
+  toJSON,
+  toSSE,
+  webapi
+} from "../chunk-VGKZIGVI.js";
+import {
+  express
+} from "../chunk-OIEWDFQU.js";
+import {
+  h3
+} from "../chunk-4OGB7JZA.js";
+import {
+  deserializeImageResponse,
+  deserializeImageStreamEvent,
+  deserializeMessage,
+  deserializeStreamEvent,
+  serializeEmbeddingInput,
+  serializeImage,
+  serializeMessage,
+  serializeStreamEvent,
+  serializeTurn
+} from "../chunk-C4JP64VW.js";
+import "../chunk-ETBFOLQN.js";
 import {
   emptyUsage
 } from "../chunk-NSE7QN3P.js";
-import {
-  Image
-} from "../chunk-WAKD3OO5.js";
+import "../chunk-N5DX5JW3.js";
 import {
   parseJsonResponse
-} from "../chunk-3C7O2RNO.js";
+} from "../chunk-A2IM7PGT.js";
 import {
-  AssistantMessage,
-  ToolResultMessage,
-  UserMessage,
   createProvider
-} from "../chunk-ILR2D5PN.js";
+} from "../chunk-JA3UZALR.js";
+import {
+  AssistantMessage
+} from "../chunk-BRP5XJ6Q.js";
 import {
-  ErrorCode,
-  ModalityType,
-  UPPError,
   doFetch,
   doStreamFetch,
   normalizeHttpError,
   toError
-} from "../chunk-4J6OFUKX.js";
+} from "../chunk-AY55T37A.js";
+import {
+  ErrorCode,
+  ModalityType,
+  UPPError
+} from "../chunk-COS4ON4G.js";
+import {
+  StreamEventType,
+  objectDelta
+} from "../chunk-6S222DHN.js";
 
 // src/providers/proxy/headers.ts
 function mergeHeaders(requestHeaders, defaultHeaders) {
@@ -36,97 +77,145 @@ function mergeHeaders(requestHeaders, defaultHeaders) {
   return headers;
 }
 
-// src/providers/proxy/serialization.ts
-function serializeMessage(m) {
-  const base = {
-    id: m.id,
-    type: m.type,
-    content: [],
-    metadata: m.metadata,
-    timestamp: m.timestamp.toISOString()
+// src/providers/proxy/llm.ts
+var PROXY_CAPABILITIES = {
+  streaming: true,
+  tools: true,
+  structuredOutput: true,
+  imageInput: true,
+  documentInput: true,
+  videoInput: true,
+  audioInput: true
+};
+function serializeRequest(request, modelId) {
+  return {
+    model: modelId,
+    messages: request.messages.map(serializeMessage),
+    system: request.system,
+    params: request.params,
+    tools: request.tools?.map((t) => ({
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters,
+      metadata: t.metadata
+    })),
+    structure: request.structure
   };
-  if (m instanceof UserMessage) {
-    base.content = m.content;
-  } else if (m instanceof AssistantMessage) {
-    base.content = m.content;
-    base.toolCalls = m.toolCalls;
-  } else if (m instanceof ToolResultMessage) {
-    base.results = m.results;
+}
+function mapCompletionStopReason(reason) {
+  switch (reason) {
+    case "stop":
+      return "end_turn";
+    case "length":
+      return "max_tokens";
+    case "tool_calls":
+      return "tool_use";
+    case "content_filter":
+      return "content_filter";
+    default:
+      return "end_turn";
   }
-  return base;
 }
-function deserializeMessage(json) {
-  const options = {
-    id: json.id,
-    metadata: json.metadata
-  };
-  switch (json.type) {
-    case "user":
-      return new UserMessage(json.content, options);
-    case "assistant":
-      return new AssistantMessage(
-        json.content,
-        json.toolCalls,
-        options
-      );
-    case "tool_result":
-      return new ToolResultMessage(json.results ?? [], options);
+function mapAnthropicStopReason(reason) {
+  switch (reason) {
+    case "tool_use":
+      return "tool_use";
+    case "max_tokens":
+      return "max_tokens";
+    case "end_turn":
+      return "end_turn";
+    case "stop_sequence":
+      return "end_turn";
     default:
-      throw new UPPError(
-        `Unknown message type: ${json.type}`,
-        ErrorCode.InvalidResponse,
-        "proxy",
-        ModalityType.LLM
-      );
+      return "end_turn";
   }
 }
-function serializeTurn(turn) {
-  return {
-    messages: turn.messages.map(serializeMessage),
-    toolExecutions: turn.toolExecutions,
-    usage: turn.usage,
-    cycles: turn.cycles,
-    data: turn.data
-  };
+function mapGoogleStopReason(reason) {
+  switch (reason) {
+    case "STOP":
+      return "end_turn";
+    case "MAX_TOKENS":
+      return "max_tokens";
+    case "SAFETY":
+      return "content_filter";
+    case "RECITATION":
+      return "content_filter";
+    case "OTHER":
+      return "end_turn";
+    default:
+      return "end_turn";
+  }
 }
-function serializeStreamEvent(event) {
-  const delta = event.delta;
-  if (delta.data instanceof Uint8Array) {
-    const { data, ...rest } = delta;
-    const bytes = Array.from(data);
-    const base64 = btoa(bytes.map((b) => String.fromCharCode(b)).join(""));
-    return {
-      type: event.type,
-      index: event.index,
-      delta: { ...rest, data: base64 }
-    };
+function mapOllamaStopReason(reason) {
+  if (reason === "length") {
+    return "max_tokens";
   }
-  return event;
+  if (reason === "stop") {
+    return "end_turn";
+  }
+  return "end_turn";
 }
-function deserializeStreamEvent(event) {
-  const delta = event.delta;
-  if (typeof delta.data === "string") {
-    const binaryString = atob(delta.data);
-    const bytes = Uint8Array.from(binaryString, (c) => c.charCodeAt(0));
-    return {
-      type: event.type,
-      index: event.index,
-      delta: { ...delta, data: bytes }
-    };
+function deriveStopReason(message) {
+  if (!message) {
+    return "end_turn";
+  }
+  if (message.toolCalls && message.toolCalls.length > 0) {
+    return "tool_use";
+  }
+  const metadata = message.metadata;
+  const openaiMeta = metadata?.openai;
+  if (openaiMeta?.status) {
+    if (openaiMeta.status === "failed") {
+      return "error";
+    }
+    if (openaiMeta.status === "completed") {
+      return "end_turn";
+    }
+  }
+  if (openaiMeta?.finish_reason) {
+    return mapCompletionStopReason(openaiMeta.finish_reason);
+  }
+  const openrouterMeta = metadata?.openrouter;
+  if (openrouterMeta?.finish_reason) {
+    return mapCompletionStopReason(openrouterMeta.finish_reason);
+  }
+  const xaiMeta = metadata?.xai;
+  if (xaiMeta?.status) {
+    if (xaiMeta.status === "failed") {
+      return "error";
+    }
+    if (xaiMeta.status === "completed") {
+      return "end_turn";
+    }
+  }
+  if (xaiMeta?.finish_reason) {
+    return mapCompletionStopReason(xaiMeta.finish_reason);
+  }
+  const anthropicMeta = metadata?.anthropic;
+  if (anthropicMeta?.stop_reason) {
+    return mapAnthropicStopReason(anthropicMeta.stop_reason);
+  }
+  const googleMeta = metadata?.google;
+  if (googleMeta?.finishReason) {
+    return mapGoogleStopReason(googleMeta.finishReason);
   }
-  return event;
+  const ollamaMeta = metadata?.ollama;
+  if (ollamaMeta?.done_reason) {
+    return mapOllamaStopReason(ollamaMeta.done_reason);
+  }
+  return "end_turn";
+}
+function turnJSONToLLMResponse(data) {
+  const messages = data.messages.map(deserializeMessage);
+  const lastAssistant = messages.filter((m) => m.type === "assistant").pop();
+  const stopReason = deriveStopReason(lastAssistant);
+  return {
+    message: lastAssistant ?? new AssistantMessage(""),
+    usage: data.usage ?? emptyUsage(),
+    stopReason,
+    data: data.data
+  };
 }
-
-// src/providers/proxy/llm.ts
-var PROXY_CAPABILITIES = {
-  streaming: true,
-  tools: true,
-  structuredOutput: true,
-  imageInput: true,
-  documentInput: true,
-  videoInput: true,
-  audioInput: true
-};
 function createLLMHandler(options) {
   const { endpoint, headers: defaultHeaders = {} } = options;
   let providerRef = null;
@@ -245,6 +334,12 @@ function createLLMHandler(options) {
                       } else {
                         const event = deserializeStreamEvent(parsed);
                         yield event;
+                        if (request.structure && event.type === StreamEventType.TextDelta) {
+                          yield objectDelta(event.delta.text ?? "", event.index);
+                        }
+                        if (request.structure && event.type === StreamEventType.ToolCallDelta && event.delta.argumentsJson) {
+                          yield objectDelta(event.delta.argumentsJson, event.index);
+                        }
                       }
                     } catch {
                     }
@@ -271,6 +366,12 @@ function createLLMHandler(options) {
                       } else {
                         const event = deserializeStreamEvent(parsed);
                         yield event;
+                        if (request.structure && event.type === StreamEventType.TextDelta) {
+                          yield objectDelta(event.delta.text ?? "", event.index);
+                        }
+                        if (request.structure && event.type === StreamEventType.ToolCallDelta && event.delta.argumentsJson) {
+                          yield objectDelta(event.delta.argumentsJson, event.index);
+                        }
                       }
                     } catch {
                     }
@@ -300,396 +401,11 @@ function createLLMHandler(options) {
     }
   };
 }
-function serializeRequest(request, modelId) {
-  return {
-    model: modelId,
-    messages: request.messages.map(serializeMessage),
-    system: request.system,
-    params: request.params,
-    tools: request.tools?.map((t) => ({
-      name: t.name,
-      description: t.description,
-      parameters: t.parameters,
-      metadata: t.metadata
-    })),
-    structure: request.structure
-  };
-}
-function turnJSONToLLMResponse(data) {
-  const messages = data.messages.map(deserializeMessage);
-  const lastAssistant = messages.filter((m) => m.type === "assistant").pop();
-  const stopReason = deriveStopReason(lastAssistant);
-  return {
-    message: lastAssistant ?? new AssistantMessage(""),
-    usage: data.usage ?? emptyUsage(),
-    stopReason,
-    data: data.data
-  };
-}
-function deriveStopReason(message) {
-  if (!message) {
-    return "end_turn";
-  }
-  if (message.toolCalls && message.toolCalls.length > 0) {
-    return "tool_use";
-  }
-  const metadata = message.metadata;
-  const openaiMeta = metadata?.openai;
-  if (openaiMeta?.status) {
-    if (openaiMeta.status === "failed") {
-      return "error";
-    }
-    if (openaiMeta.status === "completed") {
-      return "end_turn";
-    }
-  }
-  if (openaiMeta?.finish_reason) {
-    return mapCompletionStopReason(openaiMeta.finish_reason);
-  }
-  const openrouterMeta = metadata?.openrouter;
-  if (openrouterMeta?.finish_reason) {
-    return mapCompletionStopReason(openrouterMeta.finish_reason);
-  }
-  const xaiMeta = metadata?.xai;
-  if (xaiMeta?.status) {
-    if (xaiMeta.status === "failed") {
-      return "error";
-    }
-    if (xaiMeta.status === "completed") {
-      return "end_turn";
-    }
-  }
-  if (xaiMeta?.finish_reason) {
-    return mapCompletionStopReason(xaiMeta.finish_reason);
-  }
-  const anthropicMeta = metadata?.anthropic;
-  if (anthropicMeta?.stop_reason) {
-    return mapAnthropicStopReason(anthropicMeta.stop_reason);
-  }
-  const googleMeta = metadata?.google;
-  if (googleMeta?.finishReason) {
-    return mapGoogleStopReason(googleMeta.finishReason);
-  }
-  const ollamaMeta = metadata?.ollama;
-  if (ollamaMeta?.done_reason) {
-    return mapOllamaStopReason(ollamaMeta.done_reason);
-  }
-  return "end_turn";
-}
-function mapCompletionStopReason(reason) {
-  switch (reason) {
-    case "stop":
-      return "end_turn";
-    case "length":
-      return "max_tokens";
-    case "tool_calls":
-      return "tool_use";
-    case "content_filter":
-      return "content_filter";
-    default:
-      return "end_turn";
-  }
-}
-function mapAnthropicStopReason(reason) {
-  switch (reason) {
-    case "tool_use":
-      return "tool_use";
-    case "max_tokens":
-      return "max_tokens";
-    case "end_turn":
-      return "end_turn";
-    case "stop_sequence":
-      return "end_turn";
-    default:
-      return "end_turn";
-  }
-}
-function mapGoogleStopReason(reason) {
-  switch (reason) {
-    case "STOP":
-      return "end_turn";
-    case "MAX_TOKENS":
-      return "max_tokens";
-    case "SAFETY":
-      return "content_filter";
-    case "RECITATION":
-      return "content_filter";
-    case "OTHER":
-      return "end_turn";
-    default:
-      return "end_turn";
-  }
-}
-function mapOllamaStopReason(reason) {
-  if (reason === "length") {
-    return "max_tokens";
-  }
-  if (reason === "stop") {
-    return "end_turn";
-  }
-  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;
-    }
-  };
-}
+var DEFAULT_MAX_INPUT_LENGTH = Number.MAX_SAFE_INTEGER;
+var DEFAULT_DIMENSIONS = 0;
 function normalizeEmbeddingResponse(data) {
   if (!data || typeof data !== "object" || !Array.isArray(data.embeddings)) {
     throw new UPPError(
@@ -733,17 +449,11 @@ function normalizeEmbeddingResponse(data) {
     metadata: data.metadata
   };
 }
-
-// src/providers/proxy/image.ts
-var PROXY_IMAGE_CAPABILITIES = {
-  generate: true,
-  streaming: true,
-  edit: true
-};
-function createImageHandler(options) {
+function createEmbeddingHandler(options) {
   const { endpoint, headers: defaultHeaders = {} } = options;
   let providerRef = null;
   return {
+    supportedInputs: ["text", "image"],
     _setProvider(provider) {
       providerRef = provider;
     },
@@ -754,32 +464,59 @@ function createImageHandler(options) {
           "Provider reference not set. Handler must be used with createProvider().",
           ErrorCode.InvalidRequest,
           "proxy",
-          ModalityType.Image
+          ModalityType.Embedding
         );
       }
       const model = {
         modelId,
-        capabilities: PROXY_IMAGE_CAPABILITIES,
+        maxBatchSize: DEFAULT_MAX_BATCH_SIZE,
+        maxInputLength: DEFAULT_MAX_INPUT_LENGTH,
+        dimensions: DEFAULT_DIMENSIONS,
         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);
+        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);
         }
       };
-      model.stream = function stream(request) {
-        const body = buildImageRequestBody(modelId, request);
-        return executeImageStream(endpoint, body, request, defaultHeaders);
-      };
       return model;
     }
   };
 }
+
+// src/providers/proxy/image.ts
+var PROXY_IMAGE_CAPABILITIES = {
+  generate: true,
+  streaming: true,
+  edit: true
+};
 function buildImageRequestBody(modelId, request) {
   return {
     model: modelId,
@@ -796,6 +533,9 @@ function buildImageEditRequestBody(modelId, request) {
     mask: request.mask ? serializeImage(request.mask) : void 0
   };
 }
+function isImageResponsePayload(payload) {
+  return !!payload && typeof payload === "object" && "images" in payload && Array.isArray(payload.images);
+}
 async function executeImageRequest(endpoint, body, request, defaultHeaders) {
   const headers = mergeHeaders(request.config.headers, defaultHeaders);
   const response = await doFetch(
@@ -941,518 +681,46 @@ function executeImageStream(endpoint, body, request, defaultHeaders) {
     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");
-  res.setHeader("Connection", "keep-alive");
-  (async () => {
-    try {
-      for await (const event of stream) {
-        const serialized = serializeStreamEvent(event);
-        res.write(`data: ${JSON.stringify(serialized)}
-
-`);
-      }
-      const turn = await stream.turn;
-      res.write(`data: ${JSON.stringify(serializeTurn(turn))}
-
-`);
-      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();
-    }
-  })();
-}
-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();
-    }
-  })();
-}
-function sendError(message, status, res) {
-  res.status(status).json({ error: message });
-}
-var express = {
-  sendJSON,
-  sendEmbeddingJSON,
-  sendImageJSON,
-  streamSSE,
-  streamImageSSE,
-  sendError
-};
-
-// src/providers/proxy/server/fastify.ts
-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;
-  (async () => {
-    try {
-      for await (const event of stream) {
-        const serialized = serializeStreamEvent(event);
-        raw.write(`data: ${JSON.stringify(serialized)}
-
-`);
-      }
-      const turn = await stream.turn;
-      raw.write(`data: ${JSON.stringify(serializeTurn(turn))}
-
-`);
-      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();
-    }
-  })();
-  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();
-    }
-  })();
-  return reply;
-}
-function sendError2(message, status, reply) {
-  return reply.status(status).send({ error: message });
-}
-var fastify = {
-  sendJSON: sendJSON2,
-  sendEmbeddingJSON: sendEmbeddingJSON2,
-  sendImageJSON: sendImageJSON2,
-  streamSSE: streamSSE2,
-  streamImageSSE: streamImageSSE2,
-  sendError: sendError2
-};
-
-// src/providers/proxy/server/h3.ts
-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");
-  res.setHeader("Cache-Control", "no-cache");
-  res.setHeader("Connection", "keep-alive");
-  (async () => {
-    try {
-      for await (const evt of stream) {
-        const serialized = serializeStreamEvent(evt);
-        res.write(`data: ${JSON.stringify(serialized)}
-
-`);
-      }
-      const turn = await stream.turn;
-      res.write(`data: ${JSON.stringify(serializeTurn(turn))}
-
-`);
-      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();
-    }
-  })();
-}
-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();
-    }
-  })();
-}
-function createSSEStream(stream) {
-  const encoder = new TextEncoder();
-  return new ReadableStream({
-    async start(controller) {
-      try {
-        for await (const event of stream) {
-          const serialized = serializeStreamEvent(event);
-          controller.enqueue(encoder.encode(`data: ${JSON.stringify(serialized)}
-
-`));
-        }
-        const turn = await stream.turn;
-        controller.enqueue(encoder.encode(`data: ${JSON.stringify(serializeTurn(turn))}
-
-`));
-        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();
-      }
-    }
-  });
-}
-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();
-      }
-    }
-  });
-}
-function sendError3(message, status, event) {
-  return { error: message, statusCode: status };
-}
-var h3 = {
-  sendJSON: sendJSON3,
-  sendEmbeddingJSON: sendEmbeddingJSON3,
-  sendImageJSON: sendImageJSON3,
-  streamSSE: streamSSE3,
-  streamImageSSE: streamImageSSE3,
-  createSSEStream,
-  createImageSSEStream,
-  sendError: sendError3
-};
-
-// src/providers/proxy/server/webapi.ts
-function parseBody(body) {
-  if (!body || typeof body !== "object") {
-    throw new Error("Request body must be an object");
-  }
-  const data = body;
-  if (!Array.isArray(data.messages)) {
-    throw new Error("Request body must have a messages array");
-  }
-  for (const message of data.messages) {
-    if (!message || typeof message !== "object") {
-      throw new Error("Each message must be an object");
-    }
-    const msg = message;
-    if (typeof msg.id !== "string") {
-      throw new Error("Each message must have a string id");
-    }
-    if (typeof msg.type !== "string") {
-      throw new Error("Each message must have a string type");
-    }
-    if (typeof msg.timestamp !== "string") {
-      throw new Error("Each message must have a string timestamp");
-    }
-    if ((msg.type === "user" || msg.type === "assistant") && !Array.isArray(msg.content)) {
-      throw new Error("User and assistant messages must have a content array");
-    }
-  }
-  return {
-    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;
+function createImageHandler(options) {
+  const { endpoint, headers: defaultHeaders = {} } = options;
+  let providerRef = null;
   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({
-    async start(controller) {
-      try {
-        for await (const event of stream) {
-          const serialized = serializeStreamEvent(event);
-          const data = `data: ${JSON.stringify(serialized)}
-
-`;
-          controller.enqueue(encoder.encode(data));
-        }
-        const turn = await stream.turn;
-        const turnData = serializeTurn(turn);
-        controller.enqueue(encoder.encode(`data: ${JSON.stringify(turnData)}
-
-`));
-        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();
+    _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
+        );
       }
-    }
-  });
-  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 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);
         }
-        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();
-      }
-    }
-  });
-  return new Response(readable, {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive"
-    }
-  });
-}
-function toError2(message, status = 500) {
-  return new Response(JSON.stringify({ error: message }), {
-    status,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-function bindTools(schemas, implementations) {
-  if (!schemas) return [];
-  return schemas.map((schema) => {
-    const run = implementations[schema.name];
-    if (!run) {
-      throw new Error(`No implementation for tool: ${schema.name}`);
+      };
+      model.stream = function stream(request) {
+        const body = buildImageRequestBody(modelId, request);
+        return executeImageStream(endpoint, body, request, defaultHeaders);
+      };
+      return model;
     }
-    return { ...schema, run };
-  });
+  };
 }
-var webapi = {
-  parseBody,
-  parseEmbeddingBody,
-  parseImageBody,
-  toJSON,
-  toEmbeddingJSON,
-  toImageJSON,
-  toSSE,
-  toImageSSE,
-  toError: toError2,
-  bindTools
-};
-
-// src/providers/proxy/server/index.ts
-var server = {
-  /** Web API adapter (Bun, Deno, Next.js, Workers) */
-  webapi,
-  /** Express/Connect adapter */
-  express,
-  /** Fastify adapter */
-  fastify,
-  /** H3/Nitro/Nuxt adapter */
-  h3
-};
 
 // src/providers/proxy/index.ts
 function proxy(options) {