@core-ai/core-ai 0.3.0 → 0.5.0

package/dist/index.d.ts

@@ -31,10 +31,27 @@ type FilePart = {
     mimeType: string;
     filename?: string;
 };
+type ReasoningEffort = 'minimal' | 'low' | 'medium' | 'high' | 'max';
+type ReasoningConfig = {
+    effort: ReasoningEffort;
+};
+type AssistantTextPart = {
+    type: 'text';
+    text: string;
+};
+type ReasoningPart = {
+    type: 'reasoning';
+    text: string;
+    providerMetadata?: Record<string, unknown>;
+};
+type ToolCallPart = {
+    type: 'tool-call';
+    toolCall: ToolCall;
+};
+type AssistantContentPart = AssistantTextPart | ReasoningPart | ToolCallPart;
 type AssistantMessage = {
     role: 'assistant';
-    content: string | null;
-    toolCalls?: ToolCall[];
+    parts: AssistantContentPart[];
 };
 type ToolCall = {
     id: string;
@@ -75,6 +92,7 @@ type ModelConfig = {
 };
 type GenerateOptions = {
     messages: Message[];
+    reasoning?: ReasoningConfig;
     tools?: ToolSet;
     toolChoice?: ToolChoice;
     config?: ModelConfig;
@@ -82,7 +100,9 @@ type GenerateOptions = {
     signal?: AbortSignal;
 };
 type GenerateResult = {
+    parts: AssistantContentPart[];
     content: string | null;
+    reasoning: string | null;
     toolCalls: ToolCall[];
     finishReason: FinishReason;
     usage: ChatUsage;
@@ -92,6 +112,7 @@ type GenerateObjectOptions<TSchema extends z.ZodType> = {
     schema: TSchema;
     schemaName?: string;
     schemaDescription?: string;
+    reasoning?: ReasoningConfig;
     config?: ModelConfig;
     providerOptions?: Record<string, unknown>;
     signal?: AbortSignal;
@@ -106,31 +127,51 @@ type FinishReason = 'stop' | 'length' | 'tool-calls' | 'content-filter' | 'unkno
 /**
  * Token usage reported by the model after a chat completion.
  *
- * `outputTokens` is the **total** output token count, including both visible
- * text and any internal reasoning/thinking the model performed.
- * `reasoningTokens` is the subset of `outputTokens` consumed by reasoning.
- * For non-reasoning models (or providers that don't report it separately)
- * this will be `0`.
+ * `inputTokens` is always the **total** input token count, including cached
+ * reads and cache writes. Anthropic's `input_tokens` is normalized by adding
+ * `cache_read_input_tokens` and `cache_creation_input_tokens`.
  *
- * Provider mapping:
- * - **OpenAI**: `reasoningTokens` comes from `completion_tokens_details.reasoning_tokens`.
- * - **Google Gemini**: `reasoningTokens` comes from `thoughtsTokenCount`;
- *   `outputTokens` = `candidatesTokenCount + thoughtsTokenCount`.
- * - **Anthropic**: `reasoningTokens` is always `0` (thinking tokens are
- *   included in `output_tokens` but not reported separately by the API).
+ * `outputTokens` is always the **total** output token count, including both
+ * visible text and internal reasoning.
+ *
+ * `inputTokenDetails` and `outputTokenDetails` provide provider-independent
+ * breakdowns for cache and reasoning accounting.
  */
 type ChatUsage = {
-    /** Number of tokens in the input prompt. */
+    /** Total input tokens, including cached and cache-write tokens. */
     inputTokens: number;
     /** Total output tokens, including both visible text and reasoning. */
     outputTokens: number;
-    /** Tokens consumed by internal reasoning/thinking. Subset of `outputTokens`. */
-    reasoningTokens: number;
-    /** Sum of all tokens (`inputTokens + outputTokens`). */
-    totalTokens: number;
+    /** Breakdown of input token categories. */
+    inputTokenDetails: ChatInputTokenDetails;
+    /** Breakdown of output token categories. */
+    outputTokenDetails: ChatOutputTokenDetails;
+};
+type ChatInputTokenDetails = {
+    /** Input tokens served from a prior cache entry. Subset of `inputTokens`. */
+    cacheReadTokens: number;
+    /**
+     * Input tokens written to cache for future reuse. Subset of `inputTokens`.
+     * Only Anthropic reports this; other providers report `0`.
+     */
+    cacheWriteTokens: number;
+};
+type ChatOutputTokenDetails = {
+    /**
+     * Tokens consumed by internal reasoning/thinking. Subset of `outputTokens`.
+     * Omitted when the provider does not report a breakdown.
+     */
+    reasoningTokens?: number;
 };
 type StreamEvent = {
-    type: 'content-delta';
+    type: 'reasoning-start';
+} | {
+    type: 'reasoning-delta';
+    text: string;
+} | {
+    type: 'reasoning-end';
+} | {
+    type: 'text-delta';
     text: string;
 } | {
     type: 'tool-call-start';
@@ -238,6 +279,12 @@ declare class StructuredOutputValidationError extends StructuredOutputError {
 
 declare function defineTool(options: ToolDefinition): ToolDefinition;
 
+type ResultToMessageOptions = {
+    includeReasoning?: boolean;
+};
+declare function resultToMessage(result: GenerateResult, options?: ResultToMessageOptions): AssistantMessage;
+declare function assistantMessage(content: string): AssistantMessage;
+
 type GenerateParams = GenerateOptions & {
     model: ChatModel;
 };
@@ -271,4 +318,4 @@ type GenerateImageParams = ImageGenerateOptions & {
 };
 declare function generateImage(params: GenerateImageParams): Promise<ImageGenerateResult>;
 
-export { type AssistantMessage, type ChatModel, type ChatUsage, type EmbedOptions, type EmbedResult, type EmbeddingModel, type EmbeddingUsage, type FilePart, type FinishReason, type GenerateObjectOptions, type GenerateObjectResult, type GenerateOptions, type GenerateResult, type GeneratedImage, type ImageGenerateOptions, type ImageGenerateResult, type ImageModel, type ImagePart, LLMError, type Message, type ModelConfig, type ObjectStreamEvent, ProviderError, type StreamEvent, type StreamObjectOptions, type StreamObjectResult, type StreamResult, StructuredOutputError, StructuredOutputNoObjectGeneratedError, StructuredOutputParseError, StructuredOutputValidationError, type SystemMessage, type TextPart, type ToolCall, type ToolChoice, type ToolDefinition, type ToolResultMessage, type ToolSet, type UserContentPart, type UserMessage, createObjectStreamResult, createStreamResult, defineTool, embed, generate, generateImage, generateObject, stream, streamObject };
+export { type AssistantContentPart, type AssistantMessage, type AssistantTextPart, type ChatInputTokenDetails, type ChatModel, type ChatOutputTokenDetails, type ChatUsage, type EmbedOptions, type EmbedResult, type EmbeddingModel, type EmbeddingUsage, type FilePart, type FinishReason, type GenerateObjectOptions, type GenerateObjectResult, type GenerateOptions, type GenerateResult, type GeneratedImage, type ImageGenerateOptions, type ImageGenerateResult, type ImageModel, type ImagePart, LLMError, type Message, type ModelConfig, type ObjectStreamEvent, ProviderError, type ReasoningConfig, type ReasoningEffort, type ReasoningPart, type StreamEvent, type StreamObjectOptions, type StreamObjectResult, type StreamResult, StructuredOutputError, StructuredOutputNoObjectGeneratedError, StructuredOutputParseError, StructuredOutputValidationError, type SystemMessage, type TextPart, type ToolCall, type ToolCallPart, type ToolChoice, type ToolDefinition, type ToolResultMessage, type ToolSet, type UserContentPart, type UserMessage, assistantMessage, createObjectStreamResult, createStreamResult, defineTool, embed, generate, generateImage, generateObject, resultToMessage, stream, streamObject };

package/dist/index.js

@@ -52,6 +52,22 @@ function defineTool(options) {
   return options;
 }
 
+// src/result-to-message.ts
+function resultToMessage(result, options) {
+  const includeReasoning = options?.includeReasoning ?? true;
+  const parts = includeReasoning ? [...result.parts] : result.parts.filter((part) => part.type !== "reasoning");
+  return {
+    role: "assistant",
+    parts
+  };
+}
+function assistantMessage(content) {
+  return {
+    role: "assistant",
+    parts: [{ type: "text", text: content }]
+  };
+}
+
 // src/generate.ts
 async function generate(params) {
   if (params.messages.length === 0) {
@@ -103,8 +119,11 @@ function createObjectStreamResult(source) {
     let usage = {
       inputTokens: 0,
       outputTokens: 0,
-      reasoningTokens: 0,
-      totalTokens: 0
+      inputTokenDetails: {
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0
+      },
+      outputTokenDetails: {}
     };
     try {
       for await (const event of source) {
@@ -164,28 +183,85 @@ function createStreamResult(source) {
   });
   let iteratorCreated = false;
   async function* iterate() {
-    let content = "";
-    const toolCalls = [];
+    const parts = [];
+    let textBuffer = "";
+    let reasoningBuffer = "";
+    let insideReasoning = false;
     let finishReason = "unknown";
     let usage = {
       inputTokens: 0,
       outputTokens: 0,
-      reasoningTokens: 0,
-      totalTokens: 0
+      inputTokenDetails: {
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0
+      },
+      outputTokenDetails: {}
+    };
+    const flushText = () => {
+      if (textBuffer.length === 0) {
+        return;
+      }
+      parts.push({
+        type: "text",
+        text: textBuffer
+      });
+      textBuffer = "";
+    };
+    const flushReasoning = () => {
+      if (reasoningBuffer.length === 0) {
+        return;
+      }
+      parts.push({
+        type: "reasoning",
+        text: reasoningBuffer
+      });
+      reasoningBuffer = "";
     };
     for await (const event of source) {
-      if (event.type === "content-delta") {
-        content += event.text;
+      if (event.type === "reasoning-start") {
+        flushText();
+        flushReasoning();
+        insideReasoning = true;
+      } else if (event.type === "reasoning-delta") {
+        if (!insideReasoning) {
+          flushText();
+          insideReasoning = true;
+        }
+        reasoningBuffer += event.text;
+      } else if (event.type === "reasoning-end") {
+        flushReasoning();
+        insideReasoning = false;
+      } else if (event.type === "text-delta") {
+        if (insideReasoning) {
+          flushReasoning();
+          insideReasoning = false;
+        }
+        textBuffer += event.text;
       } else if (event.type === "tool-call-end") {
-        toolCalls.push(event.toolCall);
+        flushText();
+        flushReasoning();
+        insideReasoning = false;
+        parts.push({
+          type: "tool-call",
+          toolCall: event.toolCall
+        });
       } else if (event.type === "finish") {
         finishReason = event.finishReason;
         usage = event.usage;
       }
       yield event;
     }
+    flushText();
+    flushReasoning();
+    const content = parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
+    const reasoning = parts.flatMap((part) => part.type === "reasoning" ? [part.text] : []).join("");
+    const toolCalls = parts.flatMap(
+      (part) => part.type === "tool-call" ? [part.toolCall] : []
+    );
     resolveResponse?.({
+      parts,
       content: content.length > 0 ? content : null,
+      reasoning: reasoning.length > 0 ? reasoning : null,
       toolCalls,
       finishReason,
       usage
@@ -241,6 +317,7 @@ export {
   StructuredOutputNoObjectGeneratedError,
   StructuredOutputParseError,
   StructuredOutputValidationError,
+  assistantMessage,
   createObjectStreamResult,
   createStreamResult,
   defineTool,
@@ -248,6 +325,7 @@ export {
   generate,
   generateImage,
   generateObject,
+  resultToMessage,
   stream,
   streamObject
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/core-ai",
-    "version": "0.3.0",
+    "version": "0.5.0",
     "description": "Type-safe LLM abstraction layer over native provider SDKs",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",