@xsai/text 1.0.0-beta.5 → 1.0.0-beta.6

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { S as StepEndDoneEvent, T as ToolCallPart, a as ToolResultPart, U as Usage, b as TextEvent, M as Message, L as LanguageModelOptions, c as LanguageModel, d as ToolExecuteOptions } from './language-model-Dne8NRLD.js';
-export { A as AssistantMessage, e as AssistantMessageContent, f as AudioPart, C as CombinedStandardSchema, g as Content, h as ContentEndEvent, i as ContentMap, j as ContentStartEvent, k as ContentType, D as DeveloperMessage, l as DeveloperMessageContent, E as ExecutableTool, F as FilePart, m as FinishReason, I as ImagePart, n as InferSchemaInput, o as InferSchemaOutput, J as JSONSchema7, p as JSONSchema7Definition, q as LanguageModelProviderOptions, r as MessageMap, s as MessageProviderMetadata, t as MessageType, P as PartProviderMetadata, u as ProviderPart, R as RawEvent, v as ReasoningDeltaEvent, w as ReasoningPart, x as ReasoningPartContent, y as RefusalDeltaEvent, z as RefusalPart, B as ResolvedSchema, G as StepEndEvent, H as StepEndFailEvent, K as StepStartEvent, N as StepStatus, O as SystemMessage, Q as SystemMessageContent, V as TextDeltaEvent, W as TextEventMap, X as TextEventType, Y as TextPart, Z as Tool, _ as ToolCallDeltaEvent, $ as ToolChoice, a0 as ToolOptions, a1 as ToolResultPartContent, a2 as UnresolvedSchema, a3 as UserMessage, a4 as UserMessageContent, a5 as resolveSchema, a6 as tool } from './language-model-Dne8NRLD.js';
+import { S as StepEndDoneEvent, T as ToolCallPart, a as ToolResultPart, U as Usage, b as TextEvent, M as Message, L as LanguageModelOptions, c as LanguageModel, d as ToolExecuteOptions } from './language-model-CAPBb-ti.js';
+export { A as AssistantMessage, e as AssistantMessageContent, f as AudioPart, C as CombinedStandardSchema, g as Content, h as ContentEndEvent, i as ContentMap, j as ContentStartEvent, k as ContentType, D as DeveloperMessage, l as DeveloperMessageContent, E as ExecutableTool, F as FilePart, m as FinishReason, I as ImagePart, n as InferSchemaInput, o as InferSchemaOutput, J as JSONSchema7, p as JSONSchema7Definition, q as LanguageModelProviderOptions, r as MessageMap, s as MessageProviderMetadata, t as MessageType, P as PartProviderMetadata, u as ProviderPart, R as RawEvent, v as ReasoningDeltaEvent, w as ReasoningPart, x as ReasoningPartContent, y as RefusalDeltaEvent, z as RefusalPart, B as ResolvedSchema, G as StepEndEvent, H as StepEndFailEvent, K as StepStartEvent, N as StepStatus, O as SystemMessage, Q as SystemMessageContent, V as TextDeltaEvent, W as TextEventMap, X as TextEventType, Y as TextPart, Z as Tool, _ as ToolCallDeltaEvent, $ as ToolChoice, a0 as ToolOptions, a1 as ToolResultPartContent, a2 as UnresolvedSchema, a3 as UserMessage, a4 as UserMessageContent, a5 as formatIssues, a6 as resolveSchema, a7 as tool } from './language-model-CAPBb-ti.js';
 import { Promisable } from '@xsai/shared';
 export { HttpError, XSAIError, XSAIErrorCause, XSAIErrorCauseMap, XSAIErrorCode, XSAIErrorOptions } from '@xsai/shared';
 
@@ -40,8 +40,13 @@ declare const hasToolCall: (name?: string) => StopCondition;
 /** @deprecated use `maxSteps` instead. */
 declare const stepCountAtLeast: (count: number) => StopCondition;
 
