@modelence/ai 0.1.5 → 0.1.6-dev.1

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-import * as ai from 'ai';
 import { generateText as generateText$1 } from 'ai';
 
 /**
@@ -6,18 +5,17 @@ import { generateText as generateText$1 } from 'ai';
  */
 type Provider = 'openai' | 'anthropic' | 'google';
 type OriginalGenerateTextParams = Parameters<typeof generateText$1>[0];
+type ModelenceGenerateTextOptions<T> = T extends unknown ? Omit<T, 'model'> & {
+    provider: Provider;
+    model: string;
+} : never;
 /**
  * Options for the Modelence generateText function.
  *
- * This interface extends all the standard AI SDK generateText options,
+ * This type extends all the standard AI SDK generateText options,
  * but replaces the model parameter with separate provider and model parameters.
  */
-interface GenerateTextOptions extends Omit<OriginalGenerateTextParams, 'model'> {
-    /** The AI provider name */
-    provider: Provider;
-    /** The specific model name */
-    model: string;
-}
+type GenerateTextOptions = ModelenceGenerateTextOptions<OriginalGenerateTextParams>;
 /**
  * Generates text using AI models with built-in Modelence configuration and telemetry.
  *
@@ -32,8 +30,8 @@ interface GenerateTextOptions extends Omit<OriginalGenerateTextParams, 'model'>
  * import { generateText } from '@modelence/ai';
  *
  * const response = await generateText({
- *   provider: 'openai',
- *   model: 'gpt-4o',
+ *   provider: 'anthropic',
+ *   model: 'claude-sonnet-4-6',
  *   messages: [
  *     { role: 'user', content: 'Write a haiku about programming' }
  *   ],
@@ -43,6 +41,6 @@ interface GenerateTextOptions extends Omit<OriginalGenerateTextParams, 'model'>
  * console.log(response.text);
  * ```
  */
-declare function generateText(options: GenerateTextOptions): Promise<ai.GenerateTextResult<ai.ToolSet, unknown>>;
+declare function generateText(options: GenerateTextOptions): Promise<Awaited<ReturnType<typeof generateText$1>>>;
 
 export { type GenerateTextOptions, generateText };

package/dist/index.js

