@ai-sdk/huggingface 0.0.1

package/dist/index.mjs

@@ -0,0 +1,801 @@
+// src/huggingface-provider.ts
+import {
+  NoSuchModelError
+} from "@ai-sdk/provider";
+import {
+  generateId as generateId2,
+  loadApiKey,
+  withoutTrailingSlash
+} from "@ai-sdk/provider-utils";
+
+// src/responses/huggingface-responses-language-model.ts
+import {
+  APICallError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonResponseHandler,
+  generateId,
+  parseProviderOptions,
+  postJsonToApi
+} from "@ai-sdk/provider-utils";
+import { z as z2 } from "zod/v4";
+
+// src/huggingface-error.ts
+import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var huggingfaceErrorDataSchema = z.object({
+  error: z.object({
+    message: z.string(),
+    type: z.string().optional(),
+    code: z.string().optional()
+  })
+});
+var huggingfaceFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: huggingfaceErrorDataSchema,
+  errorToMessage: (data) => data.error.message
+});
+
+// src/responses/convert-to-huggingface-responses-messages.ts
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+async function convertToHuggingFaceResponsesMessages({
+  prompt
+}) {
+  const messages = [];
+  const warnings = [];
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case "system": {
+        messages.push({ role: "system", content });
+        break;
+      }
+      case "user": {
+        messages.push({
+          role: "user",
+          content: content.map((part) => {
+            switch (part.type) {
+              case "text": {
+                return { type: "input_text", text: part.text };
+              }
+              case "file": {
+                if (part.mediaType.startsWith("image/")) {
+                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+                  return {
+                    type: "input_image",
+                    image_url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${part.data}`
+                  };
+                } else {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: `file part media type ${part.mediaType}`
+                  });
+                }
+              }
+              default: {
+                const _exhaustiveCheck = part;
+                throw new Error(`Unsupported part type: ${_exhaustiveCheck}`);
+              }
+            }
+          })
+        });
+        break;
+      }
+      case "assistant": {
+        for (const part of content) {
+          switch (part.type) {
+            case "text": {
+              messages.push({
+                role: "assistant",
+                content: [{ type: "output_text", text: part.text }]
+              });
+              break;
+            }
+            case "tool-call": {
+              break;
+            }
+            case "tool-result": {
+              break;
+            }
+            case "reasoning": {
+              messages.push({
+                role: "assistant",
+                content: [{ type: "output_text", text: part.text }]
+              });
+              break;
+            }
+          }
+        }
+        break;
+      }
+      case "tool": {
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "tool messages"
+        });
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  return { input: messages, warnings };
+}
+
+// src/responses/map-huggingface-responses-finish-reason.ts
+function mapHuggingFaceResponsesFinishReason(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "tool_calls":
+      return "tool-calls";
+    case "error":
+      return "error";
+    default:
+      return "unknown";
+  }
+}
+
+// src/responses/huggingface-responses-prepare-tools.ts
+function prepareResponsesTools({
+  tools,
+  toolChoice
+}) {
+  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
+  const toolWarnings = [];
+  if (tools == null) {
+    return { tools: void 0, toolChoice: void 0, toolWarnings };
+  }
+  const huggingfaceTools = [];
+  for (const tool of tools) {
+    switch (tool.type) {
+      case "function":
+        huggingfaceTools.push({
+          type: "function",
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema
+        });
+        break;
+      case "provider-defined":
+        toolWarnings.push({
+          type: "unsupported-tool",
+          tool
+        });
+        break;
+      default: {
+        const _exhaustiveCheck = tool;
+        throw new Error(`Unsupported tool type: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  let mappedToolChoice = void 0;
+  if (toolChoice) {
+    switch (toolChoice.type) {
+      case "auto":
+        mappedToolChoice = "auto";
+        break;
+      case "required":
+        mappedToolChoice = "required";
+        break;
+      case "none":
+        break;
+      case "tool":
+        mappedToolChoice = {
+          type: "function",
+          function: { name: toolChoice.toolName }
+        };
+        break;
+      default: {
+        const _exhaustiveCheck = toolChoice;
+        throw new Error(`Unsupported tool choice type: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  return {
+    tools: huggingfaceTools,
+    toolChoice: mappedToolChoice,
+    toolWarnings
+  };
+}
+
+// src/responses/huggingface-responses-language-model.ts
+var HuggingFaceResponsesLanguageModel = class {
+  constructor(modelId, config) {
+    this.specificationVersion = "v2";
+    this.supportedUrls = {
+      "image/*": [/^https?:\/\/.*$/]
+    };
+    this.modelId = modelId;
+    this.config = config;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async getArgs({
+    maxOutputTokens,
+    temperature,
+    stopSequences,
+    topP,
+    topK,
+    presencePenalty,
+    frequencyPenalty,
+    seed,
+    prompt,
+    providerOptions,
+    tools,
+    toolChoice,
+    responseFormat
+  }) {
+    var _a, _b;
+    const warnings = [];
+    if (topK != null) {
+      warnings.push({ type: "unsupported-setting", setting: "topK" });
+    }
+    if (seed != null) {
+      warnings.push({ type: "unsupported-setting", setting: "seed" });
+    }
+    if (presencePenalty != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "presencePenalty"
+      });
+    }
+    if (frequencyPenalty != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "frequencyPenalty"
+      });
+    }
+    if (stopSequences != null) {
+      warnings.push({ type: "unsupported-setting", setting: "stopSequences" });
+    }
+    const { input, warnings: messageWarnings } = await convertToHuggingFaceResponsesMessages({
+      prompt
+    });
+    warnings.push(...messageWarnings);
+    const huggingfaceOptions = await parseProviderOptions({
+      provider: "huggingface",
+      providerOptions,
+      schema: huggingfaceResponsesProviderOptionsSchema
+    });
+    const {
+      tools: preparedTools,
+      toolChoice: preparedToolChoice,
+      toolWarnings
+    } = prepareResponsesTools({
+      tools,
+      toolChoice
+    });
+    warnings.push(...toolWarnings);
+    const baseArgs = {
+      model: this.modelId,
+      input,
+      temperature,
+      top_p: topP,
+      max_output_tokens: maxOutputTokens,
+      // HuggingFace Responses API uses text.format for structured output
+      ...(responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema && {
+        text: {
+          format: {
+            type: "json_schema",
+            strict: (_a = huggingfaceOptions == null ? void 0 : huggingfaceOptions.strictJsonSchema) != null ? _a : false,
+            name: (_b = responseFormat.name) != null ? _b : "response",
+            description: responseFormat.description,
+            schema: responseFormat.schema
+          }
+        }
+      },
+      metadata: huggingfaceOptions == null ? void 0 : huggingfaceOptions.metadata,
+      instructions: huggingfaceOptions == null ? void 0 : huggingfaceOptions.instructions,
+      ...preparedTools && { tools: preparedTools },
+      ...preparedToolChoice && { tool_choice: preparedToolChoice }
+    };
+    return { args: baseArgs, warnings };
+  }
+  async doGenerate(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
+    const { args, warnings } = await this.getArgs(options);
+    const body = {
+      ...args,
+      stream: false
+    };
+    const url = this.config.url({
+      path: "/responses",
+      modelId: this.modelId
+    });
+    const {
+      value: response,
+      responseHeaders,
+      rawValue: rawResponse
+    } = await postJsonToApi({
+      url,
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: huggingfaceFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        huggingfaceResponsesResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    if (response.error) {
+      throw new APICallError({
+        message: response.error.message,
+        url,
+        requestBodyValues: body,
+        statusCode: 400,
+        responseHeaders,
+        responseBody: rawResponse,
+        isRetryable: false
+      });
+    }
+    const content = [];
+    for (const part of response.output) {
+      switch (part.type) {
+        case "message": {
+          for (const contentPart of part.content) {
+            content.push({
+              type: "text",
+              text: contentPart.text,
+              providerMetadata: {
+                huggingface: {
+                  itemId: part.id
+                }
+              }
+            });
+            if (contentPart.annotations) {
+              for (const annotation of contentPart.annotations) {
+                content.push({
+                  type: "source",
+                  sourceType: "url",
+                  id: (_c = (_b = (_a = this.config).generateId) == null ? void 0 : _b.call(_a)) != null ? _c : generateId(),
+                  url: annotation.url,
+                  title: annotation.title
+                });
+              }
+            }
+          }
+          break;
+        }
+        case "mcp_call": {
+          content.push({
+            type: "tool-call",
+            toolCallId: part.id,
+            toolName: part.name,
+            input: part.arguments,
+            providerExecuted: true
+          });
+          if (part.output) {
+            content.push({
+              type: "tool-result",
+              toolCallId: part.id,
+              toolName: part.name,
+              result: part.output,
+              providerExecuted: true
+            });
+          }
+          break;
+        }
+        case "mcp_list_tools": {
+          content.push({
+            type: "tool-call",
+            toolCallId: part.id,
+            toolName: "list_tools",
+            input: JSON.stringify({ server_label: part.server_label }),
+            providerExecuted: true
+          });
+          if (part.tools) {
+            content.push({
+              type: "tool-result",
+              toolCallId: part.id,
+              toolName: "list_tools",
+              result: { tools: part.tools },
+              providerExecuted: true
+            });
+          }
+          break;
+        }
+        case "function_call": {
+          content.push({
+            type: "tool-call",
+            toolCallId: part.call_id,
+            toolName: part.name,
+            input: part.arguments
+          });
+          if (part.output) {
+            content.push({
+              type: "tool-result",
+              toolCallId: part.call_id,
+              toolName: part.name,
+              result: part.output
+            });
+          }
+          break;
+        }
+        default: {
+          break;
+        }
+      }
+    }
+    return {
+      content,
+      finishReason: mapHuggingFaceResponsesFinishReason(
+        (_e = (_d = response.incomplete_details) == null ? void 0 : _d.reason) != null ? _e : "stop"
+      ),
+      usage: {
+        inputTokens: (_g = (_f = response.usage) == null ? void 0 : _f.input_tokens) != null ? _g : 0,
+        outputTokens: (_i = (_h = response.usage) == null ? void 0 : _h.output_tokens) != null ? _i : 0,
+        totalTokens: (_o = (_j = response.usage) == null ? void 0 : _j.total_tokens) != null ? _o : ((_l = (_k = response.usage) == null ? void 0 : _k.input_tokens) != null ? _l : 0) + ((_n = (_m = response.usage) == null ? void 0 : _m.output_tokens) != null ? _n : 0)
+      },
+      request: { body },
+      response: {
+        id: response.id,
+        timestamp: new Date(response.created_at * 1e3),
+        modelId: response.model,
+        headers: responseHeaders,
+        body: rawResponse
+      },
+      providerMetadata: {
+        huggingface: {
+          responseId: response.id
+        }
+      },
+      warnings
+    };
+  }
+  async doStream(options) {
+    const { args, warnings } = await this.getArgs(options);
+    const body = {
+      ...args,
+      stream: true
+    };
+    const { value: response, responseHeaders } = await postJsonToApi({
+      url: this.config.url({
+        path: "/responses",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: huggingfaceFailedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler(
+        huggingfaceResponsesChunkSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    let finishReason = "unknown";
+    let responseId = null;
+    const usage = {
+      inputTokens: void 0,
+      outputTokens: void 0,
+      totalTokens: void 0
+    };
+    return {
+      stream: response.pipeThrough(
+        new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
+          transform(chunk, controller) {
+            var _a, _b, _c;
+            if (!chunk.success) {
+              finishReason = "error";
+              controller.enqueue({ type: "error", error: chunk.error });
+              return;
+            }
+            const value = chunk.value;
+            if (isResponseCreatedChunk(value)) {
+              responseId = value.response.id;
+              controller.enqueue({
+                type: "response-metadata",
+                id: value.response.id,
+                timestamp: new Date(value.response.created_at * 1e3),
+                modelId: value.response.model
+              });
+              return;
+            }
+            if (isResponseOutputItemAddedChunk(value)) {
+              if (value.item.type === "message" && value.item.role === "assistant") {
+                controller.enqueue({
+                  type: "text-start",
+                  id: value.item.id,
+                  providerMetadata: {
+                    huggingface: {
+                      itemId: value.item.id
+                    }
+                  }
+                });
+              } else if (value.item.type === "function_call") {
+                controller.enqueue({
+                  type: "tool-input-start",
+                  id: value.item.call_id,
+                  toolName: value.item.name
+                });
+              }
+              return;
+            }
+            if (isResponseOutputItemDoneChunk(value)) {
+              if (value.item.type === "message" && value.item.role === "assistant") {
+                controller.enqueue({
+                  type: "text-end",
+                  id: value.item.id
+                });
+              } else if (value.item.type === "function_call") {
+                controller.enqueue({
+                  type: "tool-input-end",
+                  id: value.item.call_id
+                });
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: value.item.call_id,
+                  toolName: value.item.name,
+                  input: value.item.arguments
+                });
+                if (value.item.output) {
+                  controller.enqueue({
+                    type: "tool-result",
+                    toolCallId: value.item.call_id,
+                    toolName: value.item.name,
+                    result: value.item.output
+                  });
+                }
+              }
+              return;
+            }
+            if (isResponseCompletedChunk(value)) {
+              responseId = value.response.id;
+              finishReason = mapHuggingFaceResponsesFinishReason(
+                (_b = (_a = value.response.incomplete_details) == null ? void 0 : _a.reason) != null ? _b : "stop"
+              );
+              if (value.response.usage) {
+                usage.inputTokens = value.response.usage.input_tokens;
+                usage.outputTokens = value.response.usage.output_tokens;
+                usage.totalTokens = (_c = value.response.usage.total_tokens) != null ? _c : value.response.usage.input_tokens + value.response.usage.output_tokens;
+              }
+              return;
+            }
+            if (isTextDeltaChunk(value)) {
+              controller.enqueue({
+                type: "text-delta",
+                id: value.item_id,
+                delta: value.delta
+              });
+              return;
+            }
+          },
+          flush(controller) {
+            controller.enqueue({
+              type: "finish",
+              finishReason,
+              usage,
+              providerMetadata: {
+                huggingface: {
+                  responseId
+                }
+              }
+            });
+          }
+        })
+      ),
+      request: { body },
+      response: { headers: responseHeaders }
+    };
+  }
+};
+var huggingfaceResponsesProviderOptionsSchema = z2.object({
+  metadata: z2.record(z2.string(), z2.string()).optional(),
+  instructions: z2.string().optional(),
+  strictJsonSchema: z2.boolean().optional()
+});
+var huggingfaceResponsesResponseSchema = z2.object({
+  id: z2.string(),
+  model: z2.string(),
+  object: z2.string(),
+  created_at: z2.number(),
+  status: z2.string(),
+  error: z2.any().nullable(),
+  instructions: z2.any().nullable(),
+  max_output_tokens: z2.any().nullable(),
+  metadata: z2.any().nullable(),
+  tool_choice: z2.any(),
+  tools: z2.array(z2.any()),
+  temperature: z2.number(),
+  top_p: z2.number(),
+  incomplete_details: z2.object({
+    reason: z2.string()
+  }).nullable().optional(),
+  usage: z2.object({
+    input_tokens: z2.number(),
+    input_tokens_details: z2.object({
+      cached_tokens: z2.number()
+    }).optional(),
+    output_tokens: z2.number(),
+    output_tokens_details: z2.object({
+      reasoning_tokens: z2.number()
+    }).optional(),
+    total_tokens: z2.number()
+  }).nullable().optional(),
+  output: z2.array(z2.any()),
+  output_text: z2.string().nullable().optional()
+});
+var responseOutputItemAddedSchema = z2.object({
+  type: z2.literal("response.output_item.added"),
+  output_index: z2.number(),
+  item: z2.discriminatedUnion("type", [
+    z2.object({
+      type: z2.literal("message"),
+      id: z2.string(),
+      role: z2.string().optional(),
+      status: z2.string().optional(),
+      content: z2.array(z2.any()).optional()
+    }),
+    z2.object({
+      type: z2.literal("mcp_list_tools"),
+      id: z2.string(),
+      server_label: z2.string(),
+      tools: z2.array(z2.any()).optional(),
+      error: z2.string().optional()
+    }),
+    z2.object({
+      type: z2.literal("mcp_call"),
+      id: z2.string(),
+      server_label: z2.string(),
+      name: z2.string(),
+      arguments: z2.string(),
+      output: z2.string().optional(),
+      error: z2.string().optional()
+    }),
+    z2.object({
+      type: z2.literal("function_call"),
+      id: z2.string(),
+      call_id: z2.string(),
+      name: z2.string(),
+      arguments: z2.string(),
+      output: z2.string().optional(),
+      error: z2.string().optional()
+    })
+  ]),
+  sequence_number: z2.number()
+});
+var responseOutputItemDoneSchema = z2.object({
+  type: z2.literal("response.output_item.done"),
+  output_index: z2.number(),
+  item: z2.discriminatedUnion("type", [
+    z2.object({
+      type: z2.literal("message"),
+      id: z2.string(),
+      role: z2.string().optional(),
+      status: z2.string().optional(),
+      content: z2.array(z2.any()).optional()
+    }),
+    z2.object({
+      type: z2.literal("mcp_list_tools"),
+      id: z2.string(),
+      server_label: z2.string(),
+      tools: z2.array(z2.any()).optional(),
+      error: z2.string().optional()
+    }),
+    z2.object({
+      type: z2.literal("mcp_call"),
+      id: z2.string(),
+      server_label: z2.string(),
+      name: z2.string(),
+      arguments: z2.string(),
+      output: z2.string().optional(),
+      error: z2.string().optional()
+    }),
+    z2.object({
+      type: z2.literal("function_call"),
+      id: z2.string(),
+      call_id: z2.string(),
+      name: z2.string(),
+      arguments: z2.string(),
+      output: z2.string().optional(),
+      error: z2.string().optional()
+    })
+  ]),
+  sequence_number: z2.number()
+});
+var textDeltaChunkSchema = z2.object({
+  type: z2.literal("response.output_text.delta"),
+  item_id: z2.string(),
+  output_index: z2.number(),
+  content_index: z2.number(),
+  delta: z2.string(),
+  sequence_number: z2.number()
+});
+var responseCompletedChunkSchema = z2.object({
+  type: z2.literal("response.completed"),
+  response: huggingfaceResponsesResponseSchema,
+  sequence_number: z2.number()
+});
+var responseCreatedChunkSchema = z2.object({
+  type: z2.literal("response.created"),
+  response: z2.object({
+    id: z2.string(),
+    object: z2.string(),
+    created_at: z2.number(),
+    status: z2.string(),
+    model: z2.string()
+  })
+});
+var huggingfaceResponsesChunkSchema = z2.union([
+  responseOutputItemAddedSchema,
+  responseOutputItemDoneSchema,
+  textDeltaChunkSchema,
+  responseCompletedChunkSchema,
+  responseCreatedChunkSchema,
+  z2.object({ type: z2.string() }).loose()
+  // fallback for unknown chunks
+]);
+function isResponseOutputItemAddedChunk(chunk) {
+  return chunk.type === "response.output_item.added";
+}
+function isResponseOutputItemDoneChunk(chunk) {
+  return chunk.type === "response.output_item.done";
+}
+function isTextDeltaChunk(chunk) {
+  return chunk.type === "response.output_text.delta";
+}
+function isResponseCompletedChunk(chunk) {
+  return chunk.type === "response.completed";
+}
+function isResponseCreatedChunk(chunk) {
+  return chunk.type === "response.created";
+}
+
+// src/huggingface-provider.ts
+function createHuggingFace(options = {}) {
+  var _a;
+  const baseURL = (_a = withoutTrailingSlash(options.baseURL)) != null ? _a : "https://router.huggingface.co/v1";
+  const getHeaders = () => ({
+    Authorization: `Bearer ${loadApiKey({
+      apiKey: options.apiKey,
+      environmentVariableName: "HUGGINGFACE_API_KEY",
+      description: "Hugging Face"
+    })}`,
+    ...options.headers
+  });
+  const createResponsesModel = (modelId) => {
+    var _a2;
+    return new HuggingFaceResponsesLanguageModel(modelId, {
+      provider: "huggingface.responses",
+      url: ({ path }) => `${baseURL}${path}`,
+      headers: getHeaders,
+      fetch: options.fetch,
+      generateId: (_a2 = options.generateId) != null ? _a2 : generateId2
+    });
+  };
+  const provider = (modelId) => createResponsesModel(modelId);
+  provider.languageModel = createResponsesModel;
+  provider.responses = createResponsesModel;
+  provider.textEmbeddingModel = (modelId) => {
+    throw new NoSuchModelError({
+      modelId,
+      modelType: "textEmbeddingModel",
+      message: "Hugging Face Responses API does not support text embeddings. Use the Hugging Face Inference API directly for embeddings."
+    });
+  };
+  provider.imageModel = (modelId) => {
+    throw new NoSuchModelError({
+      modelId,
+      modelType: "imageModel",
+      message: "Hugging Face Responses API does not support image generation. Use the Hugging Face Inference API directly for image models."
+    });
+  };
+  return provider;
+}
+var huggingface = createHuggingFace();
+export {
+  createHuggingFace,
+  huggingface
+};
+//# sourceMappingURL=index.mjs.map