+interface ExecuteToolOptions extends Pick<LanguageModelOptions, 'signal' | 'tools'> {
+    postToolCall?: PostToolCall;
+    preToolCall?: PreToolCall;
+}
 type PostToolCall = (toolResult: ToolResultPart, options: ToolExecuteOptions) => Promisable<ToolResultPart | void>;
 type PreToolCall = (toolCall: ToolCallPart, options: ToolExecuteOptions) => Promisable<ToolCallPart | ToolResultPart | void>;
+declare const executeTool: (call: ToolCallPart, { postToolCall, preToolCall, signal, tools }: ExecuteToolOptions) => Promise<ToolResultPart>;
 
 interface StreamTextOptions extends LanguageModelOptions {
     postToolCall?: PostToolCall;
@@ -82,5 +87,5 @@ declare module '@xsai/shared' {
     }
 }
 
-export { LanguageModel, LanguageModelOptions, Message, StepEndDoneEvent, TextEvent, TextEventTarget, ToolCallPart, ToolExecuteOptions, ToolResultPart, Usage, and, collect, generateText, hasToolCall, maxSteps, not, or, stepCountAtLeast, streamText, toCustomEvent, withEventTarget };
-export type { CollectResult, PostToolCall, PreToolCall, PrepareStep, PrepareStepOptions, PrepareStepResult, StepResult, StopCondition, StopContext, StreamTextOptions };
+export { LanguageModel, LanguageModelOptions, Message, StepEndDoneEvent, TextEvent, TextEventTarget, ToolCallPart, ToolExecuteOptions, ToolResultPart, Usage, and, collect, executeTool, generateText, hasToolCall, maxSteps, not, or, stepCountAtLeast, streamText, toCustomEvent, withEventTarget };
+export type { CollectResult, ExecuteToolOptions, PostToolCall, PreToolCall, PrepareStep, PrepareStepOptions, PrepareStepResult, StepResult, StopCondition, StopContext, StreamTextOptions };

package/dist/index.js

@@ -1,6 +1,6 @@
 import { XSAIError } from '@xsai/shared';
 export { HttpError, XSAIError } from '@xsai/shared';
-import { r as resolveSchema } from './schema-Bny4Y6lV.js';
+import { f as formatIssues, r as readStep, a as resolveSchema } from './read-step-DXGjtk1d.js';
 
 const getText = (message) => typeof message.content === "string" ? message.content : message.content.filter((part) => part.type === "text").map((part) => part.text).join("");
 const getToolCalls = (message) => typeof message.content === "string" ? [] : message.content.filter((part) => part.type === "tool-call");
@@ -80,7 +80,7 @@ const assertSameCallId = (source, next) => {
   if (source !== next)
     throw new Error(`Tool call hooks must preserve callId "${source}".`);
 };
