@ai-sdk/huggingface 2.0.0-beta.23 → 2.0.0-beta.24

package/dist/index.mjs

@@ -1,980 +0,0 @@
-// 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-huggingface-responses-usage.ts
-function convertHuggingFaceResponsesUsage(usage) {
-  var _a, _b, _c, _d;
-  if (usage == null) {
-    return {
-      inputTokens: {
-        total: void 0,
-        noCache: void 0,
-        cacheRead: void 0,
-        cacheWrite: void 0
-      },
-      outputTokens: {
-        total: void 0,
-        text: void 0,
-        reasoning: void 0
-      },
-      raw: void 0
-    };
-  }
-  const inputTokens = usage.input_tokens;
-  const outputTokens = usage.output_tokens;
-  const cachedTokens = (_b = (_a = usage.input_tokens_details) == null ? void 0 : _a.cached_tokens) != null ? _b : 0;
-  const reasoningTokens = (_d = (_c = usage.output_tokens_details) == null ? void 0 : _c.reasoning_tokens) != null ? _d : 0;
-  return {
-    inputTokens: {
-      total: inputTokens,
-      noCache: inputTokens - cachedTokens,
-      cacheRead: cachedTokens,
-      cacheWrite: void 0
-    },
-    outputTokens: {
-      total: outputTokens,
-      text: outputTokens - reasoningTokens,
-      reasoning: reasoningTokens
-    },
-    raw: usage
-  };
-}
-
-// src/responses/convert-to-huggingface-responses-messages.ts
-import {
-  UnsupportedFunctionalityError
-} from "@ai-sdk/provider";
-import { isProviderReference } from "@ai-sdk/provider-utils";
-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 (isProviderReference(part.data)) {
-                  throw new UnsupportedFunctionalityError({
-                    functionality: "file parts with provider references"
-                  });
-                }
-                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", feature: "tool messages" });
-        break;
-      }
-      default: {
-        const _exhaustiveCheck = role;
-        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
-      }
-    }
-  }
-  return { input: messages, warnings };
-}
-
-// 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":
-        toolWarnings.push({
-          type: "unsupported",
-          feature: `provider-defined tool ${tool.id}`
-        });
-        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/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 "other";
-  }
-}
-
-// src/responses/huggingface-responses-language-model.ts
-var HuggingFaceResponsesLanguageModel = class {
-  constructor(modelId, config) {
-    this.specificationVersion = "v4";
-    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", feature: "topK" });
-    }
-    if (seed != null) {
-      warnings.push({ type: "unsupported", feature: "seed" });
-    }
-    if (presencePenalty != null) {
-      warnings.push({ type: "unsupported", feature: "presencePenalty" });
-    }
-    if (frequencyPenalty != null) {
-      warnings.push({ type: "unsupported", feature: "frequencyPenalty" });
-    }
-    if (stopSequences != null) {
-      warnings.push({ type: "unsupported", feature: "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 },
-      ...(huggingfaceOptions == null ? void 0 : huggingfaceOptions.reasoningEffort) != null && {
-        reasoning: {
-          ...(huggingfaceOptions == null ? void 0 : huggingfaceOptions.reasoningEffort) != null && {
-            effort: huggingfaceOptions.reasoningEffort
-          }
-        }
-      }
-    };
-    return { args: baseArgs, warnings };
-  }
-  async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g;
-    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 "reasoning": {
-          for (const contentPart of part.content) {
-            content.push({
-              type: "reasoning",
-              text: contentPart.text,
-              providerMetadata: {
-                huggingface: {
-                  itemId: part.id
-                }
-              }
-            });
-          }
-          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
-            });
-          }
-          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 }
-            });
-          }
-          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: {
-        unified: mapHuggingFaceResponsesFinishReason(
-          (_e = (_d = response.incomplete_details) == null ? void 0 : _d.reason) != null ? _e : "stop"
-        ),
-        raw: (_g = (_f = response.incomplete_details) == null ? void 0 : _f.reason) != null ? _g : void 0
-      },
-      usage: convertHuggingFaceResponsesUsage(response.usage),
-      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 = {
-      unified: "other",
-      raw: void 0
-    };
-    let responseId = null;
-    let usage = void 0;
-    return {
-      stream: response.pipeThrough(
-        new TransformStream({
-          start(controller) {
-            controller.enqueue({ type: "stream-start", warnings });
-          },
-          transform(chunk, controller) {
-            var _a, _b, _c, _d;
-            if (!chunk.success) {
-              finishReason = {
-                unified: "error",
-                raw: void 0
-              };
-              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
-                });
-              } else if (value.item.type === "reasoning") {
-                controller.enqueue({
-                  type: "reasoning-start",
-                  id: value.item.id,
-                  providerMetadata: {
-                    huggingface: {
-                      itemId: value.item.id
-                    }
-                  }
-                });
-              }
-              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 = {
-                unified: mapHuggingFaceResponsesFinishReason(
-                  (_b = (_a = value.response.incomplete_details) == null ? void 0 : _a.reason) != null ? _b : "stop"
-                ),
-                raw: (_d = (_c = value.response.incomplete_details) == null ? void 0 : _c.reason) != null ? _d : void 0
-              };
-              if (value.response.usage) {
-                usage = value.response.usage;
-              }
-              return;
-            }
-            if (isReasoningDeltaChunk(value)) {
-              controller.enqueue({
-                type: "reasoning-delta",
-                id: value.item_id,
-                delta: value.delta
-              });
-              return;
-            }
-            if (isReasoningEndChunk(value)) {
-              controller.enqueue({
-                type: "reasoning-end",
-                id: value.item_id
-              });
-              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: convertHuggingFaceResponsesUsage(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(),
-  reasoningEffort: z2.string().optional()
-});
-var huggingfaceResponsesOutputSchema = z2.discriminatedUnion("type", [
-  z2.object({
-    type: z2.literal("message"),
-    id: z2.string(),
-    role: z2.string().optional(),
-    status: z2.string().optional(),
-    content: z2.array(
-      z2.object({
-        type: z2.literal("output_text"),
-        text: z2.string(),
-        annotations: z2.array(z2.any()).optional()
-      })
-    )
-  }),
-  z2.object({
-    type: z2.literal("reasoning"),
-    id: z2.string(),
-    status: z2.string().optional(),
-    content: z2.array(
-      z2.object({
-        type: z2.literal("reasoning_text"),
-        text: z2.string()
-      })
-    ),
-    summary: z2.array(
-      z2.object({
-        type: z2.literal("reasoning_summary"),
-        text: z2.string()
-      }).optional()
-    ).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(),
-    status: z2.string().optional()
-  }),
-  z2.object({
-    type: z2.literal("mcp_call"),
-    id: z2.string(),
-    name: z2.string(),
-    arguments: z2.string(),
-    output: z2.string().optional(),
-    status: z2.string().optional()
-  }),
-  z2.object({
-    type: z2.literal("mcp_list_tools"),
-    id: z2.string(),
-    server_label: z2.string(),
-    tools: z2.array(z2.any()).optional(),
-    status: z2.string().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(huggingfaceResponsesOutputSchema),
-  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("reasoning"),
-      id: z2.string(),
-      status: z2.string().optional(),
-      content: z2.array(z2.any()).optional(),
-      summary: 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()
-    }),
-    z2.object({
-      type: z2.literal("reasoning"),
-      id: z2.string(),
-      status: z2.string().optional(),
-      content: z2.array(z2.any()).optional(),
-      summary: z2.array(z2.any()).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 reasoningTextDeltaChunkSchema = z2.object({
-  type: z2.literal("response.reasoning_text.delta"),
-  item_id: z2.string(),
-  output_index: z2.number(),
-  content_index: z2.number(),
-  delta: z2.string(),
-  sequence_number: z2.number()
-});
-var reasoningTextEndChunkSchema = z2.object({
-  type: z2.literal("response.reasoning_text.done"),
-  item_id: z2.string(),
-  output_index: z2.number(),
-  content_index: z2.number(),
-  text: 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,
-  reasoningTextDeltaChunkSchema,
-  reasoningTextEndChunkSchema,
-  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 isReasoningDeltaChunk(chunk) {
-  return chunk.type === "response.reasoning_text.delta";
-}
-function isReasoningEndChunk(chunk) {
-  return chunk.type === "response.reasoning_text.done";
-}
-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.specificationVersion = "v4";
-  provider.languageModel = createResponsesModel;
-  provider.responses = createResponsesModel;
-  provider.embeddingModel = (modelId) => {
-    throw new NoSuchModelError({
-      modelId,
-      modelType: "embeddingModel",
-      message: "Hugging Face Responses API does not support text embeddings. Use the Hugging Face Inference API directly for embeddings."
-    });
-  };
-  provider.textEmbeddingModel = provider.embeddingModel;
-  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