@xsai/text 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/index.d.ts

@@ -1,8 +1,20 @@
-import { M as Message, S as StepResult, L as LanguageModelOptions, a as LanguageModel, T as ToolResultPart, b as ToolExecuteOptions, c as ToolCallPart, d as TextEvent, C as CollectResult } from './language-model-DlNwTTFi.js';
-export { A as AssistantMessage, e as AssistantMessageContent, f 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 StepEndDoneEvent, H as StepEndEvent, K as StepEndFailEvent, N as StepStartEvent, O as StepStatus, Q as SystemMessage, U 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 Usage, a4 as UserMessage, a5 as UserMessageContent, a6 as collect, a7 as resolveSchema, a8 as tool } from './language-model-DlNwTTFi.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-rSwDu2og.js';
+export { A as AssistantMessage, e as AssistantMessageContent, C as CombinedStandardSchema, f as Content, g as ContentEndEvent, h as ContentMap, i as ContentStartEvent, j as ContentType, D as DeveloperMessage, k as DeveloperMessageContent, E as ExecutableTool, F as FilePart, l as FinishReason, I as ImagePart, m as InferSchemaInput, n as InferSchemaOutput, J as JSONSchema7, o as JSONSchema7Definition, p as LanguageModelProviderOptions, q as MessageMap, r as MessageProviderMetadata, s as MessageType, P as PartProviderMetadata, t as ProviderPart, R as RawEvent, u as ReasoningDeltaEvent, v as ReasoningPart, w as ReasoningPartContent, x as RefusalDeltaEvent, y as RefusalPart, z as ResolvedSchema, B as StepEndEvent, G as StepEndFailEvent, H as StepStartEvent, K as StepStatus, N as SystemMessage, O as SystemMessageContent, Q as TextDeltaEvent, V as TextEventMap, W as TextEventType, X as TextPart, Y as Tool, Z as ToolCallDeltaEvent, _ as ToolChoice, $ as ToolOptions, a0 as ToolResultPartContent, a1 as UnresolvedSchema, a2 as UserMessage, a3 as UserMessageContent, a4 as resolveSchema, a5 as tool } from './language-model-rSwDu2og.js';
 import { Promisable } from '@xsai/shared';
 export { HttpError, XSAIError, XSAIErrorCause, XSAIErrorCauseMap, XSAIErrorCode, XSAIErrorOptions } from '@xsai/shared';
 
