@core-ai/core-ai 0.6.0 → 0.6.1

package/dist/index.js

@@ -75,38 +75,54 @@ function assistantMessage(content) {
 }
 
 // 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) {
-  if (typeof input === "string" && input.length === 0) {
+  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");
   }
-  if (Array.isArray(input) && input.length === 0) {
-    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 } = params;
+  const { model, options } = splitModelFromParams(params);
   return model.generate(options);
 }
 
 // src/generate-object.ts
 async function generateObject(params) {
   assertNonEmptyMessages(params.messages);
-  const { model, ...options } = params;
+  const { model, options } = splitModelFromParams(params);
   return model.generateObject(options);
 }
 
 // src/stream-chat.ts
 async function stream(params) {
   assertNonEmptyMessages(params.messages);
-  const { model, ...options } = params;
+  const { model, options } = splitModelFromParams(params);
   return model.stream(options);
 }
 
@@ -370,41 +386,68 @@ function createChatStream(source, options = {}) {
     reasoningBuffer = "";
     reasoningProviderMetadata = void 0;
   };
+  const startReasoning = () => {
+    flushText();
+    flushReasoning();
+    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 setFinish = (event) => {
+    finishReason = event.finishReason;
+    usage = event.usage;
+  };
   return createStream({
     source: resolvedSource,
     signal,
     reduceEvent(event) {
-      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") {
-        reasoningProviderMetadata = event.providerMetadata;
-        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
-        });
-      } else if (event.type === "finish") {
-        finishReason = event.finishReason;
-        usage = event.usage;
+      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;
       }
     },
     finalizeResult() {
@@ -437,16 +480,14 @@ function getProviderMetadata(providerMetadata, provider) {
 // src/embed.ts
 async function embed(params) {
   assertNonEmptyEmbedInput(params.input);
-  const { model, ...options } = params;
+  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 {

package/package.json

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