@@ -1,2 +1,2 @@
-import {getConfig}from'modelence/server';import {startTransaction,captureError}from'modelence/telemetry';import {generateText}from'ai';import {createOpenAI}from'@ai-sdk/openai';import {createAnthropic}from'@ai-sdk/anthropic';import {createGoogleGenerativeAI}from'@ai-sdk/google';function l(e,t){switch(e){case "openai":return createOpenAI({apiKey:String(getConfig("_system.openai.apiKey"))})(t);case "anthropic":return createAnthropic({apiKey:String(getConfig("_system.anthropic.apiKey"))})(t);case "google":return createGoogleGenerativeAI({apiKey:String(getConfig("_system.gemini.apiKey"))})(t);default:throw new Error(`Unsupported provider: ${e}`)}}async function G(e){let{provider:t,model:n,...i}=e,o=startTransaction("ai","ai:generateText",{provider:t,model:n,messageCount:Array.isArray(e.messages)?e.messages.length:0,temperature:e.temperature});try{let r=await generateText({model:l(t,n),...i});return "setContext"in o?o.end("success",{context:{usage:{promptTokens:r.usage.promptTokens,completionTokens:r.usage.completionTokens,totalTokens:r.usage.totalTokens}}}):o.end("success"),r}catch(r){throw captureError(r),o.end("error"),r}}export{G as generateText};//# sourceMappingURL=index.js.map
+import {getConfig}from'modelence/server';import {startTransaction,captureError}from'modelence/telemetry';import {generateText}from'ai';import {createOpenAI}from'@ai-sdk/openai';import {createAnthropic}from'@ai-sdk/anthropic';import {createGoogleGenerativeAI}from'@ai-sdk/google';function l(e,r){switch(e){case "openai":return createOpenAI({apiKey:String(getConfig("_system.openai.apiKey"))})(r);case "anthropic":return createAnthropic({apiKey:String(getConfig("_system.anthropic.apiKey"))})(r);case "google":return createGoogleGenerativeAI({apiKey:String(getConfig("_system.gemini.apiKey"))})(r);default:throw new Error(`Unsupported provider: ${e}`)}}async function v(e){let{provider:r,model:a,...i}=e,s=l(r,a),n=startTransaction("ai","ai:generateText",{provider:r,model:a,messageCount:Array.isArray(e.messages)?e.messages.length:0,temperature:e.temperature});try{let t=await generateText({...i,model:s});return "setContext"in n?n.end("success",{context:{usage:{promptTokens:t.usage.inputTokens,completionTokens:t.usage.outputTokens,totalTokens:t.usage.totalTokens}}}):n.end("success"),t}catch(t){throw captureError(t),n.end("error"),t}}export{v as generateText};//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"names":["getProviderModel","provider","model","createOpenAI","getConfig","createAnthropic","createGoogleGenerativeAI","generateText","options","restOptions","transaction","startTransaction","result","originalGenerateText","error","captureError"],"mappings":"uRA4BA,SAASA,CAAAA,CAAiBC,EAAoBC,CAAe,CAAA,CAC3D,OAAQD,CAAU,EAChB,KAAK,QACH,CAAA,OAAOE,aAAa,CAClB,MAAA,CAAQ,OAAOC,SAAU,CAAA,uBAAuB,CAAC,CACnD,CAAC,EAAEF,CAAK,CAAA,CAEV,KAAK,WACH,CAAA,OAAOG,gBAAgB,CACrB,MAAA,CAAQ,OAAOD,SAAU,CAAA,0BAA0B,CAAC,CACtD,CAAC,EAAEF,CAAK,CAAA,CAEV,KAAK,QACH,CAAA,OAAOI,yBAAyB,CAC9B,MAAA,CAAQ,OAAOF,SAAU,CAAA,uBAAuB,CAAC,CACnD,CAAC,EAAEF,CAAK,CAAA,CAEV,QACE,MAAM,IAAI,MAAM,CAAyBD,sBAAAA,EAAAA,CAAQ,EAAE,CACvD,CACF,CA2BA,eAAsBM,CAAAA,CAAaC,EAA8B,CAC/D,GAAM,CAAE,QAAA,CAAAP,EAAU,KAAAC,CAAAA,CAAAA,CAAO,GAAGO,CAAY,CAAA,CAAID,EAEtCE,CAAcC,CAAAA,gBAAAA,CAAiB,KAAM,iBAAmB,CAAA,CAC5D,SAAAV,CACA,CAAA,KAAA,CAAAC,EACA,YAAc,CAAA,KAAA,CAAM,QAAQM,CAAQ,CAAA,QAAQ,EAAIA,CAAQ,CAAA,QAAA,CAAS,OAAS,CAC1E,CAAA,WAAA,CAAaA,EAAQ,WACvB,CAAC,EAED,GAAI,CACF,IAAMI,CAAS,CAAA,MAAMC,aAAqB,CACxC,KAAA,CAAOb,EAAiBC,CAAUC,CAAAA,CAAK,EACvC,GAAGO,CACL,CAAC,CAED,CAAA,OAAI,eAAgBC,CAClBA,CAAAA,CAAAA,CAAY,IAAI,SAAW,CAAA,CACzB,QAAS,CACP,KAAA,CAAO,CACL,YAAcE,CAAAA,CAAAA,CAAO,MAAM,YAC3B,CAAA,gBAAA,CAAkBA,EAAO,KAAM,CAAA,gBAAA,CAC/B,YAAaA,CAAO,CAAA,KAAA,CAAM,WAC5B,CACF,CACF,CAAC,CAIDF,CAAAA,CAAAA,CAAY,IAAI,SAAS,CAAA,CAEpBE,CACT,CAASE,MAAAA,CAAAA,CAAO,CACd,MAAAC,YAAAA,CAAaD,CAAc,CAC3BJ,CAAAA,CAAAA,CAAY,IAAI,OAAO,CAAA,CACjBI,CACR,CACF","file":"index.js","sourcesContent":["import { getConfig } from 'modelence/server';\nimport { startTransaction, captureError } from 'modelence/telemetry';\nimport { generateText as originalGenerateText } from 'ai';\nimport { createOpenAI } from '@ai-sdk/openai';\nimport { createAnthropic } from '@ai-sdk/anthropic';\nimport { createGoogleGenerativeAI } from '@ai-sdk/google';\n\n/**\n * Supported AI providers for text generation.\n */\ntype Provider = 'openai' | 'anthropic' | 'google';\n\n// Extract the original generateText parameters and override the model property\ntype OriginalGenerateTextParams = Parameters<typeof originalGenerateText>[0];\n\n/**\n * Options for the Modelence generateText function.\n * \n * This interface extends all the standard AI SDK generateText options,\n * but replaces the model parameter with separate provider and model parameters.\n */\nexport interface GenerateTextOptions extends Omit<OriginalGenerateTextParams, 'model'> {\n  /** The AI provider name */\n  provider: Provider;\n  /** The specific model name */\n  model: string;\n}\n\nfunction getProviderModel(provider: Provider, model: string) {\n  switch (provider) {\n    case 'openai':\n      return createOpenAI({\n        apiKey: String(getConfig('_system.openai.apiKey')),\n      })(model);\n    \n    case 'anthropic':\n      return createAnthropic({\n        apiKey: String(getConfig('_system.anthropic.apiKey')),\n      })(model);\n    \n    case 'google':\n      return createGoogleGenerativeAI({\n        apiKey: String(getConfig('_system.gemini.apiKey')),\n      })(model);\n    \n    default:\n      throw new Error(`Unsupported provider: ${provider}`);\n  }\n}\n\n/**\n * Generates text using AI models with built-in Modelence configuration and telemetry.\n * \n * This is a wrapper around the AI SDK's generateText function that automatically\n * configures providers using Modelence's server-side configuration system.\n * \n * @param options - Configuration options for text generation\n * @returns A promise that resolves to the generated text result\n * \n * @example\n * ```typescript\n * import { generateText } from '@modelence/ai';\n * \n * const response = await generateText({\n *   provider: 'openai',\n *   model: 'gpt-4o',\n *   messages: [\n *     { role: 'user', content: 'Write a haiku about programming' }\n *   ],\n *   temperature: 0.7\n * });\n * \n * console.log(response.text);\n * ```\n */\nexport async function generateText(options: GenerateTextOptions) {\n  const { provider, model, ...restOptions } = options;\n  \n  const transaction = startTransaction('ai', 'ai:generateText', {\n    provider, \n    model,\n    messageCount: Array.isArray(options.messages) ? options.messages.length : 0,\n    temperature: options.temperature\n  });\n\n  try {\n    const result = await originalGenerateText({\n      model: getProviderModel(provider, model),\n      ...restOptions,\n    });\n    \n    if ('setContext' in transaction) {\n      transaction.end('success', {\n        context: {\n          usage: {\n            promptTokens: result.usage.promptTokens,\n            completionTokens: result.usage.completionTokens,\n            totalTokens: result.usage.totalTokens,\n          }\n        }\n      });\n    } else {\n      // Backwards compatibility for older versions of Modelence\n      // @ts-ignore\n      transaction.end('success');\n    }\n    return result;\n  } catch (error) {\n    captureError(error as Error);\n    transaction.end('error');\n    throw error;\n  }\n}\n"]}
+{"version":3,"sources":["../src/index.ts"],"names":["getProviderModel","provider","model","createOpenAI","getConfig","createAnthropic","createGoogleGenerativeAI","generateText","options","restOptions","providerModel","transaction","startTransaction","result","originalGenerateText","error","captureError"],"mappings":"uRA6BA,SAASA,CAAAA,CAAiBC,CAAAA,CAAoBC,EAAe,CAC3D,OAAQD,GACN,KAAK,SACH,OAAOE,YAAAA,CAAa,CAClB,MAAA,CAAQ,MAAA,CAAOC,UAAU,uBAAuB,CAAC,CACnD,CAAC,CAAA,CAAEF,CAAK,CAAA,CAEV,KAAK,YACH,OAAOG,eAAAA,CAAgB,CACrB,MAAA,CAAQ,MAAA,CAAOD,UAAU,0BAA0B,CAAC,CACtD,CAAC,CAAA,CAAEF,CAAK,CAAA,CAEV,KAAK,SACH,OAAOI,wBAAAA,CAAyB,CAC9B,MAAA,CAAQ,MAAA,CAAOF,UAAU,uBAAuB,CAAC,CACnD,CAAC,CAAA,CAAEF,CAAK,CAAA,CAEV,QACE,MAAM,IAAI,KAAA,CAAM,yBAAyBD,CAAQ,CAAA,CAAE,CACvD,CACF,CA2BA,eAAsBM,CAAAA,CACpBC,CAAAA,CAC2D,CAC3D,GAAM,CAAE,SAAAP,CAAAA,CAAU,KAAA,CAAAC,EAAO,GAAGO,CAAY,EAAID,CAAAA,CACtCE,CAAAA,CAAgBV,EAAiBC,CAAAA,CAAUC,CAAK,EAEhDS,CAAAA,CAAcC,gBAAAA,CAAiB,KAAM,iBAAA,CAAmB,CAC5D,SAAAX,CAAAA,CACA,KAAA,CAAAC,EACA,YAAA,CAAc,KAAA,CAAM,QAAQM,CAAAA,CAAQ,QAAQ,EAAIA,CAAAA,CAAQ,QAAA,CAAS,OAAS,CAAA,CAC1E,WAAA,CAAaA,EAAQ,WACvB,CAAC,EAED,GAAI,CACF,IAAMK,CAAAA,CAAS,MAAMC,aAAqB,CACxC,GAAGL,EACH,KAAA,CAAOC,CACT,CAAC,CAAA,CAED,OAAI,eAAgBC,CAAAA,CAClBA,CAAAA,CAAY,IAAI,SAAA,CAAW,CACzB,QAAS,CACP,KAAA,CAAO,CACL,YAAA,CAAcE,CAAAA,CAAO,MAAM,WAAA,CAC3B,gBAAA,CAAkBA,EAAO,KAAA,CAAM,YAAA,CAC/B,YAAaA,CAAAA,CAAO,KAAA,CAAM,WAC5B,CACF,CACF,CAAC,CAAA,CAIDF,CAAAA,CAAY,IAAI,SAAS,CAAA,CAEpBE,CACT,CAAA,MAASE,CAAAA,CAAO,CACd,MAAAC,YAAAA,CAAaD,CAAc,CAAA,CAC3BJ,CAAAA,CAAY,IAAI,OAAO,CAAA,CACjBI,CACR,CACF","file":"index.js","sourcesContent":["import { getConfig } from 'modelence/server';\nimport { startTransaction, captureError } from 'modelence/telemetry';\nimport { generateText as originalGenerateText } from 'ai';\nimport { createOpenAI } from '@ai-sdk/openai';\nimport { createAnthropic } from '@ai-sdk/anthropic';\nimport { createGoogleGenerativeAI } from '@ai-sdk/google';\n\n/**\n * Supported AI providers for text generation.\n */\ntype Provider = 'openai' | 'anthropic' | 'google';\n\n// Extract the original generateText parameters and override the model property\ntype OriginalGenerateTextParams = Parameters<typeof originalGenerateText>[0];\ntype ModelenceGenerateTextOptions<T> = T extends unknown\n  ? Omit<T, 'model'> & {\n      provider: Provider;\n      model: string;\n    }\n  : never;\n\n/**\n * Options for the Modelence generateText function.\n * \n * This type extends all the standard AI SDK generateText options,\n * but replaces the model parameter with separate provider and model parameters.\n */\nexport type GenerateTextOptions = ModelenceGenerateTextOptions<OriginalGenerateTextParams>;\n\nfunction getProviderModel(provider: Provider, model: string) {\n  switch (provider) {\n    case 'openai':\n      return createOpenAI({\n        apiKey: String(getConfig('_system.openai.apiKey')),\n      })(model);\n    \n    case 'anthropic':\n      return createAnthropic({\n        apiKey: String(getConfig('_system.anthropic.apiKey')),\n      })(model);\n    \n    case 'google':\n      return createGoogleGenerativeAI({\n        apiKey: String(getConfig('_system.gemini.apiKey')),\n      })(model);\n    \n    default:\n      throw new Error(`Unsupported provider: ${provider}`);\n  }\n}\n\n/**\n * Generates text using AI models with built-in Modelence configuration and telemetry.\n * \n * This is a wrapper around the AI SDK's generateText function that automatically\n * configures providers using Modelence's server-side configuration system.\n * \n * @param options - Configuration options for text generation\n * @returns A promise that resolves to the generated text result\n * \n * @example\n * ```typescript\n * import { generateText } from '@modelence/ai';\n * \n * const response = await generateText({\n *   provider: 'anthropic',\n *   model: 'claude-sonnet-4-6',\n *   messages: [\n *     { role: 'user', content: 'Write a haiku about programming' }\n *   ],\n *   temperature: 0.7\n * });\n * \n * console.log(response.text);\n * ```\n */\nexport async function generateText(\n  options: GenerateTextOptions\n): Promise<Awaited<ReturnType<typeof originalGenerateText>>> {\n  const { provider, model, ...restOptions } = options;\n  const providerModel = getProviderModel(provider, model);\n  \n  const transaction = startTransaction('ai', 'ai:generateText', {\n    provider, \n    model,\n    messageCount: Array.isArray(options.messages) ? options.messages.length : 0,\n    temperature: options.temperature\n  });\n\n  try {\n    const result = await originalGenerateText({\n      ...restOptions,\n      model: providerModel,\n    });\n    \n    if ('setContext' in transaction) {\n      transaction.end('success', {\n        context: {\n          usage: {\n            promptTokens: result.usage.inputTokens,\n            completionTokens: result.usage.outputTokens,\n            totalTokens: result.usage.totalTokens,\n          }\n        }\n      });\n    } else {\n      // Backwards compatibility for older versions of Modelence\n      // @ts-ignore\n      transaction.end('success');\n    }\n    return result;\n  } catch (error) {\n    captureError(error as Error);\n    transaction.end('error');\n    throw error;\n  }\n}\n"]}