+interface StepResult extends Omit<StepEndDoneEvent, 'error' | 'type'> {
+    text: string;
+    toolCalls: ToolCallPart[];
+    toolResults: ToolResultPart[];
+}
+
+interface CollectResult extends StepResult {
+    steps: readonly StepResult[];
+    totalUsage?: Usage;
+}
+declare const collect: (stream: ReadableStream<TextEvent>) => Promise<CollectResult>;
+
 type PrepareStep = (options: PrepareStepOptions) => Promisable<PrepareStepResult | undefined>;
 interface PrepareStepOptions {
     input: readonly Message[];
@@ -31,22 +43,16 @@ declare const stepCountAtLeast: (count: number) => StopCondition;
 type PostToolCall = (toolResult: ToolResultPart, options: ToolExecuteOptions) => Promisable<ToolResultPart | void>;
 type PreToolCall = (toolCall: ToolCallPart, options: ToolExecuteOptions) => Promisable<ToolCallPart | ToolResultPart | void>;
 
-interface LoopOptions extends LanguageModelOptions {
+interface StreamTextOptions extends LanguageModelOptions {
     postToolCall?: PostToolCall;
     prepareStep?: PrepareStep;
     preToolCall?: PreToolCall;
     /** @default `maxSteps(10)` */
     stopWhen?: StopCondition;
 }
-declare const loop: (model: LanguageModel, { postToolCall, prepareStep, preToolCall, stopWhen: stopWhenOption, ...options }: LoopOptions) => ReadableStream<TextEvent>;
-
-declare const generateText: (model: LanguageModel, options: LoopOptions) => Promise<CollectResult>;
+declare const streamText: (model: LanguageModel, { postToolCall, prepareStep, preToolCall, stopWhen: stopWhenOption, ...options }: StreamTextOptions) => ReadableStream<TextEvent>;
 
-interface StreamTextHandle {
-    result: Promise<CollectResult>;
-    stream: ReadableStream<TextEvent>;
-}
-declare const streamText: (model: LanguageModel, options: LoopOptions) => StreamTextHandle;
+declare const generateText: (model: LanguageModel, options: StreamTextOptions) => Promise<CollectResult>;
 
 type TextEventListener<E extends Event> = ((this: EventTarget, event: E) => unknown) | {
     handleEvent: (event: E) => unknown;
@@ -76,5 +82,5 @@ declare module '@xsai/shared' {
     }
 }
 
-export { CollectResult, LanguageModel, LanguageModelOptions, Message, StepResult, TextEvent, TextEventTarget, ToolCallPart, ToolExecuteOptions, ToolResultPart, and, generateText, hasToolCall, loop, maxSteps, not, or, stepCountAtLeast, streamText, toCustomEvent, withEventTarget };
-export type { LoopOptions, PostToolCall, PreToolCall, PrepareStep, PrepareStepOptions, PrepareStepResult, StopCondition, StopContext, StreamTextHandle };
+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 };

package/dist/index.js

@@ -1,6 +1,67 @@
-import { t as toStepResult, c as collect, a as collectEvent, b as collectResult, r as resolveSchema } from './schema-7PLOBVJ3.js';
 import { XSAIError } from '@xsai/shared';
 export { HttpError, XSAIError } from '@xsai/shared';
+import { r as resolveSchema } from './schema-Bny4Y6lV.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");
+const toStepResult = (event) => {
+  const { type: _type, ...result } = event;
+  return {
+    ...result,
+    text: getText(event.message),
+    toolCalls: getToolCalls(event.message),
+    toolResults: []
+  };
+};
+
+const totalUsage = (steps) => {
+  const usages = steps.flatMap((step) => step.usage == null ? [] : [step.usage]);
+  if (usages.length === 0)
+    return void 0;
+  const sum = (key) => {
+    const values = usages.map((usage) => usage[key]).filter((value) => value != null);
+    return values.length === 0 ? void 0 : values.reduce((total, value) => total + value, 0);
+  };
+  return {
+    cacheCreationInputTokens: sum("cacheCreationInputTokens"),
+    cacheReadInputTokens: sum("cacheReadInputTokens"),
+    inputTokens: sum("inputTokens") ?? 0,
+    outputTokens: sum("outputTokens") ?? 0,
+    reasoningTokens: sum("reasoningTokens"),
+    totalTokens: sum("totalTokens") ?? 0
+  };
+};
+const collect = async (stream) => {
+  const steps = [];
+  let failedError;
+  for await (const event of stream) {
+    if (failedError != null)
+      continue;
+    if (event.type === "step.end") {
+      if (event.status === "failed")
+        failedError = event.error;
+      else
+        steps.push(toStepResult(event));
+      continue;
+    }
+    if (event.type !== "content.end" || event.content.type !== "tool-result")
+      continue;
+    const step = steps.at(-1);
+    if (step == null)
+      throw new XSAIError("protocol-error", "tool result arrived before a step.end event");
+    step.toolResults.push(event.content);
+  }
+  if (failedError != null)
+    throw failedError;
+  const finalStep = steps.at(-1);
+  if (finalStep == null)
+    throw new XSAIError("truncated-stream", "model stream ended without a step.end event");
+  return {
+    ...finalStep,
+    steps,
+    totalUsage: totalUsage(steps)
+  };
+};
 
 const and = (...conditions) => (context) => conditions.every((condition) => condition(context));
 const or = (...conditions) => (context) => conditions.some((condition) => condition(context));
@@ -75,21 +136,38 @@ const executeTool = async (call, { postToolCall, preToolCall, signal, tools }) =
 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;
-  for await (const event of stream.pipeThrough(new TransformStream(), { 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;
+  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;
     }
-    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());
   }
-  signal.throwIfAborted();
-  if (stepEnd == null)
-    throw new XSAIError("truncated-stream", "model stream ended without a step.end event");
-  return stepEnd;
 };
-const loop = (model, { postToolCall, prepareStep, preToolCall, stopWhen: stopWhenOption, ...options }) => {
+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" }]];
   const steps = [];
@@ -150,59 +228,7 @@ const loop = (model, { postToolCall, prepareStep, preToolCall, stopWhen: stopWhe
   }, { highWaterMark: 0 });
 };
 
