@~lyre/ai-agents 0.2.0 → 0.4.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { LanguageModel } from 'ai';
 export { sanitizeRichHtml } from './sanitize.js';
 
 /**
@@ -42,11 +43,25 @@ type Message = {
     role: 'assistant';
     content: string;
 };
+/**
+ * Client-level defaults applied to every run. `apiKey` is a single generic key the package uses
+ * to construct whichever provider a `provider/model` string names (see providers.ts), so consumers
+ * never import `@ai-sdk/*`. `model` is the default model when an agent doesn't specify one.
+ */
+type ClientDefaults = {
+    apiKey?: string;
+    model?: ModelLike;
+};
 type AgentDefinition = {
     /** Stable identifier; used as the lookup key. Defaults to `name`. */
     id?: string;
     name: string;
-    model: ModelLike;
+    /**
+     * Model to use. A `provider/model` string (e.g. 'anthropic/claude-sonnet-4-5', 'openai/gpt-4o',
+     * 'xai/grok-2-latest') is resolved to a provider using the client's generic `apiKey`; a
+     * `LanguageModel` instance is used as-is. Optional — falls back to the client default model.
+     */
+    model?: ModelLike;
     /** System prompt. Inserted as a `system` message when no system message is in the history. */
     instructions?: string;
     temperature?: number;
@@ -62,7 +77,7 @@ type AgentDefinition = {
     providerOptions?: Record<string, Record<string, any>>;
     metadata?: Record<string, any>;
 };
-type Agent = Required<Pick<AgentDefinition, 'id' | 'name' | 'model' | 'instructions'>> & Omit<AgentDefinition, 'id' | 'name' | 'model' | 'instructions'>;
+type Agent = Required<Pick<AgentDefinition, 'id' | 'name' | 'instructions'>> & Omit<AgentDefinition, 'id' | 'name' | 'instructions'>;
 type RunParams = {
     /** Agent id, name, or definition object. */
     agent: string | AgentDefinition;
@@ -181,7 +196,8 @@ declare class Registry {
  */
 declare class AiAgentsClient {
     private readonly registry;
-    constructor();
+    private readonly defaults;
+    constructor(config?: ClientDefaults);
     registerTool<I, O>(tool: ToolDefinition<I, O>): ToolDefinition<I, O>;
     createAgent(definition: AgentDefinition): Agent;
     run(params: RunParams): Promise<RunResult>;
@@ -195,20 +211,33 @@ declare class AiAgentsClient {
     get raw(): Registry;
 }
 /**
- * Factory. Provider auth comes from environment variables. To explicitly configure
- * provider clients (e.g., for testing), pass `LanguageModel` instances to
- * `createAgent({ model })` instead of string identifiers.
+ * Factory. Pass a single generic `{ apiKey, model }` and the package constructs whichever
+ * provider the model's `provider/` prefix names — so apps never import `@ai-sdk/*`. Omit the
+ * config to fall back to the Vercel AI SDK's own env-var/gateway resolution, or pass a
+ * `LanguageModel` instance via `createAgent({ model })` for fully custom wiring.
  */
-declare function createClient(): AiAgentsClient;
+declare function createClient(config?: ClientDefaults): AiAgentsClient;
 
-declare function run(registry: Registry, params: RunParams): Promise<RunResult>;
-declare function runStream(registry: Registry, params: RunParams): AsyncGenerator<StreamEvent, void, unknown>;
+declare function run(registry: Registry, params: RunParams, defaults?: ClientDefaults): Promise<RunResult>;
+declare function runStream(registry: Registry, params: RunParams, defaults?: ClientDefaults): AsyncGenerator<StreamEvent, void, unknown>;
 /**
  * Schema-constrained structured generation. Single-shot (no tools): the model is
  * forced to return JSON matching `params.inputSchema`, validated by the AI SDK before
  * it resolves. Use this for analysis/extraction where you want a typed object instead
  * of free text. Additive — does not touch `run`/`runStream`.
  */
-declare function runObject<T>(registry: Registry, params: RunObjectParams<T>): Promise<RunObjectResult<T>>;
+declare function runObject<T>(registry: Registry, params: RunObjectParams<T>, defaults?: ClientDefaults): Promise<RunObjectResult<T>>;
+
+/** Provider prefixes this package can construct directly from a generic API key. */
+declare const SUPPORTED_PROVIDERS: string[];
+/**
+ * Turn a `provider/model` string (e.g. 'anthropic/claude-sonnet-4-5', 'openai/gpt-4o',
+ * 'xai/grok-2-latest') into a concrete provider model, using a single generic `apiKey`.
+ *
+ * Falls back to returning the original string when there's no recognizable provider prefix,
+ * the provider is unknown, or no `apiKey` is given — in which case the Vercel AI SDK resolves
+ * it itself (its gateway / provider-specific env vars). This keeps existing string usage working.
+ */
+declare function resolveModelString(model: string, apiKey?: string): LanguageModel | string;
 
-export { type Agent, type AgentDefinition, AiAgentsClient, type Message, type ModelId, type ModelLike, Registry, type RunObjectParams, type RunObjectResult, type RunParams, type RunResult, type StreamEvent, type ToolContext, type ToolDefinition, createClient, run, runObject, runStream };
+export { type Agent, type AgentDefinition, AiAgentsClient, type ClientDefaults, type Message, type ModelId, type ModelLike, Registry, type RunObjectParams, type RunObjectResult, type RunParams, type RunResult, SUPPORTED_PROVIDERS, type StreamEvent, type ToolContext, type ToolDefinition, createClient, resolveModelString, run, runObject, runStream };

package/dist/index.js

@@ -46,9 +46,36 @@ var Registry = class {
 };
 
 // src/run.ts
-import { generateObject, generateText, streamText, tool } from "ai";
-function resolveModel(agent) {
-  return agent.model;
+import { generateText, streamText, tool, Output } from "ai";
+
+// src/providers.ts
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createXai } from "@ai-sdk/xai";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+var PROVIDERS = {
+  anthropic: (apiKey, id) => createAnthropic({ apiKey })(id),
+  openai: (apiKey, id) => createOpenAI({ apiKey })(id),
+  xai: (apiKey, id) => createXai({ apiKey })(id),
+  // Grok
+  google: (apiKey, id) => createGoogleGenerativeAI({ apiKey })(id)
+};
+var SUPPORTED_PROVIDERS = Object.keys(PROVIDERS);
+function resolveModelString(model, apiKey) {
+  const slash = model.indexOf("/");
+  if (slash <= 0) return model;
+  const provider = model.slice(0, slash);
+  const modelId = model.slice(slash + 1);
+  const factory = PROVIDERS[provider];
+  if (factory && apiKey && modelId) return factory(apiKey, modelId);
+  return model;
+}
+
+// src/run.ts
+function resolveModel(agent, defaults) {
+  const model = agent.model ?? defaults?.model;
+  if (typeof model === "string") return resolveModelString(model, defaults?.apiKey);
+  return model;
 }
 function buildMessages(agent, params) {
   const messages = [];
@@ -75,12 +102,12 @@ function buildTools(registry, agent, context) {
   }
   return out;
 }
-async function run(registry, params) {
+async function run(registry, params, defaults) {
   const agent = registry.resolveAgent(params.agent);
   const messages = buildMessages(agent, params);
   const tools = buildTools(registry, agent, params.context ?? {});
   const result = await generateText({
-    model: resolveModel(agent),
+    model: resolveModel(agent, defaults),
     messages,
     tools,
     temperature: params.temperature ?? agent.temperature,
@@ -109,12 +136,12 @@ async function run(registry, params) {
     raw: result
   };
 }
-async function* runStream(registry, params) {
+async function* runStream(registry, params, defaults) {
   const agent = registry.resolveAgent(params.agent);
   const messages = buildMessages(agent, params);
   const tools = buildTools(registry, agent, params.context ?? {});
   const result = streamText({
-    model: resolveModel(agent),
+    model: resolveModel(agent, defaults),
     messages,
     tools,
     temperature: params.temperature ?? agent.temperature,
@@ -122,11 +149,21 @@ async function* runStream(registry, params) {
     stopWhen: ({ steps }) => steps.length >= (params.maxSteps ?? 8),
     providerOptions: agent.providerOptions
   });
+  const accumulatedUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+  const addUsage = (u) => {
+    if (!u) return;
+    accumulatedUsage.inputTokens += u.inputTokens ?? 0;
+    accumulatedUsage.outputTokens += u.outputTokens ?? 0;
+    accumulatedUsage.totalTokens += u.totalTokens ?? 0;
+  };
   for await (const part of result.fullStream) {
     switch (part.type) {
       case "text-delta":
         yield { type: "text-delta", text: part.text ?? part.delta ?? "" };
         break;
+      case "finish-step":
+        addUsage(part.usage);
+        break;
       case "tool-call":
         yield {
           type: "tool-call",
@@ -151,38 +188,42 @@ async function* runStream(registry, params) {
           error: part.error
         };
         break;
-      case "finish":
+      case "finish": {
+        const finalUsage = part.totalUsage ?? part.usage;
         yield {
           type: "finish",
           finishReason: part.finishReason,
           usage: {
-            inputTokens: part.usage?.inputTokens ?? 0,
-            outputTokens: part.usage?.outputTokens ?? 0,
-            totalTokens: part.usage?.totalTokens ?? 0
+            inputTokens: finalUsage?.inputTokens ?? accumulatedUsage.inputTokens,
+            outputTokens: finalUsage?.outputTokens ?? accumulatedUsage.outputTokens,
+            totalTokens: finalUsage?.totalTokens ?? accumulatedUsage.totalTokens
           }
         };
         break;
+      }
       case "error":
         yield { type: "error", error: part.error };
         break;
     }
   }
 }
-async function runObject(registry, params) {
+async function runObject(registry, params, defaults) {
   const agent = registry.resolveAgent(params.agent);
   const messages = buildMessages(agent, params);
-  const result = await generateObject({
-    model: resolveModel(agent),
+  const result = await generateText({
+    model: resolveModel(agent, defaults),
     messages,
-    schema: params.inputSchema,
-    schemaName: params.schemaName,
-    schemaDescription: params.schemaDescription,
+    output: Output.object({
+      schema: params.inputSchema,
+      name: params.schemaName,
+      description: params.schemaDescription
+    }),
     temperature: params.temperature ?? agent.temperature,
     maxOutputTokens: params.maxOutputTokens ?? agent.maxOutputTokens,
     providerOptions: agent.providerOptions
   });
   return {
-    object: result.object,
+    object: result.output,
     finishReason: result.finishReason ?? "stop",
     usage: {
       inputTokens: result.usage?.inputTokens ?? 0,
@@ -196,8 +237,10 @@ async function runObject(registry, params) {
 // src/client.ts
 var AiAgentsClient = class {
   registry;
-  constructor() {
+  defaults;
+  constructor(config) {
     this.registry = new Registry();
+    this.defaults = { apiKey: config?.apiKey, model: config?.model };
   }
   registerTool(tool2) {
     return this.registry.registerTool(tool2);
@@ -206,30 +249,32 @@ var AiAgentsClient = class {
     return this.registry.createAgent(definition);
   }
   async run(params) {
-    return run(this.registry, params);
+    return run(this.registry, params, this.defaults);
   }
   runStream(params) {
-    return runStream(this.registry, params);
+    return runStream(this.registry, params, this.defaults);
   }
   /**
    * Schema-constrained structured generation. Returns a validated, typed object
    * instead of free text. Single-shot (no tools). Added in 0.2.0.
    */
   async runObject(params) {
-    return runObject(this.registry, params);
+    return runObject(this.registry, params, this.defaults);
   }
   /** Direct access to the underlying registry for advanced introspection. */
   get raw() {
     return this.registry;
   }
 };
-function createClient() {
-  return new AiAgentsClient();
+function createClient(config) {
+  return new AiAgentsClient(config);
 }
 export {
   AiAgentsClient,
   Registry,
+  SUPPORTED_PROVIDERS,
   createClient,
+  resolveModelString,
   run,
   runObject,
   runStream,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@~lyre/ai-agents",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Multi-provider AI agents SDK for SvelteKit + Node. Thin agent/tool/run/runStream surface over the Vercel AI SDK — OpenAI, Anthropic, Google Gemini, Mistral, Cohere. Zod-typed tools, full streaming event surface, optional HTML sanitizer.",
   "type": "module",
   "sideEffects": false,
@@ -48,13 +48,18 @@
     "build": "tsup src/index.ts src/sanitize.ts --format esm --dts --clean",
     "check": "tsc --noEmit"
   },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^2.0.0",
+    "@ai-sdk/google": "^2.0.0",
+    "@ai-sdk/openai": "^2.0.0",
+    "@ai-sdk/xai": "^2.0.0",
+    "ai": "^6.0.0"
+  },
   "peerDependencies": {
-    "ai": "^6.0.0",
     "zod": "^3.23.0 || ^4.0.0"
   },
   "devDependencies": {
     "@types/node": "^22",
-    "ai": "^6.0.0",
     "tsup": "^8.3.5",
     "typescript": "^6.0.2",
     "zod": "^4.0.0"