package/jest.config.js

@@ -0,0 +1,17 @@
+export default {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
+  testMatch: ['**/?(*.)+(spec|test).ts'],
+  moduleFileExtensions: ['ts', 'js', 'json', 'node'],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts',
+    '!src/**/*.test.ts',
+    '!src/**/*.spec.ts',
+  ],
+  transform: {
+    '^.+\\.ts$': ['ts-jest', { useESM: true }],
+  },
+  extensionsToTreatAsEsm: ['.ts'],
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@modelence/ai",
-  "version": "0.1.5",
+  "version": "0.1.6-dev.1",
   "description": "Modelence AI engine",
   "exports": {
     ".": {
@@ -14,6 +14,9 @@
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest",
+    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch",
+    "test:coverage": "NODE_OPTIONS=--experimental-vm-modules jest --coverage",
     "prepublishOnly": "npm run build"
   },
   "repository": {
@@ -24,17 +27,20 @@
   "author": "Modelence",
   "license": "SEE LICENSE IN LICENSE",
   "dependencies": {
-    "@ai-sdk/anthropic": "^1.2.12",
-    "@ai-sdk/google": "^1.2.19",
-    "@ai-sdk/openai": "^1.3.22",
-    "ai": "^4.3.16"
+    "@ai-sdk/anthropic": "^3.0.45",
+    "@ai-sdk/google": "^3.0.29",
+    "@ai-sdk/openai": "^3.0.29",
+    "ai": "^6.0.90"
   },
   "peerDependencies": {
     "modelence": "*"
   },
   "devDependencies": {
-    "modelence": "^0.5.9",
-    "tsup": "^8.3.6",
-    "typescript": "^5.7.2"
+    "@types/jest": "^30.0.0",
+    "jest": "^30.2.0",
+    "modelence": "^0.12.0",
+    "ts-jest": "^29.4.6",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
   }
 }

package/src/index.test.ts

@@ -0,0 +1,190 @@
+import { beforeEach, describe, expect, jest, test } from '@jest/globals';
+
+const mockGetConfig = jest.fn<(key: string) => unknown>();
+const mockStartTransaction = jest.fn();
+const mockCaptureError = jest.fn();
+const mockGenerateText = jest.fn();
+
+const mockOpenAIModelFactory = jest.fn();
+const mockAnthropicModelFactory = jest.fn();
+const mockGoogleModelFactory = jest.fn();
+
+const mockCreateOpenAI = jest.fn(() => mockOpenAIModelFactory);
+const mockCreateAnthropic = jest.fn(() => mockAnthropicModelFactory);
+const mockCreateGoogleGenerativeAI = jest.fn(() => mockGoogleModelFactory);
+
+jest.unstable_mockModule('modelence/server', () => ({
+  getConfig: mockGetConfig,
+}));
+
+jest.unstable_mockModule('modelence/telemetry', () => ({
+  startTransaction: mockStartTransaction,
+  captureError: mockCaptureError,
+}));
+
+jest.unstable_mockModule('ai', () => ({
+  generateText: mockGenerateText,
+}));
+
+jest.unstable_mockModule('@ai-sdk/openai', () => ({
+  createOpenAI: mockCreateOpenAI,
+}));
+
+jest.unstable_mockModule('@ai-sdk/anthropic', () => ({
+  createAnthropic: mockCreateAnthropic,
+}));
+
+jest.unstable_mockModule('@ai-sdk/google', () => ({
+  createGoogleGenerativeAI: mockCreateGoogleGenerativeAI,
+}));
+
+const { generateText } = await import('./index');
+
+describe('@modelence/ai generateText', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockGetConfig.mockImplementation((key: string) => {
+      const values: Record<string, string> = {
+        '_system.openai.apiKey': 'openai-key',
+        '_system.anthropic.apiKey': 'anthropic-key',
+        '_system.gemini.apiKey': 'google-key',
+      };
+      return values[key];
+    });
+  });
+
+  test('uses OpenAI provider, forwards options, and ends transaction with usage context', async () => {
+    const transaction = {
+      end: jest.fn(),
+      setContext: jest.fn(),
+    };
+    mockStartTransaction.mockReturnValue(transaction);
+
+    const modelInstance = { provider: 'openai', model: 'gpt-4o' };
+    mockOpenAIModelFactory.mockReturnValue(modelInstance);
+
+    const result = {
+      text: 'hello',
+      usage: {
+        promptTokens: 11,
+        completionTokens: 7,
+        totalTokens: 18,
+      },
+    };
+    mockGenerateText.mockResolvedValue(result as never);
+
+    const options = {
+      provider: 'openai',
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: 'Say hello' }],
+      temperature: 0.4,
+    };
+
+    const response = await generateText(options as never);
+
+    expect(mockStartTransaction).toHaveBeenCalledWith('ai', 'ai:generateText', {
+      provider: 'openai',
+      model: 'gpt-4o',
+      messageCount: 1,
+      temperature: 0.4,
+    });
+    expect(mockGetConfig).toHaveBeenCalledWith('_system.openai.apiKey');
+    expect(mockCreateOpenAI).toHaveBeenCalledWith({ apiKey: 'openai-key' });
+    expect(mockOpenAIModelFactory).toHaveBeenCalledWith('gpt-4o');
+    expect(mockGenerateText).toHaveBeenCalledWith({
+      model: modelInstance,
+      messages: [{ role: 'user', content: 'Say hello' }],
+      temperature: 0.4,
+    });
+    expect(transaction.end).toHaveBeenCalledWith('success', {
+      context: {
+        usage: {
+          promptTokens: 11,
+          completionTokens: 7,
+          totalTokens: 18,
+        },
+      },
+    });
+    expect(mockCaptureError).not.toHaveBeenCalled();
+    expect(response).toBe(result);
+  });
+
+  test('supports older transaction API without setContext', async () => {
+    const transaction = {
+      end: jest.fn(),
+    };
+    mockStartTransaction.mockReturnValue(transaction);
+
+    const modelInstance = { provider: 'anthropic', model: 'claude-3-haiku' };
+    mockAnthropicModelFactory.mockReturnValue(modelInstance);
+
+    mockGenerateText.mockResolvedValue({
+      text: 'ok',
+      usage: {
+        promptTokens: 3,
+        completionTokens: 2,
+        totalTokens: 5,
+      },
+    } as never);
+
+    await generateText({
+      provider: 'anthropic',
+      model: 'claude-3-haiku',
+      prompt: 'Hello',
+    } as never);
+
+    expect(mockGetConfig).toHaveBeenCalledWith('_system.anthropic.apiKey');
+    expect(mockCreateAnthropic).toHaveBeenCalledWith({ apiKey: 'anthropic-key' });
+    expect(mockAnthropicModelFactory).toHaveBeenCalledWith('claude-3-haiku');
+    expect(transaction.end).toHaveBeenCalledWith('success');
+    expect(transaction.end).toHaveBeenCalledTimes(1);
+  });
+
+  test('captures and rethrows provider/model errors', async () => {
+    const transaction = {
+      end: jest.fn(),
+      setContext: jest.fn(),
+    };
+    mockStartTransaction.mockReturnValue(transaction);
+
+    const modelInstance = { provider: 'google', model: 'gemini-1.5-pro' };
+    mockGoogleModelFactory.mockReturnValue(modelInstance);
+
+    const error = new Error('generation failed');
+    mockGenerateText.mockRejectedValue(error);
+
+    await expect(
+      generateText({
+        provider: 'google',
+        model: 'gemini-1.5-pro',
+        prompt: 'Hello',
+      } as never)
+    ).rejects.toThrow('generation failed');
+
+    expect(mockGetConfig).toHaveBeenCalledWith('_system.gemini.apiKey');
+    expect(mockCreateGoogleGenerativeAI).toHaveBeenCalledWith({ apiKey: 'google-key' });
+    expect(mockGoogleModelFactory).toHaveBeenCalledWith('gemini-1.5-pro');
+    expect(mockCaptureError).toHaveBeenCalledWith(error);
+    expect(transaction.end).toHaveBeenCalledWith('error');
+  });
+
+  test('captures unsupported provider failures and does not call AI SDK', async () => {
+    const transaction = {
+      end: jest.fn(),
+      setContext: jest.fn(),
+    };
+    mockStartTransaction.mockReturnValue(transaction);
+
+    await expect(
+      generateText({
+        provider: 'invalid',
+        model: 'some-model',
+        prompt: 'Hello',
+      } as never)
+    ).rejects.toThrow('Unsupported provider: invalid');
+
+    expect(mockGenerateText).not.toHaveBeenCalled();
+    expect(mockCaptureError).toHaveBeenCalledWith(expect.any(Error));
+    expect(transaction.end).toHaveBeenCalledWith('error');
+  });
+});

