@xsai/text 0.0.0-stage → 1.0.0-beta.1

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Moeru AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,25 @@
-# Temporary Holding Version
+# @xsai/text
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<!-- automd:file src="/docs/snippets/text-responses.md" -->
+
+```sh
+pnpm add @xsai/text @xsai/text-responses
+```
+
+```ts
+import { generateText } from '@xsai/text'
+import { responses } from '@xsai/text-responses'
+
+const model = responses({
+  apiKey: process.env.OPENAI_API_KEY,
+  baseURL: 'https://api.openai.com/v1/',
+  model: 'gpt-6-luna',
+})
+
+const { text } = await generateText(model, { input: 'Say hello.' })
+console.log(text)
+```
+
+<!-- /automd -->
+
+Read the [documentation](https://xsai.js.org/getting-started).

package/dist/index.d.ts

@@ -0,0 +1,80 @@
+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 { Promisable } from '@xsai/shared';
+export { HttpError, XSAIError, XSAIErrorCause, XSAIErrorCauseMap, XSAIErrorCode, XSAIErrorOptions } from '@xsai/shared';
+
+type PrepareStep = (options: PrepareStepOptions) => Promisable<PrepareStepResult | undefined>;
+interface PrepareStepOptions {
+    input: readonly Message[];
+    signal: AbortSignal;
+    stepNumber: number;
+    steps: readonly StepResult[];
+}
+interface PrepareStepResult extends Partial<Omit<LanguageModelOptions, 'signal'>> {
+    model?: LanguageModel;
+}
+
+type StopCondition = (context: StopContext) => boolean;
+interface StopContext {
+    input: readonly Message[];
+    step: StepResult;
+    steps: readonly StepResult[];
+}
+declare const and: (...conditions: StopCondition[]) => StopCondition;
+declare const or: (...conditions: StopCondition[]) => StopCondition;
+declare const not: (condition: StopCondition) => StopCondition;
+declare const maxSteps: (count: number) => StopCondition;
+declare const hasToolCall: (name?: string) => StopCondition;
+/** @deprecated use `maxSteps` instead. */
+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 {
+    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>;
+
+interface StreamTextHandle {
+    result: Promise<CollectResult>;
+    stream: ReadableStream<TextEvent>;
+}
+declare const streamText: (model: LanguageModel, options: LoopOptions) => StreamTextHandle;
+
+type TextEventListener<E extends Event> = ((this: EventTarget, event: E) => unknown) | {
+    handleEvent: (event: E) => unknown;
+};
+type TextEventTargetMap = {
+    [K in Exclude<TextEvent['type'], 'raw'>]: CustomEvent<Omit<Extract<TextEvent, {
+        type: K;
+    }>, 'type'>>;
+} & {
+    raw: CustomEvent<unknown>;
+};
+interface TextEventTarget {
+    addEventListener: <K extends keyof TextEventTargetMap>(type: K, listener: null | TextEventListener<TextEventTargetMap[K]>, options?: AddEventListenerOptions | boolean) => void;
+    dispatchEvent: (event: Event) => boolean;
+    removeEventListener: <K extends keyof TextEventTargetMap>(type: K, listener: null | TextEventListener<TextEventTargetMap[K]>, options?: boolean | EventListenerOptions) => void;
+}
+declare const TextEventTarget: {
+    new (): TextEventTarget;
+};
+declare const toCustomEvent: <E extends TextEvent>(event: E) => TextEventTargetMap[E["type"]];
+declare const withEventTarget: (events: EventTarget) => TransformStream<TextEvent, TextEvent>;
+
+declare module '@xsai/shared' {
+    interface XSAIErrorCauseMap {
+        'model-error': unknown;
+        'protocol-error': unknown;
+    }
+}
+
+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 };

package/dist/index.js

@@ -0,0 +1,246 @@
+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';
+
+const and = (...conditions) => (context) => conditions.every((condition) => condition(context));
+const or = (...conditions) => (context) => conditions.some((condition) => condition(context));
+const not = (condition) => (context) => !condition(context);
+const maxSteps = (count) => ({ steps }) => steps.length >= count;
+const hasToolCall = (name) => ({ step }) => step.toolCalls.some((toolCall) => name == null || toolCall.name === name);
+const stepCountAtLeast = maxSteps;
+
+const toolError = (call, detail) => ({
+  callId: call.callId,
+  isError: true,
+  output: `Tool "${call.name}" execution failed: ${detail}`,
+  type: "tool-result"
+});
+const assertSameCallId = (source, next) => {
+  if (source !== next)
+    throw new Error(`Tool call hooks must preserve callId "${source}".`);
+};
+const catchToolError = async (call, signal, callback) => {
+  try {
+    return await callback();
+  } catch (error) {
+    signal?.throwIfAborted();
+    return toolError(call, error instanceof Error ? error.message : String(error));
+  }
+};
+const executeTool = async (call, { postToolCall, preToolCall, signal, tools }) => {
+  const executeOptions = { 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;
+  }
+  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, { signal }),
+      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 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) {
+  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;
+    }
+    yield event;
+  }
+  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 stopWhen = stopWhenOption ?? maxSteps(10);
+  const input = [...Array.isArray(options.input) ? options.input : [{ content: options.input, role: "user" }]];
+  const steps = [];
+  const controller = new AbortController();
+  const signal = options.signal == null ? controller.signal : AbortSignal.any([options.signal, controller.signal]);
+  const generate = async function* () {
+    while (true) {
+      signal.throwIfAborted();
+      const { model: preparedModel = model, ...preparedOptions } = await prepareStep?.({ input, signal, stepNumber: steps.length, steps }) ?? {};
+      signal.throwIfAborted();
+      const modelOptions = {
+        ...options,
+        ...preparedOptions,
+        input: preparedOptions?.input ?? input,
+        signal
+      };
+      const stepEnd = yield* readStep(await preparedModel(modelOptions), signal);
+      if (stepEnd.status === "failed" || stepEnd.status === "cancelled")
+        return;
+      const step = toStepResult(stepEnd);
+      steps.push(step);
+      input.push(step.message);
+      const stop = stopWhen({ input, step, steps });
+      if (stop || step.toolCalls.length === 0 && step.reason !== "pause_turn")
+        return;
+      signal.throwIfAborted();
+      if (step.toolCalls.length === 0)
+        continue;
+      const results = await executeTools({
+        ...modelOptions,
+        postToolCall,
+        preToolCall,
+        reason: step.reason,
+        toolCalls: step.toolCalls
+      });
+      signal.throwIfAborted();
+      step.toolResults.push(...results);
+      input.push({ content: results, role: "user" });
+      for (const [index, content] of results.entries()) {
+        yield { contentType: "tool-result", index, type: "content.start" };
+        yield { content, index, type: "content.end" };
+      }
+    }
+  };
+  const source = generate();
+  return new ReadableStream({
+    cancel: async (reason) => {
+      controller.abort(reason);
+      await source.return(void 0);
+    },
+    pull: async (output) => {
+      const next = await source.next();
+      if (next.done)
+        output.close();
+      else
+        output.enqueue(next.value);
+    }
+  }, { 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 TextEventTarget = EventTarget;
+const toCustomEvent = (event) => {
+  const { type, ...detail } = event;
+  return new CustomEvent(type, {
+    detail: event.type === "raw" ? event.detail : detail
+  });
+};
+const withEventTarget = (events) => new TransformStream({
+  transform: (event, controller) => {
+    events.dispatchEvent(toCustomEvent(event));
+    controller.enqueue(event);
+  }
+});
+
+const tool = ((options) => {
+  const inputSchema = resolveSchema(options.inputSchema);
+  const outputSchema = options.outputSchema == null ? void 0 : resolveSchema(options.outputSchema);
+  const tool2 = {
+    description: options.description,
+    inputSchema,
+    name: options.name,
+    outputSchema
+  };
+  if (options.execute == null) {
+    return tool2;
+  } else {
+    return {
+      ...tool2,
+      execute: async (input, executeOptions) => {
+        const result = await options.execute(input, executeOptions);
+        if (outputSchema)
+          return JSON.stringify(result);
+        else
+          return result;
+      }
+    };
+  }
+});
+
+export { TextEventTarget, and, collect, generateText, hasToolCall, loop, maxSteps, not, or, stepCountAtLeast, streamText, toCustomEvent, tool, withEventTarget };

package/dist/internal.d.ts

@@ -0,0 +1,58 @@
+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';
+import { XSAIError, EventSourceMessage, SendRequestOptions, HttpOptions } from '@xsai/shared';
+
+interface EventBuilder {
+    /** Appends text or tool-call identity to a part. */
+    delta: (key: PartKey, text: string, extra?: PartDeltaExtra) => void;
+    /** Records a non-failed terminal status and closes open parts. */
+    done: (status: Exclude<StepStatus, 'failed'>, reason?: FinishReason, message?: AssistantMessage) => void;
+    end: (key: PartKey, extra?: PartEndExtra) => void;
+    /** Records a provider-declared failure and closes open parts. */
+    fail: (error: XSAIError, message?: AssistantMessage) => void;
+    /** Emits `step.end` or fails for an incomplete wire stream. */
+    flush: () => void;
+    meta: (meta: FinishMeta) => void;
+    start: (key: PartKey, type: AssistantMessageContent['type'], init?: PartStartInit) => void;
+}
+interface FinishMeta {
+    messageId?: string;
+    usage?: Usage;
+}
+interface PartDeltaExtra {
+    callId?: string;
+    name?: string;
+}
+interface PartEndExtra {
+    /** Authoritative part content, e.g. a Responses `output_item.done` item. */
+    content?: AssistantMessageContent;
+    /** Attached to reasoning or text parts. */
+    providerMetadata?: PartProviderMetadata;
+}
+/** Adapter-assigned identity for a part. */
+type PartKey = number | string;
+interface PartStartInit {
+    callId?: string;
+    /** Used when the wire never sends a call id, e.g. `call_${index}`. */
+    fallbackId?: string;
+    /** Wire-level part identity, distinct from the tool call id when both exist. */
+    id?: string;
+    name?: string;
+    source?: string;
+}
+/** @internal */
+declare const eventBuilder: (emit: (event: TextEvent) => void, fail: (error: XSAIError) => void) => EventBuilder;
+/** Parses wire events and enforces stream termination. @internal */
+declare class WireEventStream<W> extends TransformStream<string, TextEvent> {
+    constructor(map: (wire: W, builder: EventBuilder) => void, includeRawEvents?: boolean);
+}
+
+declare class EventSourceDataStream extends TransformStream<EventSourceMessage, string> {
+    constructor();
+}
+
+/** @internal */
+declare const wireRequest: (options: SendRequestOptions, httpOptions: HttpOptions, modelOptions: LanguageModelOptions, eventStream: TransformStream<string, TextEvent>) => Promise<ReadableStream<TextEvent>>;
+
+export { EventSourceDataStream, WireEventStream, eventBuilder, wireRequest };
+export type { EventBuilder, FinishMeta, PartDeltaExtra, PartEndExtra, PartKey, PartStartInit };

package/dist/internal.js

@@ -0,0 +1,268 @@
+export { a as collectEvent, b as collectResult, r as resolveSchema } from './schema-7PLOBVJ3.js';
+import { XSAIError, sendRequest, EventSourceParserStream } from '@xsai/shared';
+
+const emptyContent = (type, init) => {
+  switch (type) {
+    case "provider":
+      return { source: init?.source ?? "", type, value: null };
+    case "reasoning":
+      return { content: [], type };
+    case "refusal":
+      return { refusal: "", type };
+    case "text":
+      return { text: "", type };
+    case "tool-call":
+      return { arguments: "", callId: "", id: "", name: "", type };
+  }
+};
+const acceptIdentity = (current, incoming) => incoming != null && incoming !== "" ? incoming : current;
+const resolveCallId = (state) => {
+  if (state.resolvedCallId != null)
+    return state.resolvedCallId;
+  state.resolvedCallId = acceptIdentity(state.fallbackId, state.callId) ?? `call_${state.index}`;
+  return state.resolvedCallId;
+};
+const eventBuilder = (emit, fail) => {
+  const parts = [];
+  const states = /* @__PURE__ */ new Map();
+  let terminalEmitted = false;
+  let messageId;
+  let terminal;
+  let usage;
+  const updateReasoning = (state, text) => {
+    if (text === "")
+      return;
+    const part = parts[state.index];
+    if (part.type !== "reasoning")
+      return;
+    const content = part.content;
+    const last = content.at(-1);
+    parts[state.index] = {
+      ...part,
+      content: last?.type === "text" ? content.with(-1, { text: last.text + text, type: "text" }) : [...content, { text, type: "text" }]
+    };
+    emit({ delta: text, index: state.index, type: "reasoning.delta" });
+  };
+  const updateRefusal = (state, text) => {
+    if (text === "")
+      return;
+    const part = parts[state.index];
+    if (part.type !== "refusal")
+      return;
+    parts[state.index] = { ...part, refusal: part.refusal + text };
+    emit({ delta: text, index: state.index, type: "refusal.delta" });
+  };
+  const updateText = (state, text) => {
+    if (text === "")
+      return;
+    const part = parts[state.index];
+    if (part.type !== "text")
+      return;
+    parts[state.index] = { ...part, text: part.text + text };
+    emit({ delta: text, index: state.index, type: "text.delta" });
+  };
+  const updateToolCall = (state, text, extra) => {
+    state.callId = acceptIdentity(state.callId, extra?.callId);
+    state.name = acceptIdentity(state.name, extra?.name);
+    if (text === "")
+      return;
+    const id = resolveCallId(state);
+    const part = parts[state.index];
+    if (part.type !== "tool-call")
+      return;
+    parts[state.index] = {
+      ...part,
+      arguments: part.arguments + text,
+      callId: id,
+      id,
+      name: state.name ?? part.name
+    };
+    const event = {
+      callId: id,
+      delta: text,
+      index: state.index,
+      name: state.name,
+      type: "tool-call.delta"
+    };
+    emit(event);
+  };
+  const delta = (key, text, extra) => {
+    const state = states.get(key);
+    if (state === void 0 || state.closed || terminal !== void 0)
+      return;
+    switch (parts[state.index].type) {
+      case "provider":
+        break;
+      case "reasoning":
+        updateReasoning(state, text);
+        break;
+      case "refusal":
+        updateRefusal(state, text);
+        break;
+      case "text":
+        updateText(state, text);
+        break;
+      case "tool-call":
+        updateToolCall(state, text, extra);
+        break;
+    }
+  };
+  const end = (key, extra) => {
+    const state = states.get(key);
+    if (state === void 0 || state.closed)
+      return;
+    state.closed = true;
+    const accumulated = parts[state.index];
+    const callId = resolveCallId(state);
+    const built = accumulated.type === "tool-call" ? {
+      ...accumulated,
+      callId,
+      id: state.id ?? callId,
+      name: state.name ?? ""
+    } : accumulated.type === "reasoning" ? {
+      ...accumulated,
+      content: accumulated.content.length === 0 ? [{ text: "", type: "text" }] : accumulated.content,
+      id: state.id
+    } : accumulated;
+    const authoritative = extra?.content ?? built;
+    const content = extra?.providerMetadata != null && (authoritative.type === "reasoning" || authoritative.type === "text") ? { ...authoritative, providerMetadata: extra.providerMetadata } : authoritative;
+    parts[state.index] = content;
+    emit({ content, index: state.index, type: "content.end" });
+  };
+  const emitTerminal = () => {
+    if (terminalEmitted || terminal === void 0)
+      return;
+    terminalEmitted = true;
+    const message = terminal.message ?? {
+      content: parts,
+      role: "assistant"
+    };
+    const common = {
+      message: message.id == null && messageId != null ? { ...message, id: messageId } : message,
+      type: "step.end",
+      usage
+    };
+    if (terminal.status === "failed") {
+      emit({ ...common, error: terminal.error, status: terminal.status });
+      return;
+    }
+    emit({
+      ...common,
+      reason: terminal.reason,
+      status: terminal.status
+    });
+  };
+  return {
+    delta,
+    done: (status, reason, message) => {
+      if (terminal !== void 0)
+        return;
+      const messageContent = message?.content ?? parts;
+      const hasToolCall = typeof messageContent !== "string" && messageContent.some((part) => part.type === "tool-call");
+      const reconciledReason = status === "completed" && (reason == null || reason === "stop") && hasToolCall ? "tool-calls" : reason;
+      terminal = { message, reason: reconciledReason, status };
+      for (const key of states.keys())
+        end(key);
+    },
+    end,
+    fail: (error, message) => {
+      if (terminal !== void 0)
+        return;
+      terminal = { error, message, status: "failed" };
+      for (const key of states.keys())
+        end(key);
+      emitTerminal();
+    },
+    flush: () => {
+      if (terminalEmitted)
+        return;
+      if (terminal === void 0) {
+        terminalEmitted = true;
+        fail(new XSAIError("truncated-stream", "wire stream ended without a terminal signal"));
+        return;
+      }
+      emitTerminal();
+    },
+    meta: (meta) => {
+      if (meta.messageId != null)
+        messageId = meta.messageId;
+      if (meta.usage != null)
+        usage = meta.usage;
+    },
+    start: (key, type, init) => {
+      if (states.has(key) || terminal !== void 0)
+        return;
+      const index = states.size;
+      const state = {
+        callId: init?.callId,
+        closed: false,
+        fallbackId: init?.fallbackId,
+        id: init?.id,
+        index,
+        name: init?.name
+      };
+      states.set(key, state);
+      parts.push(emptyContent(type, init));
+      emit({ contentType: type, index, type: "content.start" });
+    }
+  };
+};
+class WireEventStream extends TransformStream {
+  constructor(map, includeRawEvents = false) {
+    let builder;
+    super({
+      flush: () => {
+        builder.flush();
+      },
+      start: (controller) => {
+        builder = eventBuilder(
+          (event) => {
+            controller.enqueue(event);
+            if (event.type === "step.end" && event.status === "failed")
+              controller.terminate();
+          },
+          (error) => controller.error(error)
+        );
+        controller.enqueue({ type: "step.start" });
+      },
+      transform: (data, controller) => {
+        let wire;
+        try {
+          wire = JSON.parse(data);
+        } catch (cause) {
+          controller.error(new XSAIError("invalid-response", "malformed event data", { cause }));
+          return;
+        }
+        try {
+          if (includeRawEvents)
+            controller.enqueue({ detail: wire, type: "raw" });
+          map(wire, builder);
+        } catch (cause) {
+          controller.error(new XSAIError("protocol-error", "failed to normalize wire event", { cause }));
+        }
+      }
+    });
+  }
+}
+
+const DONE = "[DONE]";
+class EventSourceDataStream extends TransformStream {
+  constructor() {
+    super({
+      transform: ({ data }, controller) => {
+        if (data === DONE) {
+          controller.terminate();
+          return;
+        }
+        controller.enqueue(data);
+      }
+    });
+  }
+}
+
+const wireRequest = async (options, httpOptions, modelOptions, eventStream) => sendRequest({
+  ...options,
+  signal: modelOptions.signal
+}, httpOptions).then((res) => res.body.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream()).pipeThrough(new EventSourceDataStream()).pipeThrough(eventStream));
+
+export { EventSourceDataStream, WireEventStream, wireRequest };

package/dist/language-model-DlNwTTFi.d.ts

@@ -0,0 +1,545 @@
+import { XSAIError, Promisable } from '@xsai/shared';
+
+interface MessageProviderMetadata {
+}
+interface PartProviderMetadata {
+}
+
+type Content = ContentMap[ContentType];
+interface ContentMap {
+    'file': FilePart;
+    'image': ImagePart;
+    'provider': ProviderPart;
+    'reasoning': ReasoningPart;
+    'refusal': RefusalPart;
+    'text': TextPart;
+    'tool-call': ToolCallPart;
+    'tool-result': ToolResultPart;
+}
+type ContentType = keyof ContentMap;
+interface FilePart {
+    data: string | URL;
+    type: 'file';
+}
+interface ImagePart {
+    data: string | URL;
+    detail?: 'auto' | 'high' | 'low';
+    type: 'image';
+}
+interface ProviderPart {
+    source: string;
+    type: 'provider';
+    value: unknown;
+}
+interface ReasoningPart {
+    content: ReasoningPartContent[];
+    id?: string;
+    providerMetadata?: PartProviderMetadata;
+    type: 'reasoning';
+}
+interface ReasoningPartContent {
+    text: string;
+    type: 'encrypted' | 'redacted' | 'summary' | 'text';
+}
+interface RefusalPart {
+    refusal: string;
+    type: 'refusal';
+}
+interface TextPart {
+    providerMetadata?: PartProviderMetadata;
+    text: string;
+    type: 'text';
+}
+interface ToolCallPart {
+    arguments: string;
+    callId: string;
+    id: string;
+    name: string;
+    type: 'tool-call';
+}
+interface ToolResultPart {
+    callId: string;
+    isError?: boolean;
+    output: string | ToolResultPartContent[];
+    type: 'tool-result';
+}
+type ToolResultPartContent = ImagePart | TextPart;
+
+type FinishReason = 'content-filter' | 'length' | 'refusal' | 'stop' | 'tool-calls' | (string & {});
+
+interface AssistantMessage {
+    content: readonly AssistantMessageContent[] | string;
+    id?: string;
+    providerMetadata?: MessageProviderMetadata;
+    role: 'assistant';
+}
+type AssistantMessageContent = ProviderPart | ReasoningPart | RefusalPart | TextPart | ToolCallPart;
+interface DeveloperMessage {
+    content: readonly DeveloperMessageContent[] | string;
+    role: 'developer';
+}
+type DeveloperMessageContent = TextPart;
+type Message = MessageMap[MessageType];
+interface MessageMap {
+    assistant: AssistantMessage;
+    developer: DeveloperMessage;
+    system: SystemMessage;
+    user: UserMessage;
+}
+type MessageType = keyof MessageMap;
+interface SystemMessage {
+    content: readonly SystemMessageContent[] | string;
+    role: 'system';
+}
+type SystemMessageContent = TextPart;
+interface UserMessage {
+    content: readonly UserMessageContent[] | string;
+    role: 'user';
+}
+type UserMessageContent = FilePart | ImagePart | TextPart | ToolResultPart;
+
+interface Usage {
+    cacheCreationInputTokens?: number;
+    cacheReadInputTokens?: number;
+    inputTokens: number;
+    outputTokens: number;
+    reasoningTokens?: number;
+    totalTokens: number;
+}
+
+interface ContentEndEvent {
+    content: AssistantMessageContent | ToolResultPart;
+    index: number;
+    type: 'content.end';
+}
+interface ContentStartEvent {
+    contentType: AssistantMessageContent['type'] | ToolResultPart['type'];
+    index: number;
+    type: 'content.start';
+}
+interface RawEvent {
+    detail: unknown;
+    type: 'raw';
+}
+interface ReasoningDeltaEvent {
+    delta: string;
+    index: number;
+    type: 'reasoning.delta';
+}
+interface RefusalDeltaEvent {
+    delta: string;
+    index: number;
+    type: 'refusal.delta';
+}
+/** @internal */
+interface StepEndDoneEvent {
+    error?: never;
+    message: AssistantMessage;
+    reason?: FinishReason;
+    status: Exclude<StepStatus, 'failed'>;
+    type: 'step.end';
+    usage?: Usage;
+}
+type StepEndEvent = StepEndDoneEvent | StepEndFailEvent;
+/** @internal */
+interface StepEndFailEvent {
+    error: XSAIError;
+    message: AssistantMessage;
+    reason?: never;
+    status: 'failed';
+    type: 'step.end';
+    usage?: Usage;
+}
+interface StepStartEvent {
+    type: 'step.start';
+}
+type StepStatus = 'cancelled' | 'completed' | 'failed' | 'incomplete';
+interface TextDeltaEvent {
+    delta: string;
+    index: number;
+    type: 'text.delta';
+}
+type TextEvent = TextEventMap[TextEventType];
+interface TextEventMap {
+    'content.end': ContentEndEvent;
+    'content.start': ContentStartEvent;
+    'raw': RawEvent;
+    'reasoning.delta': ReasoningDeltaEvent;
+    'refusal.delta': RefusalDeltaEvent;
+    'step.end': StepEndEvent;
+    'step.start': StepStartEvent;
+    'text.delta': TextDeltaEvent;
+    'tool-call.delta': ToolCallDeltaEvent;
+}
+type TextEventType = keyof TextEventMap;
+interface ToolCallDeltaEvent {
+    callId: string;
+    delta: string;
+    index: number;
+    name?: string;
+    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. */
+    readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+    /** The Standard Typed properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The Standard Typed types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Typed. */
+    type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+    /** Infers the output type of a Standard Typed. */
+    type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+    }
+    /** The result interface of the validate function. */
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** A falsy value for `issues` indicates success. */
+        readonly issues?: undefined;
+    }
+    interface Options {
+        /** Explicit support for additional vendor-specific parameters, if needed. */
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard types interface. */
+    interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
+    }
+    /** Infers the input type of a Standard. */
+    type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+    /** Infers the output type of a Standard. */
+    type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+/** The Standard JSON Schema interface. */
+interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard JSON Schema properties. */
+    readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardJSONSchemaV1 {
+    /** The Standard JSON Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+        /** Methods for generating the input/output JSON Schema. */
+        readonly jsonSchema: StandardJSONSchemaV1.Converter;
+    }
+    /** The Standard JSON Schema converter interface. */
+    interface Converter {
+        /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+        readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+        /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+        readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    }
+    /**
+     * The target version of the generated JSON Schema.
+     *
+     * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use. All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
+     *
+     * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+     */
+    type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
+    /** The options for the input/output methods. */
+    interface Options {
+        /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+        readonly target: Target;
+        /** Explicit support for additional vendor-specific parameters, if needed. */
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** The Standard types interface. */
+    interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
+    }
+    /** Infers the input type of a Standard. */
+    type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+    /** Infers the output type of a Standard. */
+    type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+
+// ==================================================================================================
+// JSON Schema Draft 07
+// ==================================================================================================
+// https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
+// --------------------------------------------------------------------------------------------------
+
+/**
+ * Primitive type
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
+ */
+type JSONSchema7TypeName =
+    | "string" //
+    | "number"
+    | "integer"
+    | "boolean"
+    | "object"
+    | "array"
+    | "null";
+
+/**
+ * Primitive type
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
+ */
+type JSONSchema7Type =
+    | string //
+    | number
+    | boolean
+    | JSONSchema7Object
+    | JSONSchema7Array
+    | null;
+
+// Workaround for infinite type recursion
+interface JSONSchema7Object {
+    [key: string]: JSONSchema7Type;
+}
+
+// Workaround for infinite type recursion
+// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
+interface JSONSchema7Array extends Array<JSONSchema7Type> {}
+
+/**
+ * Meta schema
+ *
+ * Recommended values:
+ * - 'http://json-schema.org/schema#'
+ * - 'http://json-schema.org/hyper-schema#'
+ * - 'http://json-schema.org/draft-07/schema#'
+ * - 'http://json-schema.org/draft-07/hyper-schema#'
+ *
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
+ */
+type JSONSchema7Version = string;
+
+/**
+ * JSON Schema v7
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
+ */
+type JSONSchema7Definition = JSONSchema7 | boolean;
+interface JSONSchema7 {
+    $id?: string | undefined;
+    $ref?: string | undefined;
+    $schema?: JSONSchema7Version | undefined;
+    $comment?: string | undefined;
+
+    /**
+     * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-00#section-8.2.4
+     * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#appendix-A
+     */
+    $defs?: {
+        [key: string]: JSONSchema7Definition;
+    } | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1
+     */
+    type?: JSONSchema7TypeName | JSONSchema7TypeName[] | undefined;
+    enum?: JSONSchema7Type[] | undefined;
+    const?: JSONSchema7Type | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.2
+     */
+    multipleOf?: number | undefined;
+    maximum?: number | undefined;
+    exclusiveMaximum?: number | undefined;
+    minimum?: number | undefined;
+    exclusiveMinimum?: number | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.3
+     */
+    maxLength?: number | undefined;
+    minLength?: number | undefined;
+    pattern?: string | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.4
+     */
+    items?: JSONSchema7Definition | JSONSchema7Definition[] | undefined;
+    additionalItems?: JSONSchema7Definition | undefined;
+    maxItems?: number | undefined;
+    minItems?: number | undefined;
+    uniqueItems?: boolean | undefined;
+    contains?: JSONSchema7Definition | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.5
+     */
+    maxProperties?: number | undefined;
+    minProperties?: number | undefined;
+    required?: string[] | undefined;
+    properties?: {
+        [key: string]: JSONSchema7Definition;
+    } | undefined;
+    patternProperties?: {
+        [key: string]: JSONSchema7Definition;
+    } | undefined;
+    additionalProperties?: JSONSchema7Definition | undefined;
+    dependencies?: {
+        [key: string]: JSONSchema7Definition | string[];
+    } | undefined;
+    propertyNames?: JSONSchema7Definition | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.6
+     */
+    if?: JSONSchema7Definition | undefined;
+    then?: JSONSchema7Definition | undefined;
+    else?: JSONSchema7Definition | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.7
+     */
+    allOf?: JSONSchema7Definition[] | undefined;
+    anyOf?: JSONSchema7Definition[] | undefined;
+    oneOf?: JSONSchema7Definition[] | undefined;
+    not?: JSONSchema7Definition | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-7
+     */
+    format?: string | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-8
+     */
+    contentMediaType?: string | undefined;
+    contentEncoding?: string | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-9
+     */
+    definitions?: {
+        [key: string]: JSONSchema7Definition;
+    } | undefined;
+
+    /**
+     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-10
+     */
+    title?: string | undefined;
+    description?: string | undefined;
+    default?: JSONSchema7Type | undefined;
+    readOnly?: boolean | undefined;
+    writeOnly?: boolean | undefined;
+    examples?: JSONSchema7Type | undefined;
+}
+
+interface CombinedStandardSchema<Input = unknown, Output = Input> {
+    readonly '~standard': Partial<StandardSchemaV1.Props<Input, Output>> & StandardJSONSchemaV1.Props<Input, Output>;
+}
+type InferSchemaInput<Schema extends UnresolvedSchema> = Schema extends StandardTypedV1 ? StandardSchemaV1.InferInput<Schema> : unknown;
+type InferSchemaOutput<Schema extends UnresolvedSchema> = Schema extends StandardTypedV1 ? StandardSchemaV1.InferOutput<Schema> : unknown;
+interface ResolvedSchema<Input = unknown, Output = Input> {
+    schema: JSONSchema7;
+    validate?: StandardSchemaV1.Props<Input, Output>['validate'];
+}
+type UnresolvedSchema<Input = unknown, Output = Input> = CombinedStandardSchema<Input, Output> | JSONSchema7;
+declare const resolveSchema: <Input = unknown, Output = Input>(schema: UnresolvedSchema<Input, Output>) => ResolvedSchema<Input, Output>;
+
+interface ExecutableTool extends Tool {
+    execute: (input: unknown, options?: ToolExecuteOptions) => Promisable<string | ToolResultPartContent[]>;
+}
+interface Tool {
+    description?: string;
+    inputSchema: ResolvedSchema;
+    name: string;
+    outputSchema?: ResolvedSchema;
+}
+interface ToolExecuteOptions {
+    signal?: AbortSignal;
+}
+interface ToolOptions<TInput extends UnresolvedSchema, TOutput extends undefined | UnresolvedSchema = undefined> {
+    description?: string;
+    execute?: (input: InferSchemaOutput<TInput>, options?: ToolExecuteOptions) => TOutput extends UnresolvedSchema ? Promisable<InferSchemaInput<TOutput>> : Promisable<string | ToolResultPartContent[]>;
+    inputSchema: TInput;
+    name: string;
+    outputSchema?: TOutput;
+}
+interface ToolFactory {
+    <TInput extends UnresolvedSchema, TOutput extends undefined | UnresolvedSchema = undefined>(options: Required<Pick<ToolOptions<TInput, TOutput>, 'execute'>> & ToolOptions<TInput, TOutput>): ExecutableTool;
+    <TInput extends UnresolvedSchema, TOutput extends undefined | UnresolvedSchema = undefined>(options: ToolOptions<TInput, TOutput>): Tool;
+}
+declare const tool: ToolFactory;
+
+type LanguageModel = (options: LanguageModelOptions) => Promisable<ReadableStream<TextEvent>>;
+interface LanguageModelOptions {
+    includeRawEvents?: boolean;
+    input: Message[] | string;
+    instructions?: string;
+    maxOutputTokens?: number;
+    /** Strict structured-output schema. */
+    outputFormat?: UnresolvedSchema;
+    providerOptions?: LanguageModelProviderOptions;
+    /** Qualitative reasoning effort; provider-specific knobs stay in `providerOptions`. */
+    reasoningEffort?: 'high' | 'low' | 'max' | 'medium' | 'none' | 'xhigh' | (string & {});
+    signal?: AbortSignal;
+    temperature?: number;
+    toolChoice?: ToolChoice;
+    tools?: Tool[];
+    topP?: number;
+}
+interface LanguageModelProviderOptions {
+}
+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 };

package/dist/schema-7PLOBVJ3.js

@@ -0,0 +1,69 @@
+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 };

package/package.json

@@ -1,6 +1,54 @@
 {
   "name": "@xsai/text",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "type": "module",
+  "version": "1.0.0-beta.1",
+  "description": "extra-small AI SDK: provider-agnostic text generation, streaming and tool calling.",
+  "author": "Moeru AI",
+  "license": "MIT",
+  "homepage": "https://xsai.js.org",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moeru-ai/xsai.git",
+    "directory": "packages/text"
+  },
+  "bugs": "https://github.com/moeru-ai/xsai/issues",
+  "keywords": [
+    "xsai",
+    "ai",
+    "openai",
+    "text",
+    "generate-text",
+    "stream-text",
+    "tool-calling",
+    "agent"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json",
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "default": "./dist/internal.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@xsai/shared": "1.0.0-beta.1"
+  },
+  "devDependencies": {
+    "@standard-schema/spec": "1.1.0",
+    "@types/json-schema": "^7.0.15"
+  },
+  "scripts": {
+    "build": "pkgroll --clean-dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts"
 }