@core-ai/core-ai 0.6.0 → 0.7.0

package/dist/index.d.ts

@@ -315,6 +315,12 @@ declare class StructuredOutputValidationError extends StructuredOutputError {
 
 declare function defineTool(options: ToolDefinition): ToolDefinition;
 
+/**
+ * Convert a Zod schema to a JSON Schema object using Zod 4's native
+ * `z.toJSONSchema()`.
+ */
+declare function zodSchemaToJsonSchema(schema: z.ZodType): Record<string, unknown>;
+
 type ResultToMessageOptions = {
     includeReasoning?: boolean;
 };
@@ -360,4 +366,4 @@ type GenerateImageParams = ImageGenerateOptions & {
 };
 declare function generateImage(params: GenerateImageParams): Promise<ImageGenerateResult>;
 
-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 };
+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, zodSchemaToJsonSchema };

package/dist/index.js

@@ -53,11 +53,18 @@ var StructuredOutputValidationError = class extends StructuredOutputError {
 };
 
 // src/tool.ts
-import { zodToJsonSchema } from "zod-to-json-schema";
 function defineTool(options) {
   return options;
 }
 
+// src/json-schema.ts
+import { z } from "zod";
+function zodSchemaToJsonSchema(schema) {
+  return z.toJSONSchema(schema, {
+    io: "input"
+  });
+}
+
 // src/result-to-message.ts
 function resultToMessage(result, options) {
   const includeReasoning = options?.includeReasoning ?? true;
@@ -75,38 +82,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 +393,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 +487,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 {
@@ -468,5 +516,6 @@ export {
   getProviderMetadata,
   resultToMessage,
   stream,
-  streamObject
+  streamObject,
+  zodSchemaToJsonSchema
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@core-ai/core-ai",
-    "version": "0.6.0",
+    "version": "0.7.0",
     "description": "Type-safe LLM abstraction layer over native provider SDKs",
     "license": "MIT",
     "author": "Omnifact (https://omnifact.ai)",
@@ -43,8 +43,7 @@
         "test:watch": "vitest"
     },
     "dependencies": {
-        "zod": "^3.25.0 || ^4.0.0",
-        "zod-to-json-schema": "^3.25.1"
+        "zod": "^4.0.0"
     },
     "devDependencies": {
         "@core-ai/eslint-config": "*",