@ai-sdk/huggingface 1.0.0-beta.9 → 1.0.1

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -42,16 +32,16 @@ var import_provider_utils3 = require("@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 z2 = __toESM(require("zod/v4"));
+var import_v42 = require("zod/v4");
 
 // src/huggingface-error.ts
 var import_provider_utils = require("@ai-sdk/provider-utils");
-var z = __toESM(require("zod/v4"));
-var huggingfaceErrorDataSchema = z.object({
-  error: z.object({
-    message: z.string(),
-    type: z.string().optional(),
-    code: z.string().optional()
+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()
   })
 });
 var huggingfaceFailedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)({
@@ -59,6 +49,45 @@ var huggingfaceFailedResponseHandler = (0, import_provider_utils.createJsonError
   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
 var import_provider = require("@ai-sdk/provider");
 async function convertToHuggingFaceResponsesMessages({
@@ -130,10 +159,7 @@ async function convertToHuggingFaceResponsesMessages({
         break;
       }
       case "tool": {
-        warnings.push({
-          type: "unsupported-setting",
-          setting: "tool messages"
-        });
+        warnings.push({ type: "unsupported", feature: "tool messages" });
         break;
       }
       default: {
@@ -145,24 +171,6 @@ async function convertToHuggingFaceResponsesMessages({
   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,
@@ -184,10 +192,10 @@ function prepareResponsesTools({
           parameters: tool.inputSchema
         });
         break;
-      case "provider-defined":
+      case "provider":
         toolWarnings.push({
-          type: "unsupported-tool",
-          tool
+          type: "unsupported",
+          feature: `provider-defined tool ${tool.id}`
         });
         break;
       default: {
@@ -226,6 +234,24 @@ function prepareResponsesTools({
   };
 }
 
+// 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) {
@@ -257,25 +283,19 @@ var HuggingFaceResponsesLanguageModel = class {
     var _a, _b;
     const warnings = [];
     if (topK != null) {
-      warnings.push({ type: "unsupported-setting", setting: "topK" });
+      warnings.push({ type: "unsupported", feature: "topK" });
     }
     if (seed != null) {
-      warnings.push({ type: "unsupported-setting", setting: "seed" });
+      warnings.push({ type: "unsupported", feature: "seed" });
     }
     if (presencePenalty != null) {
-      warnings.push({
-        type: "unsupported-setting",
-        setting: "presencePenalty"
-      });
+      warnings.push({ type: "unsupported", feature: "presencePenalty" });
     }
     if (frequencyPenalty != null) {
-      warnings.push({
-        type: "unsupported-setting",
-        setting: "frequencyPenalty"
-      });
+      warnings.push({ type: "unsupported", feature: "frequencyPenalty" });
     }
     if (stopSequences != null) {
-      warnings.push({ type: "unsupported-setting", setting: "stopSequences" });
+      warnings.push({ type: "unsupported", feature: "stopSequences" });
     }
     const { input, warnings: messageWarnings } = await convertToHuggingFaceResponsesMessages({
       prompt
@@ -316,12 +336,19 @@ var HuggingFaceResponsesLanguageModel = class {
       metadata: huggingfaceOptions == null ? void 0 : huggingfaceOptions.metadata,
       instructions: huggingfaceOptions == null ? void 0 : huggingfaceOptions.instructions,
       ...preparedTools && { tools: preparedTools },
-      ...preparedToolChoice && { tool_choice: preparedToolChoice }
+      ...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, _h, _i, _j, _k, _l, _m, _n, _o;
+    var _a, _b, _c, _d, _e, _f, _g;
     const { args, warnings } = await this.getArgs(options);
     const body = {
       ...args,
@@ -385,6 +412,20 @@ var HuggingFaceResponsesLanguageModel = class {
           }
           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",
@@ -398,8 +439,7 @@ var HuggingFaceResponsesLanguageModel = class {
               type: "tool-result",
               toolCallId: part.id,
               toolName: part.name,
-              result: part.output,
-              providerExecuted: true
+              result: part.output
             });
           }
           break;
@@ -417,8 +457,7 @@ var HuggingFaceResponsesLanguageModel = class {
               type: "tool-result",
               toolCallId: part.id,
               toolName: "list_tools",
-              result: { tools: part.tools },
-              providerExecuted: true
+              result: { tools: part.tools }
             });
           }
           break;
@@ -447,14 +486,13 @@ var HuggingFaceResponsesLanguageModel = class {
     }
     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)
+      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,
@@ -491,13 +529,12 @@ var HuggingFaceResponsesLanguageModel = class {
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    let finishReason = "unknown";
-    let responseId = null;
-    const usage = {
-      inputTokens: void 0,
-      outputTokens: void 0,
-      totalTokens: void 0
+    let finishReason = {
+      unified: "other",
+      raw: void 0
     };
+    let responseId = null;
+    let usage = void 0;
     return {
       stream: response.pipeThrough(
         new TransformStream({
@@ -505,9 +542,12 @@ var HuggingFaceResponsesLanguageModel = class {
             controller.enqueue({ type: "stream-start", warnings });
           },
           transform(chunk, controller) {
-            var _a, _b, _c;
+            var _a, _b, _c, _d;
             if (!chunk.success) {
-              finishReason = "error";
+              finishReason = {
+                unified: "error",
+                raw: void 0
+              };
               controller.enqueue({ type: "error", error: chunk.error });
               return;
             }
@@ -539,6 +579,16 @@ var HuggingFaceResponsesLanguageModel = class {
                   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;
             }
@@ -572,16 +622,32 @@ var HuggingFaceResponsesLanguageModel = class {
             }
             if (isResponseCompletedChunk(value)) {
               responseId = value.response.id;
-              finishReason = mapHuggingFaceResponsesFinishReason(
-                (_b = (_a = value.response.incomplete_details) == null ? void 0 : _a.reason) != null ? _b : "stop"
-              );
+              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.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;
+                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",
@@ -595,7 +661,7 @@ var HuggingFaceResponsesLanguageModel = class {
             controller.enqueue({
               type: "finish",
               finishReason,
-              usage,
+              usage: convertHuggingFaceResponsesUsage(usage),
               providerMetadata: {
                 huggingface: {
                   responseId
@@ -610,150 +676,239 @@ var HuggingFaceResponsesLanguageModel = class {
     };
   }
 };
-var huggingfaceResponsesProviderOptionsSchema = z2.object({
-  metadata: z2.record(z2.string(), z2.string()).optional(),
-  instructions: z2.string().optional(),
-  strictJsonSchema: z2.boolean().optional()
+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 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()
+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()
+      })
+    )
+  }),
+  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()
+      })
+    ),
+    summary: import_v42.z.array(
+      import_v42.z.object({
+        type: import_v42.z.literal("reasoning_summary"),
+        text: import_v42.z.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()
+  }),
+  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()
+  }),
+  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()
+  })
+]);
+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()
   }).nullable().optional(),
-  usage: z2.object({
-    input_tokens: z2.number(),
-    input_tokens_details: z2.object({
-      cached_tokens: z2.number()
+  usage: import_v42.z.object({
+    input_tokens: import_v42.z.number(),
+    input_tokens_details: import_v42.z.object({
+      cached_tokens: import_v42.z.number()
     }).optional(),
-    output_tokens: z2.number(),
-    output_tokens_details: z2.object({
-      reasoning_tokens: z2.number()
+    output_tokens: import_v42.z.number(),
+    output_tokens_details: import_v42.z.object({
+      reasoning_tokens: import_v42.z.number()
     }).optional(),
-    total_tokens: z2.number()
+    total_tokens: import_v42.z.number()
   }).nullable().optional(),
-  output: z2.array(z2.any()),
-  output_text: z2.string().nullable().optional()
+  output: import_v42.z.array(huggingfaceResponsesOutputSchema),
+  output_text: import_v42.z.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()
+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()
+    }),
+    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()
     }),
-    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()
+    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()
     }),
-    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()
+    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()
     }),
-    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()
+    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()
     })
   ]),
-  sequence_number: z2.number()
+  sequence_number: import_v42.z.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()
+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()
     }),
