@xsai/text-messages 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,28 @@
-# Temporary Holding Version
+# @xsai/text-messages
 
-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-messages.md" -->
+
+```sh
+pnpm add @xsai/text @xsai/text-messages
+```
+
+```ts
+import { generateText } from '@xsai/text'
+import { messages } from '@xsai/text-messages'
+
+const model = messages({
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  baseURL: 'https://api.anthropic.com/v1/',
+  model: 'claude-haiku-5.5',
+})
+
+const { text } = await generateText(model, {
+  input: 'Say hello.',
+  maxOutputTokens: 128,
+})
+console.log(text)
+```
+
+<!-- /automd -->
+
+Read the [documentation](https://xsai.js.org/text/adapters).

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+import { HttpOptions } from '@xsai/shared';
+import { LanguageModel } from '@xsai/text';
+
+interface MessagesCitation {
+    [key: string]: unknown;
+    type: string;
+}
+interface MessagesPartMetadata {
+    citations?: MessagesCitation[];
+    signature?: string;
+}
+
+interface MessagesCacheControl {
+    ttl?: '1h' | '5m';
+    type: 'ephemeral';
+}
+interface MessagesMcpServer {
+    authorization_token?: string;
+    name: string;
+    type: 'url';
+    url: string;
+}
+interface MessagesProviderOptions {
+    betas?: readonly string[];
+    /** Automatic caching at the last cacheable part in the request. */
+    cacheControl?: MessagesCacheControl;
+    mcpServers?: readonly MessagesMcpServer[];
+    stopSequences?: readonly string[];
+    /** Thinking mode and display. Effort stays in `reasoningEffort`. */
+    thinking?: MessagesThinkingConfig;
+    tools?: readonly MessagesProviderTool[];
+}
+interface MessagesProviderTool {
+    [key: string]: unknown;
+    type: string;
+}
+type MessagesThinkingConfig = {
+    budget_tokens: number;
+    display?: 'omitted' | 'summarized';
+    type: 'enabled';
+} | {
+    display?: 'omitted' | 'summarized';
+    type: 'adaptive';
+} | {
+    type: 'between_tools' | 'disabled';
+};
+
+declare module '@xsai/text' {
+    interface LanguageModelProviderOptions {
+        messages?: MessagesProviderOptions;
+    }
+    interface PartProviderMetadata {
+        messages?: MessagesPartMetadata;
+    }
+}
+declare const messages: (options: HttpOptions) => LanguageModel;
+
+export { messages };
+export type { MessagesCacheControl, MessagesCitation, MessagesMcpServer, MessagesPartMetadata, MessagesProviderOptions, MessagesProviderTool, MessagesThinkingConfig };

package/dist/index.js

@@ -0,0 +1,412 @@
+import { XSAIError, requestURL } from '@xsai/shared';
+import { WireEventStream, resolveSchema, wireRequest } from '@xsai/text/internal';
+
+const mapStop = (FinishReason) => {
+  switch (FinishReason) {
+    case "content_filter":
+      return { reason: "content-filter", status: "incomplete" };
+    case "end_turn":
+    case "stop_sequence":
+      return { reason: "stop", status: "completed" };
+    case "max_output_tokens":
+    case "max_tokens":
+      return { reason: "length", status: "incomplete" };
+    case null:
+    case void 0:
+      return { status: "completed" };
+    case "refusal":
+      return { reason: "refusal", status: "completed" };
+    case "tool_use":
+      return { reason: "tool-calls", status: "completed" };
+    default:
+      return { reason: FinishReason, status: "completed" };
+  }
+};
+const mergeUsage = (start, delta) => {
+  const inputTokens = delta?.input_tokens ?? start?.input_tokens;
+  const outputTokens = delta?.output_tokens ?? start?.output_tokens;
+  if (inputTokens == null && outputTokens == null)
+    return void 0;
+  const input = inputTokens ?? 0;
+  const output = outputTokens ?? 0;
+  const cacheRead = start?.cache_read_input_tokens ?? delta?.cache_read_input_tokens;
+  const cacheCreation = start?.cache_creation_input_tokens ?? delta?.cache_creation_input_tokens;
+  return {
+    cacheCreationInputTokens: cacheCreation,
+    cacheReadInputTokens: cacheRead,
+    inputTokens: input,
+    outputTokens: output,
+    reasoningTokens: delta?.output_tokens_details?.thinking_tokens,
+    // Anthropic reports no total and counts cache buckets separately from input_tokens.
+    totalTokens: input + output + (cacheRead ?? 0) + (cacheCreation ?? 0)
+  };
+};
+class MessagesEventStream extends WireEventStream {
+  citations = /* @__PURE__ */ new Map();
+  deltaUsage;
+  FinishReason;
+  providerBlocks = /* @__PURE__ */ new Map();
+  signatures = /* @__PURE__ */ new Map();
+  source;
+  startUsage;
+  constructor(source, includeRawEvents = false) {
+    super((event, builder) => {
+      switch (event.type) {
+        case "content_block_delta":
+          this.onDelta(builder, event);
+          break;
+        case "content_block_start":
+          this.onStart(builder, event);
+          break;
+        case "content_block_stop":
+          this.onStop(builder, event);
+          break;
+        case "error":
+          builder.fail(new XSAIError("model-error", event.error.message, {
+            cause: event.error
+          }));
+          break;
+        case "message_delta":
+          this.FinishReason = event.delta.stop_reason;
+          this.deltaUsage = event.usage;
+          break;
+        case "message_start":
+          builder.meta({ messageId: event.message.id });
+          this.startUsage = event.message.usage;
+          break;
+        case "message_stop": {
+          const usage = mergeUsage(this.startUsage, this.deltaUsage);
+          if (usage != null)
+            builder.meta({ usage });
+          const finish = mapStop(this.FinishReason);
+          builder.done(finish.status, finish.reason);
+          break;
+        }
+      }
+    }, includeRawEvents);
+    this.source = source;
+  }
+  onDelta(builder, event) {
+    switch (event.delta.type) {
+      case "citations_delta": {
+        const citations = this.citations.get(event.index);
+        if (citations == null)
+          this.citations.set(event.index, [event.delta.citation]);
+        else
+          citations.push(event.delta.citation);
+        break;
+      }
+      case "input_json_delta": {
+        const provider = this.providerBlocks.get(event.index);
+        if (provider == null)
+          builder.delta(event.index, event.delta.partial_json);
+        else
+          provider.input += event.delta.partial_json;
+        break;
+      }
+      case "signature_delta":
+        this.signatures.set(event.index, (this.signatures.get(event.index) ?? "") + event.delta.signature);
+        break;
+      case "text_delta":
+        builder.delta(event.index, event.delta.text);
+        break;
+      case "thinking_delta":
+        builder.delta(event.index, event.delta.thinking);
+        break;
+    }
+  }
+  onStart(builder, event) {
+    const block = event.content_block;
+    switch (block.type) {
+      case "document":
+      case "image":
+      case "tool_result":
+        break;
+      case "redacted_thinking":
+        builder.start(event.index, "reasoning");
+        builder.end(event.index, {
+          content: { content: [{ text: block.data, type: "redacted" }], type: "reasoning" }
+        });
+        break;
+      case "text":
+        builder.start(event.index, "text");
+        if (block.citations != null && block.citations.length > 0)
+          this.citations.set(event.index, [...block.citations]);
+        if (block.text !== "")
+          builder.delta(event.index, block.text);
+        break;
+      case "thinking":
+        builder.start(event.index, "reasoning");
+        if (block.thinking !== "")
+          builder.delta(event.index, block.thinking);
+        if (block.signature != null)
+          this.signatures.set(event.index, block.signature);
+        break;
+      case "tool_use":
+        builder.start(event.index, "tool-call", { callId: block.id, id: block.id, name: block.name });
+        if (typeof block.input === "object" && block.input !== null && Object.keys(block.input).length > 0)
+          builder.delta(event.index, JSON.stringify(block.input));
+        break;
+      default:
+        builder.start(event.index, "provider", { source: this.source });
+        this.providerBlocks.set(event.index, { block, input: "" });
+    }
+  }
+  onStop(builder, event) {
+    const provider = this.providerBlocks.get(event.index);
+    this.providerBlocks.delete(event.index);
+    if (provider != null) {
+      const value = provider.input === "" ? provider.block : { ...provider.block, input: JSON.parse(provider.input) };
+      builder.end(event.index, { content: { source: this.source, type: "provider", value } });
+      return;
+    }
+    const signature = this.signatures.get(event.index);
+    this.signatures.delete(event.index);
+    const citations = this.citations.get(event.index);
+    this.citations.delete(event.index);
+    builder.end(event.index, signature == null && citations == null ? {} : { providerMetadata: { messages: {
+      ...citations == null ? {} : { citations },
+      ...signature == null ? {} : { signature }
+    } } });
+  }
+}
+
+const SUPPORTED_FORMATS = /* @__PURE__ */ new Set([
+  "date",
+  "date-time",
+  "duration",
+  "email",
+  "hostname",
+  "ipv4",
+  "ipv6",
+  "time",
+  "uri",
+  "uuid"
+]);
+const normalizeSchema = (schema) => {
+  const normalized = { ...schema };
+  const normalize = (schema2) => typeof schema2 === "boolean" ? schema2 : normalizeSchema(schema2);
+  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;
+  }
+  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);
+  if (normalized.allOf != null)
+    normalized.allOf = normalized.allOf.map(normalize);
+  for (const key of ["exclusiveMaximum", "exclusiveMinimum", "maximum", "minimum", "multipleOf", "minLength", "maxLength", "maxItems"])
+    delete normalized[key];
+  if ((normalized.minItems ?? 0) > 1)
+    delete normalized.minItems;
+  if (normalized.format != null && !SUPPORTED_FORMATS.has(normalized.format))
+    delete normalized.format;
+  return normalized;
+};
+
+const normalizeFormat = (outputFormat) => outputFormat == null ? void 0 : {
+  schema: normalizeSchema(resolveSchema(outputFormat).schema),
+  type: "json_schema"
+};
+
+const DATA_URL_PATTERN = /^data:([^;,]+);base64,(.*)$/s;
+const parseDataUrl = (data) => {
+  const match = DATA_URL_PATTERN.exec(data);
+  return match === null ? void 0 : { data: match[2], mediaType: match[1] };
+};
+const normalizeInputTextPart = (part) => ({
+  // TODO: Move citations to a first-class TextPart field.
+  citations: part.providerMetadata?.messages?.citations,
+  text: part.text,
+  type: "text"
+});
+const normalizeImagePart = (part) => {
+  const data = part.data.toString();
+  const dataUrl = parseDataUrl(data);
+  if (dataUrl != null)
+    return { source: { data: dataUrl.data, media_type: dataUrl.mediaType, type: "base64" }, type: "image" };
+  if (URL.canParse(data))
+    return { source: { type: "url", url: data }, type: "image" };
+  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();
+  const dataUrl = parseDataUrl(data);
+  if (dataUrl != null) {
+    if (dataUrl.mediaType !== "application/pdf")
+      throw new XSAIError("invalid-input", `Anthropic documents only support PDF or plain text, got: ${dataUrl.mediaType}`);
+    return { source: { data: dataUrl.data, media_type: "application/pdf", type: "base64" }, type: "document" };
+  }
+  if (URL.canParse(data))
+    return { source: { type: "url", url: data }, type: "document" };
+  return { source: { data, media_type: "text/plain", type: "text" }, type: "document" };
+};
+const normalizeToolResultContent = (content) => {
+  switch (content.type) {
+    case "image":
+      return normalizeImagePart(content);
+    case "text":
+      return normalizeInputTextPart(content);
+  }
+};
+const normalizeToolResultPart = (part) => ({
+  content: typeof part.output === "string" ? part.output : part.output.map(normalizeToolResultContent),
+  is_error: part.isError,
+  tool_use_id: part.callId,
+  type: "tool_result"
+});
+const normalizeReasoningPartContent = (content) => {
+  switch (content.type) {
+    case "encrypted":
+    case "redacted":
+      return [{ data: content.text, type: "redacted_thinking" }];
+    case "summary":
+      return [];
+    case "text":
+      return [{ thinking: content.text, type: "thinking" }];
+  }
+};
+const normalizeReasoningPart = (part) => {
+  const blocks = part.content.flatMap(normalizeReasoningPartContent);
+  const signature = part.providerMetadata?.messages?.signature;
+  if (signature == null)
+    return blocks;
+  const block = blocks.findLast((block2) => block2.type === "thinking");
+  if (block?.type === "thinking")
+    block.signature = signature;
+  return blocks;
+};
+const normalizeToolCallPart = (part) => ({
+  id: part.callId,
+  input: part.arguments === "" ? {} : JSON.parse(part.arguments),
+  name: part.name,
+  type: "tool_use"
+});
+const normalizeUserPart = (part) => {
+  switch (part.type) {
+    case "file":
+      return normalizeFilePart(part);
+    case "image":
+      return normalizeImagePart(part);
+    case "text":
+      return normalizeInputTextPart(part);
+    case "tool-result":
+      return normalizeToolResultPart(part);
+  }
+};
+const normalizeAssistantPart = (part, source) => {
+  switch (part.type) {
+    case "provider":
+      return part.source === source ? [part.value] : [];
+    case "reasoning":
+      return normalizeReasoningPart(part);
+    case "refusal":
+      throw new XSAIError("invalid-input", "Refusal parts cannot be replayed on the Messages API");
+    case "text":
+      return [normalizeInputTextPart(part)];
+    case "tool-call":
+      return [normalizeToolCallPart(part)];
+  }
+};
+const normalizeUserMessage = (message) => ({
+  content: typeof message.content === "string" ? [{ text: message.content, type: "text" }] : message.content.map(normalizeUserPart),
+  role: "user"
+});
+const normalizeAssistantMessage = (message, source) => {
+  const content = typeof message.content === "string" ? [{ text: message.content, type: "text" }] : message.content.flatMap((part) => normalizeAssistantPart(part, source));
+  return content.length === 0 ? void 0 : { content, role: "assistant" };
+};
+const systemText = (content) => typeof content === "string" ? [{ text: content, type: "text" }] : content.map(normalizeInputTextPart);
+const normalizeInput = (options, source) => {
+  const system = [];
+  const messages = [];
+  if (options.instructions != null)
+    system.push({ text: options.instructions, type: "text" });
+  for (const message of typeof options.input === "string" ? [{ content: options.input, role: "user" }] : options.input) {
+    switch (message.role) {
+      case "assistant":
+        {
+          const assistant = normalizeAssistantMessage(message, source);
+          if (assistant != null)
+            messages.push(assistant);
+        }
+        break;
+      case "developer":
+      case "system":
+        system.push(...systemText(message.content));
+        break;
+      case "user":
+        messages.push(normalizeUserMessage(message));
+        break;
+    }
+  }
+  return {
+    messages,
+    system: system.length === 0 ? void 0 : system
+  };
+};
+
+const normalizeTools = (tools) => tools?.map((tool) => ({
+  description: tool.description,
+  input_schema: normalizeSchema(tool.inputSchema.schema),
+  name: tool.name
+}));
+const mergeTools = (providerTools, tools) => {
+  const merged = [
+    ...providerTools ?? [],
+    ...normalizeTools(tools) ?? []
+  ];
+  return merged.length === 0 ? void 0 : merged;
+};
+const normalizeToolChoice = (toolChoice) => toolChoice == null ? void 0 : typeof toolChoice === "string" ? { type: toolChoice === "required" ? "any" : toolChoice } : { name: toolChoice.name, type: "tool" };
+
+const ANTHROPIC_VERSION = "2023-06-01";
+const messages = (options) => async (modelOptions) => {
+  const source = requestURL("messages", options.baseURL).toString();
+  const { messages: inputMessages, system } = normalizeInput(modelOptions, source);
+  const maxTokens = modelOptions.maxOutputTokens;
+  const outputFormat = normalizeFormat(modelOptions.outputFormat);
+  const providerOptions = modelOptions.providerOptions?.messages;
+  if (typeof maxTokens !== "number")
+    throw new XSAIError("invalid-input", "maxOutputTokens is required for the Messages API");
+  return wireRequest({
+    body: {
+      cache_control: providerOptions?.cacheControl,
+      max_tokens: maxTokens,
+      mcp_servers: providerOptions?.mcpServers,
+      messages: inputMessages,
+      model: options.model,
+      output_config: modelOptions.reasoningEffort == null && outputFormat == null ? void 0 : { effort: modelOptions.reasoningEffort, format: outputFormat },
+      stop_sequences: providerOptions?.stopSequences,
+      stream: true,
+      system,
+      temperature: modelOptions.temperature,
+      thinking: providerOptions?.thinking,
+      tool_choice: normalizeToolChoice(modelOptions.toolChoice),
+      tools: mergeTools(providerOptions?.tools, modelOptions.tools),
+      top_p: modelOptions.topP
+    },
+    headers: {
+      ...options.headers,
+      "anthropic-beta": providerOptions?.betas !== void 0 && providerOptions.betas.length > 0 ? providerOptions.betas.join(",") : options.headers?.["anthropic-beta"],
+      "anthropic-version": ANTHROPIC_VERSION,
+      "Content-Type": "application/json",
+      "x-api-key": options.apiKey ?? options.headers?.["x-api-key"]
+    },
+    path: source
+  }, options, modelOptions, new MessagesEventStream(source, modelOptions.includeRawEvents));
+};
+
+export { messages };

package/package.json

@@ -1,6 +1,49 @@
 {
   "name": "@xsai/text-messages",
-  "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: Anthropic Messages 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-messages"
+  },
+  "bugs": "https://github.com/moeru-ai/xsai/issues",
+  "keywords": [
+    "xsai",
+    "ai",
+    "anthropic",
+    "messages",
+    "claude"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "@xsai/text": "1.0.0-beta.1"
+  },
+  "dependencies": {
+    "@xsai/shared": "1.0.0-beta.1"
+  },
+  "devDependencies": {
+    "@xsai/text": "1.0.0-beta.1"
+  },
+  "scripts": {
+    "build": "pkgroll --clean-dist",
+    "test": "vitest run --exclude e2e/**",
+    "test:watch": "vitest"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts"
 }