@xsai/text-chat 0.0.0-stage → 1.0.0-beta.2

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-chat
 
-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-chat.md" -->
+
+```sh
+pnpm add @xsai/text @xsai/text-chat
+```
+
+```ts
+import { generateText } from '@xsai/text'
+import { chat } from '@xsai/text-chat'
+
+const model = chat({
+  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/text/adapters).

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+import { HttpOptions } from '@xsai/shared';
+import { LanguageModel } from '@xsai/text';
+
+interface ChatPartMetadata {
+    /** Which assistant-message field carried reasoning on this wire. */
+    reasoning_field?: 'reasoning' | 'reasoning_content';
+}
+
+interface ChatProviderOptions {
+    frequencyPenalty?: number;
+    parallelToolCalls?: boolean;
+    presencePenalty?: number;
+    seed?: number;
+    stopSequences?: readonly string[];
+    topK?: number;
+}
+
+declare module '@xsai/text' {
+    interface LanguageModelProviderOptions {
+        chat?: ChatProviderOptions;
+    }
+    interface PartProviderMetadata {
+        chat?: ChatPartMetadata;
+    }
+}
+declare const chat: (options: HttpOptions) => LanguageModel;
+
+export { chat };
+export type { ChatPartMetadata, ChatProviderOptions };

package/dist/index.js

@@ -0,0 +1,322 @@
+import { WireEventStream, resolveSchema, wireRequest } from '@xsai/text/internal';
+import { XSAIError } from '@xsai/shared';
+
+const mapFinish = (reason, refusal) => {
+  switch (reason) {
+    case "content_filter":
+      return { reason: "content-filter", status: "incomplete" };
+    case "length":
+    case "max_output_tokens":
+    case "max_tokens":
+      return { reason: "length", status: "incomplete" };
+    case null:
+    case void 0:
+      return { status: "completed" };
+    case "stop":
+      return { reason: refusal ? "refusal" : "stop", status: "completed" };
+    case "tool_calls":
+      return { reason: "tool-calls", status: "completed" };
+    default:
+      return { reason, status: "completed" };
+  }
+};
+const normalizeUsage = (usage) => {
+  const input = usage.prompt_tokens ?? 0;
+  const output = usage.completion_tokens ?? 0;
+  return {
+    cacheReadInputTokens: usage.prompt_tokens_details?.cached_tokens ?? usage.prompt_cache_hit_tokens,
+    inputTokens: input,
+    outputTokens: output,
+    reasoningTokens: usage.completion_tokens_details?.reasoning_tokens,
+    totalTokens: usage.total_tokens ?? input + output
+  };
+};
+class ChatEventStream extends WireEventStream {
+  // Preserve the wire field for assistant-message replay.
+  hasRefusal = false;
+  reasoningField;
+  constructor(includeRawEvents = false) {
+    super((chunk, builder) => {
+      if (chunk.error != null) {
+        builder.fail(new XSAIError("model-error", chunk.error.message, {
+          cause: chunk.error
+        }));
+        return;
+      }
+      if (chunk.usage != null)
+        builder.meta({ usage: normalizeUsage(chunk.usage) });
+      for (const choice of chunk.choices ?? []) {
+        if (choice.index !== 0)
+          continue;
+        if (choice.delta != null)
+          this.onDelta(builder, choice.delta);
+        if (choice.finish_reason != null) {
+          if (this.reasoningField != null)
+            builder.end("reasoning", { providerMetadata: { chat: { reasoning_field: this.reasoningField } } });
+          const finish = mapFinish(choice.finish_reason, this.hasRefusal);
+          builder.done(finish.status, finish.reason);
+        }
+      }
+    }, includeRawEvents);
+  }
+  onDelta(builder, delta) {
+    const reasoning = delta.reasoning_content ?? delta.reasoning;
+    if (reasoning != null && reasoning !== "") {
+      this.reasoningField ??= delta.reasoning_content != null ? "reasoning_content" : "reasoning";
+      builder.start("reasoning", "reasoning");
+      builder.delta("reasoning", reasoning);
+    }
+    const content = delta.content ?? "";
+    if (content !== "") {
+      builder.start("text", "text");
+      builder.delta("text", content);
+    }
+    const refusal = delta.refusal ?? "";
+    if (refusal !== "") {
+      this.hasRefusal = true;
+      builder.start("refusal", "refusal");
+      builder.delta("refusal", refusal);
+    }
+    for (const call of delta.tool_calls ?? []) {
+      const key = `tool:${call.index}`;
+      builder.start(key, "tool-call", { fallbackId: `call_${call.index}` });
+      builder.delta(key, call.function?.arguments ?? "", { callId: call.id, name: call.function?.name });
+    }
+  }
+}
+
+const SUPPORTED_FORMATS = /* @__PURE__ */ new Set([
+  "date",
+  "date-time",
+  "duration",
+  "email",
+  "hostname",
+  "ipv4",
+  "ipv6",
+  "time",
+  "uuid"
+]);
+const normalizeSchema = (schema) => {
+  const normalized = { ...schema };
+  const normalize = (schema2) => typeof schema2 === "boolean" ? schema2 : normalizeSchema(schema2);
+  if (normalized.$ref != null)
+    return { $ref: normalized.$ref };
+  if (normalized.type === "object" || normalized.properties != null) {
+    normalized.properties ??= {};
+    normalized.properties = Object.fromEntries(Object.entries(normalized.properties).map(([name, property]) => [name, normalize(property)]));
+    normalized.additionalProperties = false;
+    normalized.required = Object.keys(normalized.properties);
+  }
+  if (normalized.$defs != null)
+    normalized.$defs = Object.fromEntries(Object.entries(normalized.$defs).map(([name, definition]) => [name, normalize(definition)]));
+  if (normalized.definitions != null)
+    normalized.definitions = Object.fromEntries(Object.entries(normalized.definitions).map(([name, definition]) => [name, normalize(definition)]));
+  if (normalized.items != null) {
+    normalized.items = Array.isArray(normalized.items) ? normalized.items.map(normalize) : normalize(normalized.items);
+  }
+  if (normalized.oneOf != null) {
+    const oneOf = normalized.oneOf;
+    delete normalized.oneOf;
+    normalized.anyOf = normalized.anyOf == null ? oneOf : normalized.anyOf.concat(oneOf);
+  }
+  if (normalized.anyOf != null)
+    normalized.anyOf = normalized.anyOf.map(normalize);
+  delete normalized.allOf;
+  delete normalized.not;
+  delete normalized.if;
+  delete normalized.then;
+  delete normalized.else;
+  if (normalized.format != null && !SUPPORTED_FORMATS.has(normalized.format))
+    delete normalized.format;
+  return normalized;
+};
+
+const normalizeSchemaName = (title) => title == null || title === "" ? "output" : title.replace(/[^\w-]/g, "_").slice(0, 64);
+const normalizeFormat = (outputFormat) => {
+  if (outputFormat == null)
+    return void 0;
+  const { schema } = resolveSchema(outputFormat);
+  const normalized = normalizeSchema(schema);
+  return {
+    json_schema: {
+      description: normalized.description,
+      name: normalizeSchemaName(normalized.title),
+      schema: normalized,
+      strict: true
+    },
+    type: "json_schema"
+  };
+};
+
+const normalizeInputTextPart = (part) => ({
+  text: part.text,
+  type: "text"
+});
+const normalizeImagePart = (part) => {
+  const data = part.data.toString();
+  if (URL.canParse(data))
+    return { image_url: { detail: part.detail, url: data }, type: "image_url" };
+  throw new XSAIError("invalid-input", "Image part data must be a URL or a base64 data: URL");
+};
+const normalizeFilePart = (part) => {
+  const data = part.data.toString();
+  if (data.startsWith("data:"))
+    return { file: { file_data: data }, type: "file" };
+  throw new XSAIError("invalid-input", "File part data must be a base64 data: URL");
+};
+const normalizeToolResultPart = (part) => {
+  const output = typeof part.output === "string" ? part.output : part.output.map((content) => {
+    if (content.type !== "text")
+      throw new XSAIError("invalid-input", "Image tool results are not supported on the Chat Completions API");
+    return normalizeInputTextPart(content);
+  });
+  return {
+    // Some gateways reject empty tool content.
+    content: output === "" || Array.isArray(output) && output.length === 0 ? "(no output)" : output,
+    role: "tool",
+    tool_call_id: part.callId
+  };
+};
+const reasoningText = (part) => part.content.filter((content) => content.type === "text").map((content) => content.text).join("");
+const normalizeToolCallPart = (part) => ({
+  function: {
+    arguments: part.arguments,
+    name: part.name
+  },
+  id: part.callId,
+  type: "function"
+});
+const normalizeAssistantMessage = (message) => {
+  if (typeof message.content === "string")
+    return { content: message.content, role: "assistant" };
+  const content = [];
+  const reasoning = [];
+  let reasoningField = "reasoning_content";
+  const refusal = [];
+  const toolCalls = [];
+  for (const part of message.content) {
+    switch (part.type) {
+      case "provider":
+        break;
+      case "reasoning":
+        reasoning.push(reasoningText(part));
+        reasoningField = part.providerMetadata?.chat?.reasoning_field ?? reasoningField;
+        break;
+      case "refusal":
+        refusal.push(part.refusal);
+        break;
+      case "text":
+        content.push(normalizeInputTextPart(part));
+        break;
+      case "tool-call":
+        toolCalls.push(normalizeToolCallPart(part));
+        break;
+    }
+  }
+  if (content.length === 0 && reasoning.length === 0 && refusal.length === 0 && toolCalls.length === 0)
+    return void 0;
+  return {
+    // Some gateways reject `content: null` even when tool_calls is set.
+    content: content.length === 0 ? "" : content,
+    [reasoningField]: reasoning.length === 0 ? void 0 : reasoning.join(""),
+    refusal: refusal.length === 0 ? void 0 : refusal.join(""),
+    role: "assistant",
+    tool_calls: toolCalls.length === 0 ? void 0 : toolCalls
+  };
+};
+const normalizeUserPart = (part) => {
+  switch (part.type) {
+    case "file":
+      return normalizeFilePart(part);
+    case "image":
+      return normalizeImagePart(part);
+    case "text":
+      return normalizeInputTextPart(part);
+  }
+};
+const normalizeUserMessage = (message, messages) => {
+  if (typeof message.content === "string") {
+    messages.push({ content: message.content, role: "user" });
+    return;
+  }
+  let content = [];
+  const flush = () => {
+    if (content.length === 0)
+      return;
+    messages.push({ content, role: "user" });
+    content = [];
+  };
+  for (const part of message.content) {
+    if (part.type === "tool-result") {
+      flush();
+      messages.push(normalizeToolResultPart(part));
+      continue;
+    }
+    content.push(normalizeUserPart(part));
+  }
+  flush();
+};
+const joinText = (content) => typeof content === "string" ? content : content.map((part) => part.text).join("");
+const normalizeInput = (options) => {
+  const messages = [];
+  if (options.instructions != null)
+    messages.push({ content: options.instructions, role: "system" });
+  for (const message of typeof options.input === "string" ? [{ content: options.input, role: "user" }] : options.input) {
+    switch (message.role) {
+      case "assistant":
+        {
+          const assistant = normalizeAssistantMessage(message);
+          if (assistant != null)
+            messages.push(assistant);
+        }
+        break;
+      case "developer":
+      case "system":
+        messages.push({ content: joinText(message.content), role: message.role });
+        break;
+      case "user":
+        normalizeUserMessage(message, messages);
+        break;
+    }
+  }
+  return messages;
+};
+
+const normalizeTools = (tools) => tools?.map((tool) => ({
+  function: {
+    description: tool.description,
+    name: tool.name,
+    parameters: normalizeSchema(tool.inputSchema.schema),
+    strict: true
+  },
+  type: "function"
+}));
+const normalizeToolChoice = (toolChoice) => toolChoice == null ? void 0 : typeof toolChoice === "string" ? toolChoice : { function: { name: toolChoice.name }, type: "function" };
+
+const chat = (options) => async (modelOptions) => {
+  const providerOptions = modelOptions.providerOptions?.chat;
+  return wireRequest({
+    body: {
+      frequency_penalty: providerOptions?.frequencyPenalty,
+      max_tokens: modelOptions.maxOutputTokens,
+      messages: normalizeInput(modelOptions),
+      model: options.model,
+      parallel_tool_calls: providerOptions?.parallelToolCalls,
+      presence_penalty: providerOptions?.presencePenalty,
+      reasoning_effort: modelOptions.reasoningEffort,
+      response_format: normalizeFormat(modelOptions.outputFormat),
+      seed: providerOptions?.seed,
+      stop: providerOptions?.stopSequences,
+      stream: true,
+      stream_options: { include_usage: true },
+      temperature: modelOptions.temperature,
+      tool_choice: normalizeToolChoice(modelOptions.toolChoice),
+      tools: normalizeTools(modelOptions.tools),
+      top_k: providerOptions?.topK,
+      top_p: modelOptions.topP
+    },
+    path: "chat/completions"
+  }, options, modelOptions, new ChatEventStream(modelOptions.includeRawEvents));
+};
+
+export { chat };

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "@xsai/text-chat",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "type": "module",
+  "version": "1.0.0-beta.2",
+  "description": "extra-small AI SDK: OpenAI Chat Completions API model for @xsai/text.",
+  "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-chat"
+  },
+  "bugs": "https://github.com/moeru-ai/xsai/issues",
+  "keywords": [
+    "xsai",
+    "ai",
+    "openai",
+    "chat",
+    "chat-completions"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=26"
+  },
+  "peerDependencies": {
+    "@xsai/text": "1.0.0-beta.2"
+  },
+  "dependencies": {
+    "@xsai/shared": "1.0.0-beta.2"
+  },
+  "devDependencies": {
+    "@xsai/text": "1.0.0-beta.2",
+    "zod": "^4.3.6"
+  },
+  "scripts": {
+    "build": "pkgroll --clean-dist",
+    "test": "vitest run --exclude e2e/**",
+    "test:watch": "vitest"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts"
 }