@ai-sdk/huggingface 2.0.0-beta.9 → 2.0.0-canary.37

package/dist/index.js

@@ -1,50 +1,41 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  createHuggingFace: () => createHuggingFace,
-  huggingface: () => huggingface
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/huggingface-provider.ts
-var import_provider3 = require("@ai-sdk/provider");
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
+import {
+  NoSuchModelError
+} from "@ai-sdk/provider";
+import {
+  generateId as generateId2,
+  loadApiKey,
+  withoutTrailingSlash
+} from "@ai-sdk/provider-utils";
 
 // src/responses/huggingface-responses-language-model.ts
-var import_provider2 = require("@ai-sdk/provider");
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_v42 = require("zod/v4");
+import {
+  APICallError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonResponseHandler,
+  generateId,
+  parseProviderOptions,
+  postJsonToApi,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod/v4";
 
 // src/huggingface-error.ts
-var import_provider_utils = require("@ai-sdk/provider-utils");
-var import_v4 = require("zod/v4");
-var huggingfaceErrorDataSchema = import_v4.z.object({
-  error: import_v4.z.object({
-    message: import_v4.z.string(),
-    type: import_v4.z.string().optional(),
-    code: import_v4.z.string().optional()
+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 = (0, import_provider_utils.createJsonErrorResponseHandler)({
+var huggingfaceFailedResponseHandler = createJsonErrorResponseHandler({
   errorSchema: huggingfaceErrorDataSchema,
   errorToMessage: (data) => data.error.message
 });
@@ -89,7 +80,13 @@ function convertHuggingFaceResponsesUsage(usage) {
 }
 
 // src/responses/convert-to-huggingface-responses-messages.ts
-var import_provider = require("@ai-sdk/provider");
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+import {
+  getTopLevelMediaType,
+  resolveFullMediaType
+} from "@ai-sdk/provider-utils";
 async function convertToHuggingFaceResponsesMessages({
   prompt
 }) {
@@ -110,16 +107,30 @@ async function convertToHuggingFaceResponsesMessages({
                 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 import_provider.UnsupportedFunctionalityError({
-                    functionality: `file part media type ${part.mediaType}`
-                  });
+                switch (part.data.type) {
+                  case "reference": {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "file parts with provider references"
+                    });
+                  }
+                  case "text": {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "text file parts"
+                    });
+                  }
+                  case "url":
+                  case "data": {
+                    if (getTopLevelMediaType(part.mediaType) === "image") {
+                      return {
+                        type: "input_image",
+                        image_url: part.data.type === "url" ? part.data.url.toString() : `data:${resolveFullMediaType({ part })};base64,${part.data.data}`
+                      };
+                    } else {
+                      throw new UnsupportedFunctionalityError({
+                        functionality: `file part media type ${part.mediaType}`
+                      });
+                    }
+                  }
                 }
               }
               default: {
@@ -171,6 +182,15 @@ async function convertToHuggingFaceResponsesMessages({
   return { input: messages, warnings };
 }
 
+// src/responses/huggingface-responses-language-model-options.ts
+import { z as z2 } from "zod/v4";
+var huggingfaceLanguageModelResponsesOptions = z2.object({
+  metadata: z2.record(z2.string(), z2.string()).optional(),
+  instructions: z2.string().optional(),
+  strictJsonSchema: z2.boolean().optional(),
+  reasoningEffort: z2.string().optional()
+});
+
 // src/responses/huggingface-responses-prepare-tools.ts
 function prepareResponsesTools({
   tools,
@@ -253,7 +273,7 @@ function mapHuggingFaceResponsesFinishReason(finishReason) {
 }
 
 // src/responses/huggingface-responses-language-model.ts
-var HuggingFaceResponsesLanguageModel = class {
+var HuggingFaceResponsesLanguageModel = class _HuggingFaceResponsesLanguageModel {
   constructor(modelId, config) {
     this.specificationVersion = "v4";
     this.supportedUrls = {
@@ -262,6 +282,18 @@ var HuggingFaceResponsesLanguageModel = class {
     this.modelId = modelId;
     this.config = config;
   }
+  static [WORKFLOW_SERIALIZE](model) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE](options) {
+    return new _HuggingFaceResponsesLanguageModel(
+      options.modelId,
+      options.config
+    );
+  }
   get provider() {
     return this.config.provider;
   }
@@ -301,10 +333,10 @@ var HuggingFaceResponsesLanguageModel = class {
       prompt
     });
     warnings.push(...messageWarnings);
-    const huggingfaceOptions = await (0, import_provider_utils2.parseProviderOptions)({
+    const huggingfaceOptions = await parseProviderOptions({
       provider: "huggingface",
       providerOptions,
-      schema: huggingfaceResponsesProviderOptionsSchema
+      schema: huggingfaceLanguageModelResponsesOptions
     });
     const {
       tools: preparedTools,
@@ -348,7 +380,7 @@ var HuggingFaceResponsesLanguageModel = class {
     return { args: baseArgs, warnings };
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
     const { args, warnings } = await this.getArgs(options);
     const body = {
       ...args,
@@ -362,19 +394,19 @@ var HuggingFaceResponsesLanguageModel = class {
       value: response,
       responseHeaders,
       rawValue: rawResponse
-    } = await (0, import_provider_utils2.postJsonToApi)({
+    } = await postJsonToApi({
       url,
-      headers: (0, import_provider_utils2.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
       body,
       failedResponseHandler: huggingfaceFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils2.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler(
         huggingfaceResponsesResponseSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
     if (response.error) {
-      throw new import_provider2.APICallError({
+      throw new APICallError({
         message: response.error.message,
         url,
         requestBodyValues: body,
@@ -403,7 +435,7 @@ var HuggingFaceResponsesLanguageModel = class {
                 content.push({
                   type: "source",
                   sourceType: "url",
-                  id: (_c = (_b = (_a = this.config).generateId) == null ? void 0 : _b.call(_a)) != null ? _c : (0, import_provider_utils2.generateId)(),
+                  id: (_e = (_d = (_c = this.config).generateId) == null ? void 0 : _d.call(_c)) != null ? _e : generateId(),
                   url: annotation.url,
                   title: annotation.title
                 });
@@ -488,9 +520,9 @@ var HuggingFaceResponsesLanguageModel = class {
       content,
       finishReason: {
         unified: mapHuggingFaceResponsesFinishReason(
-          (_e = (_d = response.incomplete_details) == null ? void 0 : _d.reason) != null ? _e : "stop"
+          (_g = (_f = response.incomplete_details) == null ? void 0 : _f.reason) != null ? _g : "stop"
         ),
-        raw: (_g = (_f = response.incomplete_details) == null ? void 0 : _f.reason) != null ? _g : void 0
+        raw: (_i = (_h = response.incomplete_details) == null ? void 0 : _h.reason) != null ? _i : void 0
       },
       usage: convertHuggingFaceResponsesUsage(response.usage),
       request: { body },
@@ -510,20 +542,21 @@ var HuggingFaceResponsesLanguageModel = class {
     };
   }
   async doStream(options) {
+    var _a, _b;
     const { args, warnings } = await this.getArgs(options);
     const body = {
       ...args,
       stream: true
     };
-    const { value: response, responseHeaders } = await (0, import_provider_utils2.postJsonToApi)({
+    const { value: response, responseHeaders } = await postJsonToApi({
       url: this.config.url({
         path: "/responses",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils2.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
       body,
       failedResponseHandler: huggingfaceFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils2.createEventSourceResponseHandler)(
+      successfulResponseHandler: createEventSourceResponseHandler(
         huggingfaceResponsesChunkSchema
       ),
       abortSignal: options.abortSignal,
@@ -542,7 +575,7 @@ var HuggingFaceResponsesLanguageModel = class {
             controller.enqueue({ type: "stream-start", warnings });
           },
           transform(chunk, controller) {
-            var _a, _b, _c, _d;
+            var _a2, _b2, _c, _d;
             if (!chunk.success) {
               finishReason = {
                 unified: "error",
@@ -624,7 +657,7 @@ var HuggingFaceResponsesLanguageModel = class {
               responseId = value.response.id;
               finishReason = {
                 unified: mapHuggingFaceResponsesFinishReason(
-                  (_b = (_a = value.response.incomplete_details) == null ? void 0 : _a.reason) != null ? _b : "stop"
+                  (_b2 = (_a2 = value.response.incomplete_details) == null ? void 0 : _a2.reason) != null ? _b2 : "stop"
                 ),
                 raw: (_d = (_c = value.response.incomplete_details) == null ? void 0 : _c.reason) != null ? _d : void 0
               };
@@ -676,231 +709,225 @@ var HuggingFaceResponsesLanguageModel = class {
     };
   }
 };
-var huggingfaceResponsesProviderOptionsSchema = import_v42.z.object({
-  metadata: import_v42.z.record(import_v42.z.string(), import_v42.z.string()).optional(),
-  instructions: import_v42.z.string().optional(),
-  strictJsonSchema: import_v42.z.boolean().optional(),
-  reasoningEffort: import_v42.z.string().optional()
-});
-var huggingfaceResponsesOutputSchema = import_v42.z.discriminatedUnion("type", [
-  import_v42.z.object({
-    type: import_v42.z.literal("message"),
-    id: import_v42.z.string(),
-    role: import_v42.z.string().optional(),
-    status: import_v42.z.string().optional(),
-    content: import_v42.z.array(
-      import_v42.z.object({
-        type: import_v42.z.literal("output_text"),
-        text: import_v42.z.string(),
-        annotations: import_v42.z.array(import_v42.z.any()).optional()
+var huggingfaceResponsesOutputSchema = z3.discriminatedUnion("type", [
+  z3.object({
+    type: z3.literal("message"),
+    id: z3.string(),
+    role: z3.string().optional(),
+    status: z3.string().optional(),
+    content: z3.array(
+      z3.object({
+        type: z3.literal("output_text"),
+        text: z3.string(),
+        annotations: z3.array(z3.any()).optional()
       })
     )
   }),
-  import_v42.z.object({
-    type: import_v42.z.literal("reasoning"),
-    id: import_v42.z.string(),
-    status: import_v42.z.string().optional(),
-    content: import_v42.z.array(
-      import_v42.z.object({
-        type: import_v42.z.literal("reasoning_text"),
-        text: import_v42.z.string()
+  z3.object({
+    type: z3.literal("reasoning"),
+    id: z3.string(),
+    status: z3.string().optional(),
+    content: z3.array(
+      z3.object({
+        type: z3.literal("reasoning_text"),
+        text: z3.string()
       })
     ),
-    summary: import_v42.z.array(
-      import_v42.z.object({
-        type: import_v42.z.literal("reasoning_summary"),
-        text: import_v42.z.string()
+    summary: z3.array(
+      z3.object({
+        type: z3.literal("reasoning_summary"),
+        text: z3.string()
       }).optional()
     ).optional()
   }),
-  import_v42.z.object({
-    type: import_v42.z.literal("function_call"),
-    id: import_v42.z.string(),
-    call_id: import_v42.z.string(),
-    name: import_v42.z.string(),
-    arguments: import_v42.z.string(),
-    output: import_v42.z.string().optional(),
-    status: import_v42.z.string().optional()
+  z3.object({
+    type: z3.literal("function_call"),
+    id: z3.string(),
+    call_id: z3.string(),
+    name: z3.string(),
+    arguments: z3.string(),
+    output: z3.string().optional(),
+    status: z3.string().optional()
   }),
-  import_v42.z.object({
-    type: import_v42.z.literal("mcp_call"),
-    id: import_v42.z.string(),
-    name: import_v42.z.string(),
-    arguments: import_v42.z.string(),
-    output: import_v42.z.string().optional(),
-    status: import_v42.z.string().optional()
+  z3.object({
+    type: z3.literal("mcp_call"),
+    id: z3.string(),
+    name: z3.string(),
+    arguments: z3.string(),
+    output: z3.string().optional(),
+    status: z3.string().optional()
   }),
-  import_v42.z.object({
-    type: import_v42.z.literal("mcp_list_tools"),
-    id: import_v42.z.string(),
-    server_label: import_v42.z.string(),
-    tools: import_v42.z.array(import_v42.z.any()).optional(),
-    status: import_v42.z.string().optional()
+  z3.object({
+    type: z3.literal("mcp_list_tools"),
+    id: z3.string(),
+    server_label: z3.string(),
+    tools: z3.array(z3.any()).optional(),
+    status: z3.string().optional()
   })
 ]);
-var huggingfaceResponsesResponseSchema = import_v42.z.object({
-  id: import_v42.z.string(),
-  model: import_v42.z.string(),
-  object: import_v42.z.string(),
-  created_at: import_v42.z.number(),
-  status: import_v42.z.string(),
-  error: import_v42.z.any().nullable(),
-  instructions: import_v42.z.any().nullable(),
-  max_output_tokens: import_v42.z.any().nullable(),
-  metadata: import_v42.z.any().nullable(),
-  tool_choice: import_v42.z.any(),
-  tools: import_v42.z.array(import_v42.z.any()),
-  temperature: import_v42.z.number(),
-  top_p: import_v42.z.number(),
-  incomplete_details: import_v42.z.object({
-    reason: import_v42.z.string()
+var huggingfaceResponsesResponseSchema = z3.object({
+  id: z3.string(),
+  model: z3.string(),
+  object: z3.string(),
+  created_at: z3.number(),
+  status: z3.string(),
+  error: z3.any().nullable(),
+  instructions: z3.any().nullable(),
+  max_output_tokens: z3.any().nullable(),
+  metadata: z3.any().nullable(),
+  tool_choice: z3.any(),
+  tools: z3.array(z3.any()),
+  temperature: z3.number(),
+  top_p: z3.number(),
+  incomplete_details: z3.object({
+    reason: z3.string()
   }).nullable().optional(),
-  usage: import_v42.z.object({
-    input_tokens: import_v42.z.number(),
-    input_tokens_details: import_v42.z.object({
-      cached_tokens: import_v42.z.number()
+  usage: z3.object({
+    input_tokens: z3.number(),
+    input_tokens_details: z3.object({
+      cached_tokens: z3.number()
     }).optional(),
-    output_tokens: import_v42.z.number(),
-    output_tokens_details: import_v42.z.object({
-      reasoning_tokens: import_v42.z.number()
+    output_tokens: z3.number(),
+    output_tokens_details: z3.object({
+      reasoning_tokens: z3.number()
     }).optional(),
-    total_tokens: import_v42.z.number()
+    total_tokens: z3.number()
   }).nullable().optional(),
-  output: import_v42.z.array(huggingfaceResponsesOutputSchema),
-  output_text: import_v42.z.string().nullable().optional()
+  output: z3.array(huggingfaceResponsesOutputSchema),
+  output_text: z3.string().nullable().optional()
 });
-var responseOutputItemAddedSchema = import_v42.z.object({
-  type: import_v42.z.literal("response.output_item.added"),
-  output_index: import_v42.z.number(),
-  item: import_v42.z.discriminatedUnion("type", [
-    import_v42.z.object({
-      type: import_v42.z.literal("message"),
-      id: import_v42.z.string(),
-      role: import_v42.z.string().optional(),
-      status: import_v42.z.string().optional(),
-      content: import_v42.z.array(import_v42.z.any()).optional()
+var responseOutputItemAddedSchema = z3.object({
+  type: z3.literal("response.output_item.added"),
+  output_index: z3.number(),
+  item: z3.discriminatedUnion("type", [
+    z3.object({
+      type: z3.literal("message"),
+      id: z3.string(),
+      role: z3.string().optional(),
+      status: z3.string().optional(),
+      content: z3.array(z3.any()).optional()
     }),
-    import_v42.z.object({
-      type: import_v42.z.literal("reasoning"),
-      id: import_v42.z.string(),
-      status: import_v42.z.string().optional(),
-      content: import_v42.z.array(import_v42.z.any()).optional(),
-      summary: import_v42.z.array(import_v42.z.any()).optional()
+    z3.object({
+      type: z3.literal("reasoning"),
+      id: z3.string(),
+      status: z3.string().optional(),
+      content: z3.array(z3.any()).optional(),
+      summary: z3.array(z3.any()).optional()
     }),
-    import_v42.z.object({
-      type: import_v42.z.literal("mcp_list_tools"),
-      id: import_v42.z.string(),
-      server_label: import_v42.z.string(),
-      tools: import_v42.z.array(import_v42.z.any()).optional(),
-      error: import_v42.z.string().optional()
+    z3.object({
+      type: z3.literal("mcp_list_tools"),
+      id: z3.string(),
+      server_label: z3.string(),
+      tools: z3.array(z3.any()).optional(),
+      error: z3.string().optional()
     }),
-    import_v42.z.object({
-      type: import_v42.z.literal("mcp_call"),
-      id: import_v42.z.string(),
-      server_label: import_v42.z.string(),
-      name: import_v42.z.string(),
-      arguments: import_v42.z.string(),
-      output: import_v42.z.string().optional(),
-      error: import_v42.z.string().optional()
+    z3.object({
+      type: z3.literal("mcp_call"),
+      id: z3.string(),
+      server_label: z3.string(),
+      name: z3.string(),
+      arguments: z3.string(),
+      output: z3.string().optional(),
+      error: z3.string().optional()
     }),
-    import_v42.z.object({
-      type: import_v42.z.literal("function_call"),
-      id: import_v42.z.string(),
-      call_id: import_v42.z.string(),
-      name: import_v42.z.string(),
-      arguments: import_v42.z.string(),
-      output: import_v42.z.string().optional(),
-      error: import_v42.z.string().optional()
+    z3.object({
+      type: z3.literal("function_call"),
+      id: z3.string(),
+      call_id: z3.string(),
+      name: z3.string(),
+      arguments: z3.string(),
+      output: z3.string().optional(),
+      error: z3.string().optional()
     })
   ]),
-  sequence_number: import_v42.z.number()
+  sequence_number: z3.number()
 });
-var responseOutputItemDoneSchema = import_v42.z.object({
-  type: import_v42.z.literal("response.output_item.done"),
-  output_index: import_v42.z.number(),
-  item: import_v42.z.discriminatedUnion("type", [
-    import_v42.z.object({
-      type: import_v42.z.literal("message"),
-      id: import_v42.z.string(),
-      role: import_v42.z.string().optional(),
-      status: import_v42.z.string().optional(),
-      content: import_v42.z.array(import_v42.z.any()).optional()
+var responseOutputItemDoneSchema = z3.object({
+  type: z3.literal("response.output_item.done"),
+  output_index: z3.number(),
+  item: z3.discriminatedUnion("type", [
+    z3.object({
+      type: z3.literal("message"),
+      id: z3.string(),
+      role: z3.string().optional(),
+      status: z3.string().optional(),
+      content: z3.array(z3.any()).optional()
     }),
-    import_v42.z.object({
-      type: import_v42.z.literal("mcp_list_tools"),
-      id: import_v42.z.string(),
-      server_label: import_v42.z.string(),
-      tools: import_v42.z.array(import_v42.z.any()).optional(),
-      error: import_v42.z.string().optional()
+    z3.object({
+      type: z3.literal("mcp_list_tools"),
+      id: z3.string(),
+      server_label: z3.string(),
+      tools: z3.array(z3.any()).optional(),
+      error: z3.string().optional()
     }),
-    import_v42.z.object({
-      type: import_v42.z.literal("mcp_call"),
-      id: import_v42.z.string(),
-      server_label: import_v42.z.string(),
-      name: import_v42.z.string(),
-      arguments: import_v42.z.string(),
-      output: import_v42.z.string().optional(),
-      error: import_v42.z.string().optional()
+    z3.object({
+      type: z3.literal("mcp_call"),
+      id: z3.string(),
+      server_label: z3.string(),
+      name: z3.string(),
+      arguments: z3.string(),
+      output: z3.string().optional(),
+      error: z3.string().optional()
     }),
-    import_v42.z.object({
-      type: import_v42.z.literal("function_call"),
-      id: import_v42.z.string(),
-      call_id: import_v42.z.string(),
-      name: import_v42.z.string(),
-      arguments: import_v42.z.string(),
-      output: import_v42.z.string().optional(),
-      error: import_v42.z.string().optional()
+    z3.object({
+      type: z3.literal("function_call"),
+      id: z3.string(),
+      call_id: z3.string(),
+      name: z3.string(),
+      arguments: z3.string(),
+      output: z3.string().optional(),
+      error: z3.string().optional()
     }),
-    import_v42.z.object({
-      type: import_v42.z.literal("reasoning"),
-      id: import_v42.z.string(),
-      status: import_v42.z.string().optional(),
-      content: import_v42.z.array(import_v42.z.any()).optional(),
-      summary: import_v42.z.array(import_v42.z.any()).optional()
+    z3.object({
+      type: z3.literal("reasoning"),
+      id: z3.string(),
+      status: z3.string().optional(),
+      content: z3.array(z3.any()).optional(),
+      summary: z3.array(z3.any()).optional()
     })
   ]),
-  sequence_number: import_v42.z.number()
+  sequence_number: z3.number()
 });
-var textDeltaChunkSchema = import_v42.z.object({
-  type: import_v42.z.literal("response.output_text.delta"),
-  item_id: import_v42.z.string(),
-  output_index: import_v42.z.number(),
-  content_index: import_v42.z.number(),
-  delta: import_v42.z.string(),
-  sequence_number: import_v42.z.number()
+var textDeltaChunkSchema = z3.object({
+  type: z3.literal("response.output_text.delta"),
+  item_id: z3.string(),
+  output_index: z3.number(),
+  content_index: z3.number(),
+  delta: z3.string(),
+  sequence_number: z3.number()
 });
-var reasoningTextDeltaChunkSchema = import_v42.z.object({
-  type: import_v42.z.literal("response.reasoning_text.delta"),
-  item_id: import_v42.z.string(),
-  output_index: import_v42.z.number(),
-  content_index: import_v42.z.number(),
-  delta: import_v42.z.string(),
-  sequence_number: import_v42.z.number()
+var reasoningTextDeltaChunkSchema = z3.object({
+  type: z3.literal("response.reasoning_text.delta"),
+  item_id: z3.string(),
+  output_index: z3.number(),
+  content_index: z3.number(),
+  delta: z3.string(),
+  sequence_number: z3.number()
 });
-var reasoningTextEndChunkSchema = import_v42.z.object({
-  type: import_v42.z.literal("response.reasoning_text.done"),
-  item_id: import_v42.z.string(),
-  output_index: import_v42.z.number(),
-  content_index: import_v42.z.number(),
-  text: import_v42.z.string(),
-  sequence_number: import_v42.z.number()
+var reasoningTextEndChunkSchema = z3.object({
+  type: z3.literal("response.reasoning_text.done"),
+  item_id: z3.string(),
+  output_index: z3.number(),
+  content_index: z3.number(),
+  text: z3.string(),
+  sequence_number: z3.number()
 });
-var responseCompletedChunkSchema = import_v42.z.object({
-  type: import_v42.z.literal("response.completed"),
+var responseCompletedChunkSchema = z3.object({
+  type: z3.literal("response.completed"),
   response: huggingfaceResponsesResponseSchema,
-  sequence_number: import_v42.z.number()
+  sequence_number: z3.number()
 });
-var responseCreatedChunkSchema = import_v42.z.object({
-  type: import_v42.z.literal("response.created"),
-  response: import_v42.z.object({
-    id: import_v42.z.string(),
-    object: import_v42.z.string(),
-    created_at: import_v42.z.number(),
-    status: import_v42.z.string(),
-    model: import_v42.z.string()
+var responseCreatedChunkSchema = z3.object({
+  type: z3.literal("response.created"),
+  response: z3.object({
+    id: z3.string(),
+    object: z3.string(),
+    created_at: z3.number(),
+    status: z3.string(),
+    model: z3.string()
   })
 });
-var huggingfaceResponsesChunkSchema = import_v42.z.union([
+var huggingfaceResponsesChunkSchema = z3.union([
   responseOutputItemAddedSchema,
   responseOutputItemDoneSchema,
   reasoningTextDeltaChunkSchema,
@@ -908,7 +935,7 @@ var huggingfaceResponsesChunkSchema = import_v42.z.union([
   textDeltaChunkSchema,
   responseCompletedChunkSchema,
   responseCreatedChunkSchema,
-  import_v42.z.object({ type: import_v42.z.string() }).loose()
+  z3.object({ type: z3.string() }).loose()
   // fallback for unknown chunks
 ]);
 function isResponseOutputItemAddedChunk(chunk) {
@@ -936,9 +963,9 @@ function isResponseCreatedChunk(chunk) {
 // src/huggingface-provider.ts
 function createHuggingFace(options = {}) {
   var _a;
-  const baseURL = (_a = (0, import_provider_utils3.withoutTrailingSlash)(options.baseURL)) != null ? _a : "https://router.huggingface.co/v1";
+  const baseURL = (_a = withoutTrailingSlash(options.baseURL)) != null ? _a : "https://router.huggingface.co/v1";
   const getHeaders = () => ({
-    Authorization: `Bearer ${(0, import_provider_utils3.loadApiKey)({
+    Authorization: `Bearer ${loadApiKey({
       apiKey: options.apiKey,
       environmentVariableName: "HUGGINGFACE_API_KEY",
       description: "Hugging Face"
@@ -952,7 +979,7 @@ function createHuggingFace(options = {}) {
       url: ({ path }) => `${baseURL}${path}`,
       headers: getHeaders,
       fetch: options.fetch,
-      generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils3.generateId
+      generateId: (_a2 = options.generateId) != null ? _a2 : generateId2
     });
   };
   const provider = (modelId) => createResponsesModel(modelId);
@@ -960,7 +987,7 @@ function createHuggingFace(options = {}) {
   provider.languageModel = createResponsesModel;
   provider.responses = createResponsesModel;
   provider.embeddingModel = (modelId) => {
-    throw new import_provider3.NoSuchModelError({
+    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."
@@ -968,7 +995,7 @@ function createHuggingFace(options = {}) {
   };
   provider.textEmbeddingModel = provider.embeddingModel;
   provider.imageModel = (modelId) => {
-    throw new import_provider3.NoSuchModelError({
+    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."
@@ -976,10 +1003,14 @@ function createHuggingFace(options = {}) {
   };
   return provider;
 }
-var huggingface = createHuggingFace();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+var huggingFace = createHuggingFace();
+
+// src/version.ts
+var VERSION = true ? "2.0.0-canary.37" : "0.0.0-test";
+export {
+  VERSION,
   createHuggingFace,
-  huggingface
-});
+  huggingFace,
+  huggingFace as huggingface
+};
 //# sourceMappingURL=index.js.map