-    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()
+    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()
     }),
-    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()
+    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()
     }),
-    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()
+    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()
+    }),
+    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()
     })
   ]),
-  sequence_number: z2.number()
+  sequence_number: import_v42.z.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 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 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 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 responseCompletedChunkSchema = z2.object({
-  type: z2.literal("response.completed"),
+var responseCompletedChunkSchema = import_v42.z.object({
+  type: import_v42.z.literal("response.completed"),
   response: huggingfaceResponsesResponseSchema,
-  sequence_number: z2.number()
+  sequence_number: import_v42.z.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 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 huggingfaceResponsesChunkSchema = z2.union([
+var huggingfaceResponsesChunkSchema = import_v42.z.union([
   responseOutputItemAddedSchema,
   responseOutputItemDoneSchema,
+  reasoningTextDeltaChunkSchema,
+  reasoningTextEndChunkSchema,
   textDeltaChunkSchema,
   responseCompletedChunkSchema,
   responseCreatedChunkSchema,
-  z2.object({ type: z2.string() }).loose()
+  import_v42.z.object({ type: import_v42.z.string() }).loose()
   // fallback for unknown chunks
 ]);
 function isResponseOutputItemAddedChunk(chunk) {
@@ -765,6 +920,12 @@ function isResponseOutputItemDoneChunk(chunk) {
 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";
 }
@@ -795,15 +956,17 @@ function createHuggingFace(options = {}) {
     });
   };
   const provider = (modelId) => createResponsesModel(modelId);
+  provider.specificationVersion = "v3";
   provider.languageModel = createResponsesModel;
   provider.responses = createResponsesModel;
-  provider.textEmbeddingModel = (modelId) => {
+  provider.embeddingModel = (modelId) => {
     throw new import_provider3.NoSuchModelError({
       modelId,
-      modelType: "textEmbeddingModel",
+      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 import_provider3.NoSuchModelError({
       modelId,