@core-ai/core-ai 0.5.1 → 0.6.1

package/README.md

@@ -15,6 +15,7 @@ Provider packages are published separately:
 - `@core-ai/openai`
 - `@core-ai/anthropic`
 - `@core-ai/google-genai`
+- `@core-ai/mistral`
 
 ## Usage
 

package/dist/index.d.ts

@@ -42,7 +42,18 @@ type AssistantTextPart = {
 type ReasoningPart = {
     type: 'reasoning';
     text: string;
-    providerMetadata?: Record<string, unknown>;
+    /**
+     * Provider-namespaced metadata for this reasoning block. The top-level key is
+     * the provider identifier (e.g. `'anthropic'`, `'openai'`), which also serves as
+     * the ownership discriminator: an adapter checks for the presence of its own key
+     * to detect cross-provider blocks. Cross-provider blocks are downgraded to plain
+     * text (preserving context) rather than forwarding opaque metadata that would
+     * cause an API error on the receiving provider.
+     *
+     * @example Anthropic: `{ anthropic: { signature: '...' } }`
+     * @example OpenAI:    `{ openai: { encryptedContent: '...' } }`
+     */
+    providerMetadata?: Record<string, Record<string, unknown>>;
 };
 type ToolCallPart = {
     type: 'tool-call';
@@ -78,26 +89,31 @@ type ChatModel = {
     readonly provider: string;
     readonly modelId: string;
     generate(options: GenerateOptions): Promise<GenerateResult>;
-    stream(options: GenerateOptions): Promise<StreamResult>;
+    stream(options: GenerateOptions): Promise<ChatStream>;
     generateObject<TSchema extends z.ZodType>(options: GenerateObjectOptions<TSchema>): Promise<GenerateObjectResult<TSchema>>;
-    streamObject<TSchema extends z.ZodType>(options: StreamObjectOptions<TSchema>): Promise<StreamObjectResult<TSchema>>;
+    streamObject<TSchema extends z.ZodType>(options: StreamObjectOptions<TSchema>): Promise<ObjectStream<TSchema>>;
 };
-type ModelConfig = {
+interface GenerateProviderOptions {
+    [key: string]: Record<string, unknown> | undefined;
+}
+interface EmbedProviderOptions {
+    [key: string]: Record<string, unknown> | undefined;
+}
+interface ImageProviderOptions {
+    [key: string]: Record<string, unknown> | undefined;
+}
+type BaseGenerateOptions = {
+    messages: Message[];
     temperature?: number;
     maxTokens?: number;
     topP?: number;
-    stopSequences?: string[];
-    frequencyPenalty?: number;
-    presencePenalty?: number;
-};
-type GenerateOptions = {
-    messages: Message[];
     reasoning?: ReasoningConfig;
+    providerOptions?: GenerateProviderOptions;
+    signal?: AbortSignal;
+};
+type GenerateOptions = BaseGenerateOptions & {
     tools?: ToolSet;
     toolChoice?: ToolChoice;
-    config?: ModelConfig;
-    providerOptions?: Record<string, unknown>;
-    signal?: AbortSignal;
 };
 type GenerateResult = {
     parts: AssistantContentPart[];
@@ -107,15 +123,10 @@ type GenerateResult = {
     finishReason: FinishReason;
     usage: ChatUsage;
 };
-type GenerateObjectOptions<TSchema extends z.ZodType> = {
-    messages: Message[];
+type GenerateObjectOptions<TSchema extends z.ZodType> = BaseGenerateOptions & {
     schema: TSchema;
     schemaName?: string;
     schemaDescription?: string;
-    reasoning?: ReasoningConfig;
-    config?: ModelConfig;
-    providerOptions?: Record<string, unknown>;
-    signal?: AbortSignal;
 };
 type StreamObjectOptions<TSchema extends z.ZodType> = GenerateObjectOptions<TSchema>;
 type GenerateObjectResult<TSchema extends z.ZodType> = {
@@ -170,6 +181,7 @@ type StreamEvent = {
     text: string;
 } | {
     type: 'reasoning-end';
+    providerMetadata?: Record<string, Record<string, unknown>>;
 } | {
     type: 'text-delta';
     text: string;
@@ -189,8 +201,21 @@ type StreamEvent = {
     finishReason: FinishReason;
     usage: ChatUsage;
 };
-type StreamResult = AsyncIterable<StreamEvent> & {
-    toResponse(): Promise<GenerateResult>;
+/**
+ * Handle for a single in-flight chat streaming operation.
+ *
+ * The handle is replayable: iterating after some or all events have already
+ * arrived replays the buffered event history before waiting for later events.
+ *
+ * `result` resolves with the aggregated final response when the operation
+ * completes successfully, and rejects on abort or upstream failure.
+ *
+ * `events` always resolves with all observed events up to the terminal point,
+ * including abort and failure cases.
+ */
+type ChatStream = AsyncIterable<StreamEvent> & {
+    readonly result: Promise<GenerateResult>;
+    readonly events: Promise<readonly StreamEvent[]>;
 };
 type ObjectStreamEvent<TSchema extends z.ZodType> = {
     type: 'object-delta';
@@ -203,8 +228,16 @@ type ObjectStreamEvent<TSchema extends z.ZodType> = {
     finishReason: FinishReason;
     usage: ChatUsage;
 };
-type StreamObjectResult<TSchema extends z.ZodType> = AsyncIterable<ObjectStreamEvent<TSchema>> & {
-    toResponse(): Promise<GenerateObjectResult<TSchema>>;
+/**
+ * Handle for a single in-flight structured object streaming operation.
+ *
+ * The lifecycle semantics mirror `ChatStream`: iteration is replayable,
+ * `result` settles independently of event consumption, and `events` resolves
+ * with the observed history.
+ */
+type ObjectStream<TSchema extends z.ZodType> = AsyncIterable<ObjectStreamEvent<TSchema>> & {
+    readonly result: Promise<GenerateObjectResult<TSchema>>;
+    readonly events: Promise<readonly ObjectStreamEvent<TSchema>[]>;
 };
 type EmbeddingModel = {
     readonly provider: string;
@@ -214,7 +247,7 @@ type EmbeddingModel = {
 type EmbedOptions = {
     input: string | string[];
     dimensions?: number;
-    providerOptions?: Record<string, unknown>;
+    providerOptions?: EmbedProviderOptions;
 };
 type EmbedResult = {
     embeddings: number[][];
@@ -237,7 +270,7 @@ type ImageGenerateOptions = {
     prompt: string;
     n?: number;
     size?: string;
-    providerOptions?: Record<string, unknown>;
+    providerOptions?: ImageProviderOptions;
 };
 type ImageGenerateResult = {
     images: GeneratedImage[];
@@ -252,6 +285,9 @@ declare class LLMError extends Error {
     readonly cause?: unknown;
     constructor(message: string, cause?: unknown);
 }
+declare class StreamAbortedError extends LLMError {
+    constructor(message?: string, cause?: unknown);
+}
 declare class ProviderError extends LLMError {
     readonly provider: string;
     readonly statusCode?: number;
@@ -298,15 +334,21 @@ declare function generateObject<TSchema extends z.ZodType>(params: GenerateObjec
 type StreamParams = GenerateOptions & {
     model: ChatModel;
 };
-declare function stream(params: StreamParams): Promise<StreamResult>;
+declare function stream(params: StreamParams): Promise<ChatStream>;
 
 type StreamObjectParams<TSchema extends z.ZodType> = StreamObjectOptions<TSchema> & {
     model: ChatModel;
 };
-declare function streamObject<TSchema extends z.ZodType>(params: StreamObjectParams<TSchema>): Promise<StreamObjectResult<TSchema>>;
-declare function createObjectStreamResult<TSchema extends z.ZodType>(source: AsyncIterable<ObjectStreamEvent<TSchema>>): StreamObjectResult<TSchema>;
+declare function streamObject<TSchema extends z.ZodType>(params: StreamObjectParams<TSchema>): Promise<ObjectStream<TSchema>>;
+declare function createObjectStream<TSchema extends z.ZodType>(source: AsyncIterable<ObjectStreamEvent<TSchema>>, options?: {
+    signal?: AbortSignal;
+}): ObjectStream<TSchema>;
+
+declare function createChatStream(source: AsyncIterable<StreamEvent> | (() => Promise<AsyncIterable<StreamEvent>>), options?: {
+    signal?: AbortSignal;
+}): ChatStream;
 
-declare function createStreamResult(source: AsyncIterable<StreamEvent>): StreamResult;
+declare function getProviderMetadata<T extends Record<string, unknown>>(providerMetadata: Record<string, Record<string, unknown>> | undefined, provider: string): T | undefined;
 
 type EmbedParams = EmbedOptions & {
     model: EmbeddingModel;
@@ -318,4 +360,4 @@ type GenerateImageParams = ImageGenerateOptions & {
 };
 declare function generateImage(params: GenerateImageParams): Promise<ImageGenerateResult>;
 
-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 };
+export { type AssistantContentPart, type AssistantMessage, type AssistantTextPart, type BaseGenerateOptions, type ChatInputTokenDetails, type ChatModel, type ChatOutputTokenDetails, type ChatStream, type ChatUsage, type EmbedOptions, type EmbedProviderOptions, type EmbedResult, type EmbeddingModel, type EmbeddingUsage, type FilePart, type FinishReason, type GenerateObjectOptions, type GenerateObjectResult, type GenerateOptions, type GenerateProviderOptions, type GenerateResult, type GeneratedImage, type ImageGenerateOptions, type ImageGenerateResult, type ImageModel, type ImagePart, type ImageProviderOptions, LLMError, type Message, type ObjectStream, type ObjectStreamEvent, ProviderError, type ReasoningConfig, type ReasoningEffort, type ReasoningPart, StreamAbortedError, type StreamEvent, type StreamObjectOptions, 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, createChatStream, createObjectStream, defineTool, embed, generate, generateImage, generateObject, getProviderMetadata, resultToMessage, stream, streamObject };

package/dist/index.js

@@ -7,6 +7,12 @@ var LLMError = class extends Error {
     this.cause = cause;
   }
 };
+var StreamAbortedError = class extends LLMError {
+  constructor(message = "stream aborted", cause) {
+    super(message, cause);
+    this.name = "StreamAbortedError";
+  }
+};
 var ProviderError = class extends LLMError {
   provider;
   statusCode;
@@ -68,263 +74,439 @@ function assistantMessage(content) {
   };
 }
 
-// src/generate.ts
-async function generate(params) {
-  if (params.messages.length === 0) {
+// src/assertions.ts
+function isEmptyText(value) {
+  return value.length === 0;
+}
+function assertNonEmptyMessages(messages) {
+  if (messages.length === 0) {
     throw new LLMError("messages must not be empty");
   }
+}
+function assertNonEmptyEmbedInput(input) {
+  const isEmptyString = typeof input === "string" && isEmptyText(input);
+  const isEmptyArray = Array.isArray(input) && input.length === 0;
+  if (isEmptyString || isEmptyArray) {
+    throw new LLMError("input must not be empty");
+  }
+}
+function assertNonEmptyPrompt(prompt) {
+  if (isEmptyText(prompt)) {
+    throw new LLMError("prompt must not be empty");
+  }
+}
+
+// src/model-options.ts
+function splitModelFromParams(params) {
   const { model, ...options } = params;
+  return {
+    model,
+    options
+  };
+}
+
+// src/generate.ts
+async function generate(params) {
+  assertNonEmptyMessages(params.messages);
+  const { model, options } = splitModelFromParams(params);
   return model.generate(options);
 }
 
 // src/generate-object.ts
 async function generateObject(params) {
-  if (params.messages.length === 0) {
-    throw new LLMError("messages must not be empty");
-  }
-  const { model, ...options } = params;
+  assertNonEmptyMessages(params.messages);
+  const { model, options } = splitModelFromParams(params);
   return model.generateObject(options);
 }
 
 // src/stream-chat.ts
 async function stream(params) {
-  if (params.messages.length === 0) {
-    throw new LLMError("messages must not be empty");
-  }
-  const { model, ...options } = params;
+  assertNonEmptyMessages(params.messages);
+  const { model, options } = splitModelFromParams(params);
   return model.stream(options);
 }
 
-// src/stream-object.ts
-async function streamObject(params) {
-  if (params.messages.length === 0) {
-    throw new LLMError("messages must not be empty");
+// src/base-stream.ts
+function createStream(options) {
+  const { source, reduceEvent, finalizeResult, signal } = options;
+  const iterator = source[Symbol.asyncIterator]();
+  const bufferedEvents = [];
+  let terminalState = { status: "running" };
+  let resolveResult;
+  let rejectResult;
+  let resolveEvents;
+  const result = new Promise((resolve, reject) => {
+    resolveResult = resolve;
+    rejectResult = reject;
+  });
+  void result.catch(() => {
+  });
+  const events = new Promise((resolve) => {
+    resolveEvents = resolve;
+  });
+  const waiters = /* @__PURE__ */ new Set();
+  let closeSourceIteratorPromise;
+  function notifyWaiters() {
+    for (const waiter of waiters) {
+      waiter();
+    }
+    waiters.clear();
   }
-  const { model, ...options } = params;
-  return model.streamObject(options);
-}
-function createObjectStreamResult(source) {
-  let resolveResponse;
-  let rejectResponse;
-  const responsePromise = new Promise(
-    (resolve, reject) => {
-      resolveResponse = resolve;
-      rejectResponse = reject;
+  function resolveWhenUpdated() {
+    if (terminalState.status !== "running") {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      waiters.add(resolve);
+    });
+  }
+  function cleanupSignalListener() {
+    signal?.removeEventListener("abort", abortStream);
+  }
+  function settleCompleted(finalResult) {
+    if (terminalState.status !== "running") {
+      return;
+    }
+    terminalState = {
+      status: "completed",
+      result: finalResult
+    };
+    cleanupSignalListener();
+    resolveResult?.(finalResult);
+    resolveEvents?.([...bufferedEvents]);
+    notifyWaiters();
+  }
+  function settleRejected(error) {
+    if (terminalState.status !== "running") {
+      return;
     }
-  );
-  let iteratorCreated = false;
-  async function* iterate() {
-    let objectResult;
-    let finishReason = "unknown";
-    let usage = {
-      inputTokens: 0,
-      outputTokens: 0,
-      inputTokenDetails: {
-        cacheReadTokens: 0,
-        cacheWriteTokens: 0
-      },
-      outputTokenDetails: {}
+    terminalState = {
+      status: "rejected",
+      error
     };
+    cleanupSignalListener();
+    rejectResult?.(error);
+    resolveEvents?.([...bufferedEvents]);
+    notifyWaiters();
+  }
+  function closeSourceIterator() {
+    if (closeSourceIteratorPromise) {
+      return closeSourceIteratorPromise;
+    }
+    closeSourceIteratorPromise = (async () => {
+      try {
+        await iterator.return?.();
+      } catch {
+      }
+    })();
+    return closeSourceIteratorPromise;
+  }
+  function abortStream() {
+    if (terminalState.status !== "running") {
+      return;
+    }
+    settleRejected(new StreamAbortedError("stream aborted"));
+    void closeSourceIterator();
+  }
+  if (signal) {
+    if (signal.aborted) {
+      abortStream();
+    } else {
+      signal.addEventListener("abort", abortStream, { once: true });
+    }
+  }
+  async function pump() {
     try {
-      for await (const event of source) {
-        if (event.type === "object") {
-          objectResult = event.object;
-        } else if (event.type === "finish") {
-          finishReason = event.finishReason;
-          usage = event.usage;
+      while (terminalState.status === "running") {
+        const next = await iterator.next();
+        if (terminalState.status !== "running") {
+          await closeSourceIterator();
+          return;
         }
-        yield event;
-      }
-      if (objectResult === void 0) {
-        throw new LLMError(
-          "object stream completed without emitting a final object"
-        );
+        if (next.done) {
+          try {
+            settleCompleted(finalizeResult());
+          } catch (error) {
+            settleRejected(error);
+          }
+          return;
+        }
+        bufferedEvents.push(next.value);
+        notifyWaiters();
+        reduceEvent(next.value);
       }
-      resolveResponse?.({
-        object: objectResult,
-        finishReason,
-        usage
-      });
     } catch (error) {
-      rejectResponse?.(error);
-      throw error;
+      settleRejected(error);
+      await closeSourceIterator();
     }
   }
-  const generator = iterate();
+  void pump();
   return {
     [Symbol.asyncIterator]() {
-      if (iteratorCreated) {
-        throw new Error("Stream can only be iterated once");
-      }
-      iteratorCreated = true;
-      return generator;
-    },
-    toResponse() {
-      if (!iteratorCreated) {
-        iteratorCreated = true;
-        (async () => {
-          try {
-            for await (const _event of generator) {
+      let index = 0;
+      let closed = false;
+      return {
+        async next() {
+          if (closed) {
+            return {
+              done: true,
+              value: void 0
+            };
+          }
+          while (!closed && index >= bufferedEvents.length) {
+            if (terminalState.status === "completed") {
+              return {
+                done: true,
+                value: void 0
+              };
             }
-          } catch {
+            if (terminalState.status === "rejected") {
+              throw terminalState.error;
+            }
+            await resolveWhenUpdated();
           }
-        })();
-      }
-      return responsePromise;
-    }
+          if (closed) {
+            return {
+              done: true,
+              value: void 0
+            };
+          }
+          const value = bufferedEvents[index];
+          index += 1;
+          return {
+            done: false,
+            value
+          };
+        },
+        async return() {
+          closed = true;
+          notifyWaiters();
+          return {
+            done: true,
+            value: void 0
+          };
+        }
+      };
+    },
+    result,
+    events
   };
 }
 
-// src/stream.ts
-function createStreamResult(source) {
-  let resolveResponse;
-  const responsePromise = new Promise((resolve) => {
-    resolveResponse = resolve;
-  });
-  let iteratorCreated = false;
-  async function* iterate() {
-    const parts = [];
-    let textBuffer = "";
-    let reasoningBuffer = "";
-    let insideReasoning = false;
-    let finishReason = "unknown";
-    let usage = {
-      inputTokens: 0,
-      outputTokens: 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 === "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") {
-        flushText();
-        flushReasoning();
-        insideReasoning = false;
-        parts.push({
-          type: "tool-call",
-          toolCall: event.toolCall
-        });
+// src/stream-object.ts
+async function streamObject(params) {
+  assertNonEmptyMessages(params.messages);
+  const { model, ...options } = params;
+  return model.streamObject(options);
+}
+function createObjectStream(source, options = {}) {
+  const { signal } = options;
+  let objectState = {
+    status: "pending"
+  };
+  let finishReason = "unknown";
+  let usage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    inputTokenDetails: {
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0
+    },
+    outputTokenDetails: {}
+  };
+  return createStream({
+    source,
+    signal,
+    reduceEvent(event) {
+      if (event.type === "object") {
+        objectState = {
+          status: "ready",
+          object: event.object
+        };
       } else if (event.type === "finish") {
         finishReason = event.finishReason;
         usage = event.usage;
       }
-      yield event;
+    },
+    finalizeResult() {
+      if (objectState.status !== "ready") {
+        throw new LLMError(
+          "object stream completed without emitting a final object"
+        );
+      }
+      return {
+        object: objectState.object,
+        finishReason,
+        usage
+      };
+    }
+  });
+}
+
+// src/stream.ts
+function createChatStream(source, options = {}) {
+  const { signal } = options;
+  const resolvedSource = typeof source === "function" ? (async function* () {
+    yield* await source();
+  })() : source;
+  const parts = [];
+  let textBuffer = "";
+  let reasoningBuffer = "";
+  let reasoningProviderMetadata;
+  let insideReasoning = false;
+  let finishReason = "unknown";
+  let usage = {
+    inputTokens: 0,
+    outputTokens: 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 && reasoningProviderMetadata === void 0) {
+      return;
     }
+    parts.push({
+      type: "reasoning",
+      text: reasoningBuffer,
+      ...reasoningProviderMetadata ? { providerMetadata: reasoningProviderMetadata } : {}
+    });
+    reasoningBuffer = "";
+    reasoningProviderMetadata = void 0;
+  };
+  const startReasoning = () => {
     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
+    insideReasoning = true;
+  };
+  const appendReasoning = (text) => {
+    if (!insideReasoning) {
+      flushText();
+      insideReasoning = true;
+    }
+    reasoningBuffer += text;
+  };
+  const endReasoning = (providerMetadata) => {
+    reasoningProviderMetadata = providerMetadata;
+    flushReasoning();
+    insideReasoning = false;
+  };
+  const appendText = (text) => {
+    if (insideReasoning) {
+      flushReasoning();
+      insideReasoning = false;
+    }
+    textBuffer += text;
+  };
+  const appendToolCall = (toolCall) => {
+    flushText();
+    flushReasoning();
+    insideReasoning = false;
+    parts.push({
+      type: "tool-call",
+      toolCall
     });
-  }
-  const generator = iterate();
-  return {
-    [Symbol.asyncIterator]() {
-      if (iteratorCreated) {
-        throw new Error("Stream can only be iterated once");
+  };
+  const setFinish = (event) => {
+    finishReason = event.finishReason;
+    usage = event.usage;
+  };
+  return createStream({
+    source: resolvedSource,
+    signal,
+    reduceEvent(event) {
+      switch (event.type) {
+        case "reasoning-start":
+          startReasoning();
+          break;
+        case "reasoning-delta":
+          appendReasoning(event.text);
+          break;
+        case "reasoning-end":
+          endReasoning(event.providerMetadata);
+          break;
+        case "text-delta":
+          appendText(event.text);
+          break;
+        case "tool-call-end":
+          appendToolCall(event.toolCall);
+          break;
+        case "finish":
+          setFinish(event);
+          break;
+        default:
+          break;
       }
-      iteratorCreated = true;
-      return generator;
     },
-    toResponse() {
-      if (!iteratorCreated) {
-        iteratorCreated = true;
-        (async () => {
-          for await (const _event of generator) {
-          }
-        })();
-      }
-      return responsePromise;
+    finalizeResult() {
+      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] : []
+      );
+      return {
+        parts,
+        content: content.length > 0 ? content : null,
+        reasoning: reasoning.length > 0 ? reasoning : null,
+        toolCalls,
+        finishReason,
+        usage
+      };
     }
-  };
+  });
+}
+
+// src/provider-metadata.ts
+function getProviderMetadata(providerMetadata, provider) {
+  return providerMetadata?.[provider];
 }
 
 // src/embed.ts
 async function embed(params) {
-  const { input } = params;
-  if (typeof input === "string" && input.length === 0) {
-    throw new LLMError("input must not be empty");
-  }
-  if (Array.isArray(input) && input.length === 0) {
-    throw new LLMError("input must not be empty");
-  }
-  const { model, ...options } = params;
+  assertNonEmptyEmbedInput(params.input);
+  const { model, options } = splitModelFromParams(params);
   return model.embed(options);
 }
 
 // src/generate-image.ts
 async function generateImage(params) {
-  if (params.prompt.length === 0) {
-    throw new LLMError("prompt must not be empty");
-  }
-  const { model, ...options } = params;
+  assertNonEmptyPrompt(params.prompt);
+  const { model, options } = splitModelFromParams(params);
   return model.generate(options);
 }
 export {
   LLMError,
   ProviderError,
+  StreamAbortedError,
   StructuredOutputError,
   StructuredOutputNoObjectGeneratedError,
   StructuredOutputParseError,
   StructuredOutputValidationError,
   assistantMessage,
-  createObjectStreamResult,
-  createStreamResult,
+  createChatStream,
+  createObjectStream,
   defineTool,
   embed,
   generate,
   generateImage,
   generateObject,
+  getProviderMetadata,
   resultToMessage,
   stream,
   streamObject

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/core-ai",
-    "version": "0.5.1",
+    "version": "0.6.1",
     "description": "Type-safe LLM abstraction layer over native provider SDKs",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -47,8 +47,9 @@
         "zod-to-json-schema": "^3.25.1"
     },
     "devDependencies": {
-        "@core-ai/eslint-config": "^0.0.0",
-        "@core-ai/typescript-config": "^0.0.0",
+        "@core-ai/eslint-config": "*",
+        "@core-ai/testing": "*",
+        "@core-ai/typescript-config": "*",
         "typescript": "^5.7.3",
         "vitest": "^3.2.4"
     }