-const generateText = async (model, options) => collect(loop(model, options));
-
-const streamText = (model, options) => {
-  const result = Promise.withResolvers();
-  void result.promise.catch(() => {
-  });
-  const steps = [];
-  let sourceReader;
-  let cancelled = false;
-  const stream = new ReadableStream({
-    cancel: async (reason) => {
-      cancelled = true;
-      result.reject(reason === void 0 ? new DOMException("The operation was aborted.", "AbortError") : reason);
-      await sourceReader?.cancel(reason);
-    },
-    start: (controller) => {
-      const reader = loop(model, options).getReader();
-      sourceReader = reader;
-      void (async () => {
-        let failedError;
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-              break;
-            if (cancelled)
-              return;
-            failedError ??= collectEvent(steps, value);
-            controller.enqueue(value);
-          }
-          if (cancelled)
-            return;
-          if (failedError != null) {
-            result.reject(failedError);
-            controller.close();
-            return;
-          }
-          result.resolve(collectResult(steps));
-          controller.close();
-        } catch (error) {
-          if (cancelled)
-            return;
-          result.reject(error);
-          controller.error(error);
-        } finally {
-          sourceReader = void 0;
-          reader.releaseLock();
-        }
-      })();
-    }
-  });
-  return { result: result.promise, stream };
-};
+const generateText = async (model, options) => collect(streamText(model, options));
 
 const TextEventTarget = EventTarget;
 const toCustomEvent = (event) => {
@@ -233,7 +259,13 @@ const tool = ((options) => {
     return {
       ...tool2,
       execute: async (input, executeOptions) => {
-        const result = await options.execute(input, executeOptions);
+        let result = await options.execute(input, executeOptions);
+        if (outputSchema?.validate != null) {
+          const validation = await outputSchema.validate(result);
+          if (validation.issues)
+            throw new Error(`Tool output validation failed for "${options.name}".`);
+          result = validation.value;
+        }
         if (outputSchema)
           return JSON.stringify(result);
         else
@@ -243,4 +275,4 @@ const tool = ((options) => {
   }
 });
 
-export { TextEventTarget, and, collect, generateText, hasToolCall, loop, maxSteps, not, or, stepCountAtLeast, streamText, toCustomEvent, tool, withEventTarget };
+export { TextEventTarget, and, collect, 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 { f as CombinedStandardSchema, n as InferSchemaInput, o as InferSchemaOutput, J as JSONSchema7, p as JSONSchema7Definition, B as ResolvedSchema, a2 as UnresolvedSchema, a9 as collectEvent, aa as collectResult, a7 as resolveSchema } from './language-model-DlNwTTFi.js';
+export { C as CombinedStandardSchema, m as InferSchemaInput, n as InferSchemaOutput, J as JSONSchema7, o as JSONSchema7Definition, z as ResolvedSchema, a1 as UnresolvedSchema, a4 as resolveSchema } from './language-model-rSwDu2og.js';
 import { XSAIError, EventSourceMessage, SendRequestOptions, HttpOptions } from '@xsai/shared';
 
 interface EventBuilder {

package/dist/internal.js

@@ -1,5 +1,5 @@
-export { a as collectEvent, b as collectResult, r as resolveSchema } from './schema-7PLOBVJ3.js';
 import { XSAIError, sendRequest, EventSourceParserStream } from '@xsai/shared';
+export { r as resolveSchema } from './schema-Bny4Y6lV.js';
 
 const emptyContent = (type, init) => {
   switch (type) {

package/dist/{language-model-DlNwTTFi.d.ts → language-model-rSwDu2og.d.ts}

@@ -180,22 +180,6 @@ interface ToolCallDeltaEvent {
     type: 'tool-call.delta';
 }
 
-interface StepResult extends Omit<StepEndDoneEvent, 'error' | 'type'> {
-    text: string;
-    toolCalls: ToolCallPart[];
-    toolResults: ToolResultPart[];
-}
-
-interface CollectResult extends StepResult {
-    steps: readonly StepResult[];
-    totalUsage?: Usage;
-}
-/** @internal */
-declare const collectEvent: (steps: StepResult[], event: TextEvent) => unknown;
-/** @internal */
-declare const collectResult: (steps: StepResult[]) => CollectResult;
-declare const collect: (stream: ReadableStream<TextEvent>) => Promise<CollectResult>;
-
 /** The Standard Typed interface. This is a base type extended by other specs. */
 interface StandardTypedV1<Input = unknown, Output = Input> {
     /** The Standard properties. */
@@ -541,5 +525,5 @@ type ToolChoice = 'auto' | 'none' | 'required' | {
     name: string;
 };
 
-export { collect as a6, resolveSchema as a7, tool as a8, collectEvent as a9, collectResult as aa };
-export type { ToolChoice as $, AssistantMessage as A, ResolvedSchema as B, CollectResult as C, DeveloperMessage as D, ExecutableTool as E, FilePart as F, StepEndDoneEvent as G, StepEndEvent as H, ImagePart as I, JSONSchema7 as J, StepEndFailEvent as K, LanguageModelOptions as L, Message as M, StepStartEvent as N, StepStatus as O, PartProviderMetadata as P, SystemMessage as Q, RawEvent as R, StepResult as S, ToolResultPart as T, SystemMessageContent as U, TextDeltaEvent as V, TextEventMap as W, TextEventType as X, TextPart as Y, Tool as Z, ToolCallDeltaEvent as _, LanguageModel as a, ToolOptions as a0, ToolResultPartContent as a1, UnresolvedSchema as a2, Usage as a3, UserMessage as a4, UserMessageContent as a5, ToolExecuteOptions as b, ToolCallPart as c, TextEvent as d, AssistantMessageContent as e, CombinedStandardSchema 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 };
+export { resolveSchema as a4, tool as a5 };
+export type { ToolOptions as $, AssistantMessage as A, StepEndEvent as B, CombinedStandardSchema as C, DeveloperMessage as D, ExecutableTool as E, FilePart as F, StepEndFailEvent as G, StepStartEvent as H, ImagePart as I, JSONSchema7 as J, StepStatus as K, LanguageModelOptions as L, Message as M, SystemMessage as N, SystemMessageContent as O, PartProviderMetadata as P, TextDeltaEvent as Q, RawEvent as R, StepEndDoneEvent as S, ToolCallPart as T, Usage as U, TextEventMap as V, TextEventType as W, TextPart as X, Tool as Y, ToolCallDeltaEvent as Z, ToolChoice as _, ToolResultPart as a, ToolResultPartContent as a0, UnresolvedSchema as a1, UserMessage as a2, UserMessageContent as a3, TextEvent as b, LanguageModel as c, ToolExecuteOptions as d, AssistantMessageContent as e, Content as f, ContentEndEvent as g, ContentMap as h, ContentStartEvent as i, ContentType as j, DeveloperMessageContent as k, FinishReason as l, InferSchemaInput as m, InferSchemaOutput as n, JSONSchema7Definition as o, LanguageModelProviderOptions as p, MessageMap as q, MessageProviderMetadata as r, MessageType as s, ProviderPart as t, ReasoningDeltaEvent as u, ReasoningPart as v, ReasoningPartContent as w, RefusalDeltaEvent as x, RefusalPart as y, ResolvedSchema as z };

package/dist/schema-Bny4Y6lV.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xsai/text",
   "type": "module",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.4",
   "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.2"
+    "@xsai/shared": "1.0.0-beta.4"
   },
   "devDependencies": {
     "@standard-schema/spec": "1.1.0",

package/dist/schema-7PLOBVJ3.js

@@ -1,69 +0,0 @@
-import { XSAIError } from '@xsai/shared';
-
-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");
-const toStepResult = (event) => {
-  const { type: _type, ...result } = event;
-  return {
-    ...result,
-    text: getText(event.message),
-    toolCalls: getToolCalls(event.message),
-    toolResults: []
-  };
-};
-
-const totalUsage = (steps) => {
-  const usages = steps.flatMap((step) => step.usage == null ? [] : [step.usage]);
-  if (usages.length === 0)
-    return void 0;
-  const sum = (key) => {
-    const values = usages.map((usage) => usage[key]).filter((value) => value != null);
-    return values.length === 0 ? void 0 : values.reduce((total, value) => total + value, 0);
-  };
-  return {
-    cacheCreationInputTokens: sum("cacheCreationInputTokens"),
-    cacheReadInputTokens: sum("cacheReadInputTokens"),
-    inputTokens: sum("inputTokens") ?? 0,
-    outputTokens: sum("outputTokens") ?? 0,
-    reasoningTokens: sum("reasoningTokens"),
-    totalTokens: sum("totalTokens") ?? 0
-  };
-};
-const collectEvent = (steps, event) => {
-  if (event.type === "step.end") {
-    if (event.status === "failed")
-      return event.error;
-    steps.push(toStepResult(event));
-  } else if (event.type === "content.end" && event.content.type === "tool-result") {
-    const step = steps.at(-1);
-    if (step == null)
-      throw new XSAIError("protocol-error", "tool result arrived before a step.end event");
-    step.toolResults.push(event.content);
-  }
-};
-const collectResult = (steps) => {
-  const finalStep = steps.at(-1);
-  if (finalStep == null)
-    throw new XSAIError("truncated-stream", "model stream ended without a step.end event");
-  return {
-    ...finalStep,
-    steps,
-    totalUsage: totalUsage(steps)
-  };
-};
-const collect = async (stream) => {
-  const steps = [];
-  let failedError;
-  for await (const event of stream)
-    failedError ??= collectEvent(steps, event);
-  if (failedError != null)
-    throw failedError;
-  return collectResult(steps);
-};
-
-const resolveSchema = (schema) => "~standard" in schema ? {
-  schema: schema["~standard"].jsonSchema.input({ target: "draft-07" }),
-  validate: schema["~standard"].validate
-} : { schema };
-
-export { collectEvent as a, collectResult as b, collect as c, resolveSchema as r, toStepResult as t };