package/src/index.ts

@@ -12,19 +12,20 @@ type Provider = 'openai' | 'anthropic' | 'google';
 
 // Extract the original generateText parameters and override the model property
 type OriginalGenerateTextParams = Parameters<typeof originalGenerateText>[0];
+type ModelenceGenerateTextOptions<T> = T extends unknown
+  ? Omit<T, 'model'> & {
+      provider: Provider;
+      model: string;
+    }
+  : never;
 
 /**
  * Options for the Modelence generateText function.
  * 
- * This interface extends all the standard AI SDK generateText options,
+ * This type extends all the standard AI SDK generateText options,
  * but replaces the model parameter with separate provider and model parameters.
  */
-export interface GenerateTextOptions extends Omit<OriginalGenerateTextParams, 'model'> {
-  /** The AI provider name */
-  provider: Provider;
-  /** The specific model name */
-  model: string;
-}
+export type GenerateTextOptions = ModelenceGenerateTextOptions<OriginalGenerateTextParams>;
 
 function getProviderModel(provider: Provider, model: string) {
   switch (provider) {
@@ -62,8 +63,8 @@ function getProviderModel(provider: Provider, model: string) {
  * import { generateText } from '@modelence/ai';
  * 
  * const response = await generateText({
- *   provider: 'openai',
- *   model: 'gpt-4o',
+ *   provider: 'anthropic',
+ *   model: 'claude-sonnet-4-6',
  *   messages: [
  *     { role: 'user', content: 'Write a haiku about programming' }
  *   ],
@@ -73,8 +74,11 @@ function getProviderModel(provider: Provider, model: string) {
  * console.log(response.text);
  * ```
  */
-export async function generateText(options: GenerateTextOptions) {
+export async function generateText(
+  options: GenerateTextOptions
+): Promise<Awaited<ReturnType<typeof originalGenerateText>>> {
   const { provider, model, ...restOptions } = options;
+  const providerModel = getProviderModel(provider, model);
   
   const transaction = startTransaction('ai', 'ai:generateText', {
     provider, 
@@ -85,16 +89,16 @@ export async function generateText(options: GenerateTextOptions) {
 
   try {
     const result = await originalGenerateText({
-      model: getProviderModel(provider, model),
       ...restOptions,
+      model: providerModel,
     });
     
     if ('setContext' in transaction) {
       transaction.end('success', {
         context: {
           usage: {
-            promptTokens: result.usage.promptTokens,
-            completionTokens: result.usage.completionTokens,
+            promptTokens: result.usage.inputTokens,
+            completionTokens: result.usage.outputTokens,
             totalTokens: result.usage.totalTokens,
           }
         }