-const catchToolError = async (call, signal, callback) => {
+const attempt = async (call, signal, callback) => {
   try {
     return await callback();
   } catch (error) {
@@ -88,85 +88,48 @@ const catchToolError = async (call, signal, callback) => {
     return toolError(call, error instanceof Error ? error.message : String(error));
   }
 };
+const parseInput = (args) => {
+  try {
+    return JSON.parse(args.trim() || "{}");
+  } catch {
+    throw new Error("Failed to parse tool input.");
+  }
+};
+const runTool = async (call, tools, options) => {
+  const tool = tools?.find((candidate) => candidate.name === call.name);
+  if (tool == null) {
+    const available = tools?.map((candidate) => candidate.name).join(", ");
+    throw new Error(`Model tried to call unavailable tool "${call.name}", ${available == null || available === "" ? "No tools are available" : `Available tools: ${available}`}.`);
+  }
+  if (tool.execute == null)
+    throw new Error(`Tool "${call.name}" is not executable.`);
+  let input = parseInput(call.arguments);
+  if (tool.inputSchema.validate != null) {
+    const validation = await tool.inputSchema.validate(input);
+    if (validation.issues)
+      throw new Error(`Tool input validation failed for "${call.name}": ${formatIssues(validation.issues)}`);
+    input = validation.value;
+  }
+  return { callId: call.callId, output: await tool.execute(input, options), type: "tool-result" };
+};
 const executeTool = async (call, { postToolCall, preToolCall, signal, tools }) => {
-  const executeOptions = { callId: call.callId, signal };
-  const preToolCallResult = await catchToolError(call, signal, async () => preToolCall?.(call, executeOptions));
-  if (preToolCallResult != null) {
-    assertSameCallId(call.callId, preToolCallResult.callId);
-    if (preToolCallResult.type === "tool-result")
-      return preToolCallResult;
-    call = preToolCallResult;
+  const options = { callId: call.callId, signal };
+  const prepared = await attempt(call, signal, async () => preToolCall?.(call, options));
+  if (prepared != null) {
+    assertSameCallId(call.callId, prepared.callId);
+    if (prepared.type === "tool-result")
+      return prepared;
+    call = prepared;
   }
-  let shouldPostToolCall = false;
-  const toolResult = await catchToolError(call, signal, async () => {
-    const tool = tools?.find((candidate) => candidate.name === call.name);
-    const executableTool = tool;
-    if (executableTool == null || executableTool.execute == null) {
-      const available = tools?.map((candidate) => candidate.name).join(", ");
-      return toolError(call, tool == null ? `Model tried to call unavailable tool "${call.name}", ${available == null || available === "" ? "No tools are available" : `Available tools: ${available}`}.` : `Tool "${call.name}" is not executable.`);
-    }
-    let toolInput;
-    try {
-      toolInput = JSON.parse(call.arguments.trim() || "{}");
-    } catch {
-      return toolError(call, "Failed to parse tool input.");
-    }
-    let validatedInput = toolInput;
-    if (executableTool.inputSchema.validate != null) {
-      const validation = await executableTool.inputSchema.validate(toolInput);
-      if (validation.issues)
-        return toolError(call, `Tool input validation failed for "${call.name}".`);
-      validatedInput = validation.value;
-    }
-    shouldPostToolCall = true;
-    return {
-      callId: call.callId,
-      output: await executableTool.execute(validatedInput, executeOptions),
-      type: "tool-result"
-    };
-  });
-  if (!shouldPostToolCall || postToolCall == null)
-    return toolResult;
-  const postToolCallResult = await catchToolError(call, signal, async () => postToolCall(toolResult, executeOptions));
-  if (postToolCallResult == null)
-    return toolResult;
-  assertSameCallId(toolResult.callId, postToolCallResult.callId);
-  return postToolCallResult;
+  const result = await attempt(call, signal, async () => runTool(call, tools, options));
+  const posted = await attempt(call, signal, async () => postToolCall?.(result, options));
+  if (posted == null)
+    return result;
+  assertSameCallId(result.callId, posted.callId);
+  return posted;
 };
 const executeTools = async ({ reason, toolCalls, ...options }) => reason === "length" ? toolCalls.map((call) => toolError(call, "The response reached the output token limit before the tool call was complete.")) : Promise.all(toolCalls.map(async (call) => executeTool(call, options)));
 
-const readStep = async function* (stream, signal) {
-  const reader = stream.getReader();
-  let cancellation;
-  const abort = () => {
-    cancellation = reader.cancel(signal.reason);
-    void cancellation.catch(() => {
-    });
-  };
-  let stepEnd;
-  signal.addEventListener("abort", abort, { once: true });
-  try {
-    signal.throwIfAborted();
-    while (true) {
-      const { done, value: event } = await reader.read();
-      signal.throwIfAborted();
-      if (done)
-        break;
-      if (event.type === "step.end") {
-        if (stepEnd != null)
-          throw new XSAIError("protocol-error", "model stream produced more than one step.end event");
-        stepEnd = event;
-      }
-      yield event;
-    }
-    if (stepEnd == null)
-      throw new XSAIError("truncated-stream", "model stream ended without a step.end event");
-    return stepEnd;
-  } finally {
-    signal.removeEventListener("abort", abort);
-    await (cancellation ?? reader.cancel(signal.reason)).finally(() => reader.releaseLock());
-  }
-};
 const streamText = (model, { postToolCall, prepareStep, preToolCall, stopWhen: stopWhenOption, ...options }) => {
   const stopWhen = stopWhenOption ?? maxSteps(10);
   const input = [...Array.isArray(options.input) ? options.input : [{ content: options.input, role: "user" }]];
@@ -263,7 +226,7 @@ const tool = ((options) => {
         if (outputSchema?.validate != null) {
           const validation = await outputSchema.validate(result);
           if (validation.issues)
-            throw new Error(`Tool output validation failed for "${options.name}".`);
+            throw new Error(`Tool output validation failed for "${options.name}": ${formatIssues(validation.issues)}`);
           result = validation.value;
         }
         if (outputSchema)
@@ -275,4 +238,4 @@ const tool = ((options) => {
   }
 });
 
-export { TextEventTarget, and, collect, generateText, hasToolCall, maxSteps, not, or, stepCountAtLeast, streamText, toCustomEvent, tool, withEventTarget };
+export { TextEventTarget, and, collect, executeTool, generateText, hasToolCall, maxSteps, not, or, stepCountAtLeast, streamText, toCustomEvent, tool, withEventTarget };

package/dist/internal.d.ts

@@ -1,5 +1,5 @@
-import { StepStatus, FinishReason, AssistantMessage, AssistantMessageContent, PartProviderMetadata, Usage, TextEvent, LanguageModelOptions } from './index.js';
-export { C as CombinedStandardSchema, n as InferSchemaInput, o as InferSchemaOutput, J as JSONSchema7, p as JSONSchema7Definition, B as ResolvedSchema, a2 as UnresolvedSchema, a5 as resolveSchema } from './language-model-Dne8NRLD.js';
+import { StepStatus, FinishReason, AssistantMessage, AssistantMessageContent, PartProviderMetadata, Usage, TextEvent, StepEndEvent, LanguageModelOptions } from './index.js';
+export { C as CombinedStandardSchema, n as InferSchemaInput, o as InferSchemaOutput, J as JSONSchema7, p as JSONSchema7Definition, B as ResolvedSchema, a2 as UnresolvedSchema, a5 as formatIssues, a6 as resolveSchema } from './language-model-CAPBb-ti.js';
 import { XSAIError, EventSourceMessage, SendRequestOptions, HttpOptions } from '@xsai/shared';
 
 interface EventBuilder {
@@ -17,6 +17,7 @@ interface EventBuilder {
 }
 interface FinishMeta {
     messageId?: string;
+    model?: string;
     usage?: Usage;
 }
 interface PartDeltaExtra {
@@ -51,8 +52,24 @@ declare class EventSourceDataStream extends TransformStream<EventSourceMessage,
     constructor();
 }
 
+/**
+ * Reads a model stream until it ends or `signal` aborts. Unlike `for await` on the stream itself,
+ * an abort ends a pending read even if the model ignores its signal, and the model sees the reason.
+ * Not covered by semver.
+ *
+ * @internal
+ */
+declare const readEvents: (stream: ReadableStream<TextEvent>, signal: AbortSignal) => AsyncGenerator<TextEvent, void>;
+/**
+ * Reads one model step and checks that it has exactly one `step.end`.
+ * Not covered by semver.
+ *
+ * @internal
+ */
+declare const readStep: (stream: ReadableStream<TextEvent>, signal: AbortSignal) => AsyncGenerator<TextEvent, StepEndEvent>;
+
 /** @internal */
 declare const wireRequest: (options: SendRequestOptions, httpOptions: HttpOptions, modelOptions: LanguageModelOptions, eventStream: TransformStream<string, TextEvent>) => Promise<ReadableStream<TextEvent>>;
 
-export { EventSourceDataStream, WireEventStream, eventBuilder, wireRequest };
+export { EventSourceDataStream, WireEventStream, eventBuilder, readEvents, readStep, wireRequest };
 export type { EventBuilder, FinishMeta, PartDeltaExtra, PartEndExtra, PartKey, PartStartInit };

package/dist/internal.js

@@ -1,5 +1,5 @@
 import { XSAIError, sendRequest, EventSourceParserStream } from '@xsai/shared';
-export { r as resolveSchema } from './schema-Bny4Y6lV.js';
+export { f as formatIssues, b as readEvents, r as readStep, a as resolveSchema } from './read-step-DXGjtk1d.js';
 
 const emptyContent = (type, init) => {
   switch (type) {
@@ -28,6 +28,7 @@ const eventBuilder = (emit, fail) => {
   let terminalEmitted = false;
   let messageId;
   let terminal;
+  let model;
   let usage;
   const updateReasoning = (state, text) => {
     if (text === "")
@@ -139,6 +140,7 @@ const eventBuilder = (emit, fail) => {
     };
     const common = {
       message: message.id == null && messageId != null ? { ...message, id: messageId } : message,
+      model,
       type: "step.end",
       usage
     };
@@ -186,6 +188,8 @@ const eventBuilder = (emit, fail) => {
     meta: (meta) => {
       if (meta.messageId != null)
         messageId = meta.messageId;
+      if (meta.model != null)
+        model = meta.model;
       if (meta.usage != null)
         usage = meta.usage;
     },

package/dist/{language-model-Dne8NRLD.d.ts → language-model-CAPBb-ti.d.ts}

@@ -82,6 +82,7 @@ interface AssistantMessage {
 type AssistantMessageContent = ProviderPart | ReasoningPart | RefusalPart | TextPart | ToolCallPart;
 interface DeveloperMessage {
     content: readonly DeveloperMessageContent[] | string;
+    providerMetadata?: MessageProviderMetadata;
     role: 'developer';
 }
 type DeveloperMessageContent = TextPart;
@@ -95,6 +96,7 @@ interface MessageMap {
 type MessageType = keyof MessageMap;
 interface SystemMessage {
     content: readonly SystemMessageContent[] | string;
+    providerMetadata?: MessageProviderMetadata;
     role: 'system';
 }
 type SystemMessageContent = TextPart;
@@ -141,6 +143,8 @@ interface RefusalDeltaEvent {
 interface StepEndDoneEvent {
     error?: never;
     message: AssistantMessage;
+    /** The model that the provider says answered, if it says. */
+    model?: string;
     reason?: FinishReason;
     status: Exclude<StepStatus, 'failed'>;
     type: 'step.end';
@@ -151,6 +155,8 @@ type StepEndEvent = StepEndDoneEvent | StepEndFailEvent;
 interface StepEndFailEvent {
     error: XSAIError;
     message: AssistantMessage;
+    /** The model that the provider says answered, if it says. */
+    model?: string;
     reason?: never;
     status: 'failed';
     type: 'step.end';
@@ -481,6 +487,7 @@ interface ResolvedSchema<Input = unknown, Output = Input> {
     validate?: StandardSchemaV1.Props<Input, Output>['validate'];
 }
 type UnresolvedSchema<Input = unknown, Output = Input> = CombinedStandardSchema<Input, Output> | JSONSchema7;
+declare const formatIssues: (issues: readonly StandardSchemaV1.Issue[]) => string;
 declare const resolveSchema: <Input = unknown, Output = Input>(schema: UnresolvedSchema<Input, Output>) => ResolvedSchema<Input, Output>;
 
 interface ExecutableTool extends Tool {
@@ -532,5 +539,5 @@ type ToolChoice = 'auto' | 'none' | 'required' | {
     name: string;
 };
 
-export { resolveSchema as a5, tool as a6 };
+export { formatIssues as a5, resolveSchema as a6, tool as a7 };
 export type { ToolChoice as $, AssistantMessage as A, ResolvedSchema as B, CombinedStandardSchema as C, DeveloperMessage as D, ExecutableTool as E, FilePart as F, StepEndEvent as G, StepEndFailEvent as H, ImagePart as I, JSONSchema7 as J, StepStartEvent as K, LanguageModelOptions as L, Message as M, StepStatus as N, SystemMessage as O, PartProviderMetadata as P, SystemMessageContent as Q, RawEvent as R, StepEndDoneEvent as S, ToolCallPart as T, Usage as U, TextDeltaEvent as V, TextEventMap as W, TextEventType as X, TextPart as Y, Tool as Z, ToolCallDeltaEvent as _, ToolResultPart as a, ToolOptions as a0, ToolResultPartContent as a1, UnresolvedSchema as a2, UserMessage as a3, UserMessageContent as a4, TextEvent as b, LanguageModel as c, ToolExecuteOptions as d, AssistantMessageContent as e, AudioPart as f, Content as g, ContentEndEvent as h, ContentMap as i, ContentStartEvent as j, ContentType as k, DeveloperMessageContent as l, FinishReason as m, InferSchemaInput as n, InferSchemaOutput as o, JSONSchema7Definition as p, LanguageModelProviderOptions as q, MessageMap as r, MessageProviderMetadata as s, MessageType as t, ProviderPart as u, ReasoningDeltaEvent as v, ReasoningPart as w, ReasoningPartContent as x, RefusalDeltaEvent as y, RefusalPart as z };

package/dist/read-step-DXGjtk1d.js

@@ -0,0 +1,50 @@
+import { XSAIError } from '@xsai/shared';
+
+const formatIssues = (issues) => issues.map(({ message, path }) => {
+  const location = path?.map((segment) => String(typeof segment === "object" ? segment.key : segment)).join(".");
+  return location == null || location === "" ? message : `${location}: ${message}`;
+}).join("; ");
+const resolveSchema = (schema) => "~standard" in schema ? {
+  schema: schema["~standard"].jsonSchema.input({ target: "draft-07" }),
+  validate: schema["~standard"].validate
+} : { schema };
+
+const readEvents = async function* (stream, signal) {
+  const reader = stream.getReader();
+  let cancellation;
+  const abort = () => {
+    cancellation = reader.cancel(signal.reason);
+    void cancellation.catch(() => {
+    });
+  };
+  signal.addEventListener("abort", abort, { once: true });
+  try {
+    signal.throwIfAborted();
+    while (true) {
+      const { done, value } = await reader.read();
+      signal.throwIfAborted();
+      if (done)
+        return;
+      yield value;
+    }
+  } finally {
+    signal.removeEventListener("abort", abort);
+    await (cancellation ?? reader.cancel(signal.reason)).finally(() => reader.releaseLock());
+  }
+};
+const readStep = async function* (stream, signal) {
+  let stepEnd;
+  for await (const event of readEvents(stream, signal)) {
+    if (event.type === "step.end") {
+      if (stepEnd != null)
+        throw new XSAIError("protocol-error", "model stream produced more than one step.end event");
+      stepEnd = event;
+    }
+    yield event;
+  }
+  if (stepEnd == null)
+    throw new XSAIError("truncated-stream", "model stream ended without a step.end event");
+  return stepEnd;
+};
+
+export { resolveSchema as a, readEvents as b, formatIssues as f, readStep as r };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xsai/text",
   "type": "module",
-  "version": "1.0.0-beta.5",
+  "version": "1.0.0-beta.6",
   "description": "extra-small AI SDK: provider-agnostic text generation, streaming and tool calling.",
   "author": "Moeru AI",
   "license": "MIT",
@@ -41,7 +41,7 @@
     "node": ">=26"
   },
   "dependencies": {
-    "@xsai/shared": "1.0.0-beta.5"
+    "@xsai/shared": "1.0.0-beta.6"
   },
   "devDependencies": {
     "@standard-schema/spec": "1.1.0",

package/dist/schema-Bny4Y6lV.js

@@ -1,6 +0,0 @@
-const resolveSchema = (schema) => "~standard" in schema ? {
-  schema: schema["~standard"].jsonSchema.input({ target: "draft-07" }),
-  validate: schema["~standard"].validate
-} : { schema };
-
-export { resolveSchema as r };