@outputai/llm 0.6.1-next.fc6a93e.0 → 0.7.0

package/src/ai_provider.js

@@ -0,0 +1,86 @@
+import { FatalError, ValidationError, z } from '@outputai/core';
+import { Agent, fetch } from 'undici';
+// providers
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createAzure } from '@ai-sdk/azure';
+import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createPerplexity } from '@ai-sdk/perplexity';
+import { createVertex } from '@ai-sdk/google-vertex';
+
+/** This custom dispatcher has longer timeouts */
+const customDispatcher = new Agent( {
+  headersTimeout: 15 * 60 * 1000, // 15 min
+  bodyTimeout: 15 * 60 * 1000
+} );
+
+/** This custom fetch instance uses the custom dispatcher */
+const customFetch = ( input, init ) => fetch( input, { dispatcher: customDispatcher, ...init } );
+
+/** Available provider to initialize. */
+const providerInitializers = {
+  anthropic: createAnthropic,
+  azure: createAzure,
+  bedrock: createAmazonBedrock,
+  openai: createOpenAI,
+  perplexity: createPerplexity,
+  vertex: createVertex
+};
+
+/** Providers already initialized due usage */
+const initializedProviders = {};
+
+/** Providers registered by the user */
+const registeredProviders = {};
+
+/**
+ * Get all available provider names, including shipped and registered.
+ * @returns {string[]} Provider names
+ */
+export const getProviderNames = () =>
+  new Set( Object.keys( providerInitializers ).concat( Object.keys( registeredProviders ) ) ).values().toArray();
+
+const registerProviderSchema = z.object( {
+  name: z.string().min( 1, 'Provider name must be a non-empty string' ),
+  providerFn: z.function()
+} );
+
+/**
+ * Register or override an AI SDK provider factory by name.
+ * @param {string} name - Provider name used in prompt frontmatter
+ * @param {Function} providerFn - Factory function that receives a model id
+ * @returns {void}
+ */
+export function registerProvider( name, providerFn ) {
+  const result = registerProviderSchema.safeParse( { name, providerFn } );
+  if ( !result.success ) {
+    throw new ValidationError( `Invalid provider registration: ${z.prettifyError( result.error )}` );
+  }
+  registeredProviders[name] = providerFn;
+}
+
+/**
+ * Return a provider by its name.
+ * Look for registered providers first.
+ * If none, looks for initialized providers.
+ * Finally, looks for available provider initializers, and if found, init it.
+ *
+ * @param {string} name
+ * @returns {object} provider
+ */
+export const getProvider = name => {
+  const provider = registeredProviders[name] ?? initializedProviders[name];
+
+  if ( provider ) {
+    return provider;
+  }
+  if ( providerInitializers[name] ) {
+    try {
+      return initializedProviders[name] = providerInitializers[name]( { fetch: customFetch } );
+    } catch ( error ) {
+      throw new FatalError( `Failed to initialize provider "${name}": ${error.message}`, { cause: error } );
+    }
+  }
+
+  throw new FatalError( `Unsupported provider "${name}"` );
+};

package/src/ai_provider.spec.js

@@ -0,0 +1,147 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const SHIPPED_PROVIDERS = [
+  { name: 'anthropic', pkg: '@ai-sdk/anthropic', exportName: 'createAnthropic' },
+  { name: 'azure', pkg: '@ai-sdk/azure', exportName: 'createAzure' },
+  { name: 'bedrock', pkg: '@ai-sdk/amazon-bedrock', exportName: 'createAmazonBedrock' },
+  { name: 'openai', pkg: '@ai-sdk/openai', exportName: 'createOpenAI' },
+  { name: 'perplexity', pkg: '@ai-sdk/perplexity', exportName: 'createPerplexity' },
+  { name: 'vertex', pkg: '@ai-sdk/google-vertex', exportName: 'createVertex' }
+];
+
+const makeProviderModules = () => Object.fromEntries(
+  SHIPPED_PROVIDERS.map( ( { name, pkg, exportName } ) => [
+    pkg,
+    {
+      [exportName]: vi.fn( options => ( { name, options } ) )
+    }
+  ] )
+);
+
+const importWithMockedProviders = async ( modules = makeProviderModules() ) => {
+  await vi.resetModules();
+
+  for ( const { pkg, exportName } of SHIPPED_PROVIDERS ) {
+    vi.doMock( pkg, () => ( {
+      [exportName]: modules[pkg][exportName]
+    } ) );
+  }
+
+  return {
+    modules,
+    ...( await import( './ai_provider.js' ) )
+  };
+};
+
+afterEach( () => {
+  for ( const { pkg } of SHIPPED_PROVIDERS ) {
+    vi.doUnmock( pkg );
+  }
+  vi.resetModules();
+  vi.restoreAllMocks();
+} );
+
+describe( 'getProvider', () => {
+  it( 'does not initialize shipped providers on import', async () => {
+    const { modules } = await importWithMockedProviders();
+
+    for ( const { pkg, exportName } of SHIPPED_PROVIDERS ) {
+      expect( modules[pkg][exportName] ).not.toHaveBeenCalled();
+    }
+  } );
+
+  it( 'initializes each shipped provider with custom fetch when requested', async () => {
+    const { modules, getProvider } = await importWithMockedProviders();
+
+    for ( const { name, pkg, exportName } of SHIPPED_PROVIDERS ) {
+      const provider = getProvider( name );
+
+      expect( provider ).toMatchObject( { name, options: { fetch: expect.any( Function ) } } );
+      expect( modules[pkg][exportName] ).toHaveBeenCalledWith( { fetch: expect.any( Function ) } );
+    }
+  } );
+
+  it( 'can import and initialize all installed shipped providers', async () => {
+    const { getProvider } = await import( './ai_provider.js' );
+
+    for ( const { name } of SHIPPED_PROVIDERS ) {
+      expect( getProvider( name ) ).toEqual( expect.any( Function ) );
+    }
+  } );
+
+  it( 'caches initialized providers', async () => {
+    const { modules, getProvider } = await importWithMockedProviders();
+
+    const first = getProvider( 'openai' );
+    const second = getProvider( 'openai' );
+
+    expect( second ).toBe( first );
+    expect( modules['@ai-sdk/openai'].createOpenAI ).toHaveBeenCalledTimes( 1 );
+  } );
+
+  it( 'uses registered providers before shipped providers', async () => {
+    const { modules, getProvider, registerProvider } = await importWithMockedProviders();
+    const customProvider = vi.fn( model => ( { provider: 'custom', model } ) );
+
+    registerProvider( 'openai', customProvider );
+
+    expect( getProvider( 'openai' ) ).toBe( customProvider );
+    expect( modules['@ai-sdk/openai'].createOpenAI ).not.toHaveBeenCalled();
+  } );
+
+  it( 'throws FatalError for unsupported providers', async () => {
+    const { getProvider } = await importWithMockedProviders();
+
+    expect( () => getProvider( 'not-real' ) ).toThrow( 'Unsupported provider "not-real"' );
+  } );
+
+  it( 'throws a friendly error when provider initialization fails', async () => {
+    const modules = makeProviderModules();
+    modules['@ai-sdk/openai'].createOpenAI.mockImplementation( () => {
+      throw new Error( 'Missing OpenAI API key' );
+    } );
+    const { getProvider } = await importWithMockedProviders( modules );
+
+    expect( () => getProvider( 'openai' ) ).toThrow(
+      'Failed to initialize provider "openai": Missing OpenAI API key'
+    );
+  } );
+} );
+
+describe( 'registerProvider', () => {
+  it( 'registers custom providers', async () => {
+    const { getProvider, getProviderNames, registerProvider } = await importWithMockedProviders();
+    const customProvider = vi.fn();
+
+    registerProvider( 'custom', customProvider );
+
+    expect( getProvider( 'custom' ) ).toBe( customProvider );
+    expect( getProviderNames() ).toContain( 'custom' );
+  } );
+
+  it( 'validates provider registration arguments', async () => {
+    const { registerProvider } = await importWithMockedProviders();
+
+    expect( () => registerProvider( '', vi.fn() ) ).toThrow( 'Provider name must be a non-empty string' );
+    expect( () => registerProvider( 'custom', 'not-a-function' ) ).toThrow( 'expected function, received string' );
+  } );
+} );
+
+describe( 'getProviderNames', () => {
+  it( 'returns shipped and registered provider names without duplicates', async () => {
+    const { getProviderNames, registerProvider } = await importWithMockedProviders();
+
+    registerProvider( 'custom', vi.fn() );
+    registerProvider( 'openai', vi.fn() );
+
+    expect( getProviderNames() ).toEqual( [
+      'anthropic',
+      'azure',
+      'bedrock',
+      'openai',
+      'perplexity',
+      'vertex',
+      'custom'
+    ] );
+  } );
+} );

package/src/index.d.ts

@@ -6,6 +6,7 @@ import type {
   StreamTextResult as AIStreamTextResult,
   ToolLoopAgent as AIToolLoopAgent,
   ToolSet,
+  ModelMessage,
   StreamTextOnFinishCallback,
   generateText as aiGenerateText,
   streamText as aiStreamText,
@@ -40,11 +41,6 @@ export type {
 // Re-export the tool helper function, Output, smoothStream, stop condition helpers, and jsonSchema
 export { tool, Output, smoothStream, stepCountIs, hasToolCall, jsonSchema } from 'ai';
 
-// Web search tool factories
-export { tavilySearch, tavilyExtract, tavilyCrawl, tavilyMap } from '@tavily/ai-sdk';
-export { webSearch as exaSearch } from '@exalabs/ai-sdk';
-export { perplexitySearch } from '@perplexity-ai/ai-sdk';
-
 /**
  * Represents a single message in a prompt conversation.
  *
@@ -171,11 +167,40 @@ export type SkillsArg<Input = unknown> = Skill[] |
   ( ( input: Input ) => Skill[] | Promise<Skill[]> );
 
 /** Prompt-owned AI SDK fields supplied by Output prompt files. */
-type PromptOwnedTextOptions = 'model' | 'messages' | 'prompt';
+type PromptOwnedTextOptions = 'model' | 'messages' | 'prompt' | 'tools';
 type AnyAiOutput = AIOutputNamespace.Output<unknown, unknown, unknown>;
+type CompatibleToolFunction = ( ...args: never[] ) => unknown | PromiseLike<unknown>;
+type CompatibleApprovalFunction = ( ...args: never[] ) => boolean | PromiseLike<boolean>;
+
+/**
+ * Structurally-compatible AI SDK tool shape.
+ *
+ * This intentionally avoids referencing AI SDK's concrete `Tool` schema types so tools
+ * from packages resolved with a different Zod peer instance remain assignable.
+ */
+export type CompatibleTool = {
+  description?: string;
+  title?: string;
+  providerOptions?: Record<string, unknown>;
+  inputSchema?: unknown;
+  parameters?: unknown;
+  execute?: CompatibleToolFunction;
+  onInputStart?: CompatibleToolFunction;
+  onInputDelta?: CompatibleToolFunction;
+  onInputAvailable?: CompatibleToolFunction;
+  needsApproval?: boolean | CompatibleApprovalFunction;
+} & (
+  { inputSchema: unknown } |
+  { parameters: unknown } |
+  { execute: CompatibleToolFunction }
+);
+
+/** AI SDK tools accepted by Output APIs without requiring one exact Zod peer instance. */
+export type CompatibleToolSet = Record<string, CompatibleTool>;
 
 /**
  * AI SDK options accepted by generateText, with prompt-owned fields supplied by Output prompt files.
+ * `tools` is accepted separately as {@link CompatibleToolSet} to support third-party tool packages.
  *
  * @typeParam Tools - The tools available for the model to call
  */
@@ -186,6 +211,7 @@ export type GenerateTextAiSdkOptions<
 
 /**
  * AI SDK options accepted by streamText, with prompt-owned fields supplied by Output prompt files.
+ * `tools` is accepted separately as {@link CompatibleToolSet} to support third-party tool packages.
  *
  * @typeParam Tools - The tools available for the model to call
  */
@@ -205,7 +231,8 @@ type GenerateImagePromptWithImages = Exclude<GenerateImagePrompt, string>;
 type GenerateImageInput = GenerateImagePromptWithImages['images'][number];
 
 /** Agent {@link Agent.stream} options: same as AI SDK plus wrapped `onFinish` (adds `cost`). */
-export type OutputAgentStreamParameters = Omit<AgentStreamParameters<never, ToolSet>, 'onFinish'> & {
+export type OutputAgentStreamParameters = Omit<AgentStreamParameters<never, ToolSet>, 'onFinish' | 'tools'> & {
+  tools?: CompatibleToolSet;
   onFinish?: WrappedStreamTextOnFinishCallback<ToolSet>;
 };
 
@@ -224,7 +251,7 @@ export type OutputAgentConstructorParameters<
   /** Static skill packages made available to the LLM */
   skills?: Skill[];
   /** AI SDK tools available during the reasoning loop */
-  tools?: ConstructorParameters<typeof AIToolLoopAgent>[0]['tools'];
+  tools?: CompatibleToolSet;
   /** Maximum tool-loop iterations when stopWhen is not specified (default: 10) */
   maxSteps?: number;
   /** Pluggable conversation store — opt-in, stateless by default */
@@ -232,7 +259,9 @@ export type OutputAgentConstructorParameters<
 };
 
 /** Agent generate options accepted by the underlying AI SDK agent. */
-export type OutputAgentGenerateParameters = AgentCallParameters<never, ToolSet>;
+export type OutputAgentGenerateParameters = Omit<AgentCallParameters<never, ToolSet>, 'tools'> & {
+  tools?: CompatibleToolSet;
+};
 
 /** Parameters accepted by {@link generateText}. */
 export type GenerateTextParameters<
@@ -249,6 +278,8 @@ export type GenerateTextParameters<
   skills?: SkillsArg<Record<string, string | number | boolean> | undefined>;
   /** Used to create a default `stepCountIs(maxSteps)` when tools are present and `stopWhen` is omitted */
   maxSteps?: number;
+  /** AI SDK tools, accepted structurally to tolerate different Zod peer versions. */
+  tools?: CompatibleToolSet;
 } & GenerateTextAiSdkOptions<Tools, OutputSpec>;
 
 /** Parameters accepted by {@link streamText}. */
@@ -266,6 +297,8 @@ export type StreamTextParameters<
   skills?: Skill[] | ( ( input: Record<string, string | number | boolean> | undefined ) => Skill[] );
   /** Used to create a default `stepCountIs(maxSteps)` when tools are present and `stopWhen` is omitted */
   maxSteps?: number;
+  /** AI SDK tools, accepted structurally to tolerate different Zod peer versions. */
+  tools?: CompatibleToolSet;
   /** Callback when stream finishes. Receives the wrapped event with optional `cost`. */
   onFinish?: WrappedStreamTextOnFinishCallback<Tools>;
 } & Omit<StreamTextAiSdkOptions<Tools, OutputSpec>, 'onFinish'>;
@@ -391,15 +424,16 @@ export function registerProvider(
  *
  * @returns Array of provider name strings
  */
-export function getRegisteredProviders(): string[];
+export function getProviderNames(): string[];
 
 /**
  * Use an LLM model to generate text.
  *
  * This function is a wrapper over the AI SDK's `generateText`.
  * The prompt file sets `model`, `messages`, `temperature`, `maxTokens`, and `providerOptions`.
- * All other AI SDK `generateText` options are accepted via {@link GenerateTextAiSdkOptions}, including
- * tools, tool choice, structured output, callbacks, retries, and sampling settings.
+ * AI SDK-compatible `tools` are accepted structurally via {@link CompatibleToolSet}. Other AI SDK
+ * `generateText` options are accepted via {@link GenerateTextAiSdkOptions}, including tool choice,
+ * structured output, callbacks, retries, and sampling settings.
  *
  * @param args - Generation arguments. See {@link GenerateTextParameters}.
  * @returns AI SDK response with text and metadata.
@@ -416,8 +450,9 @@ export function generateText<
  *
  * This function is a wrapper over the AI SDK's `streamText`.
  * The prompt file sets `model`, `messages`, `temperature`, `maxTokens`, and `providerOptions`.
- * All other AI SDK `streamText` options are accepted via {@link StreamTextAiSdkOptions}, except
- * `onFinish`, which Output wraps to add optional cost data.
+ * AI SDK-compatible `tools` are accepted structurally via {@link CompatibleToolSet}. Other AI SDK
+ * `streamText` options are accepted via {@link StreamTextAiSdkOptions}, except `onFinish`, which
+ * Output wraps to add optional cost data.
  *
  * @param args - Streaming arguments. See {@link StreamTextParameters}.
  * @returns AI SDK stream result with textStream, fullStream, and metadata promises.
@@ -463,8 +498,8 @@ export function skill( params: {
 
 /** Pluggable conversation store for multi-turn Agent interactions. */
 export interface ConversationStore {
-  getMessages(): import( 'ai' ).ModelMessage[] | Promise<import( 'ai' ).ModelMessage[]>;
-  addMessages( messages: import( 'ai' ).ModelMessage[] ): void | Promise<void>;
+  getMessages(): ModelMessage[] | Promise<ModelMessage[]>;
+  addMessages( messages: ModelMessage[] ): void | Promise<void>;
 }
 
 /** Create an in-memory conversation store backed by a closure array. */

package/src/index.js

@@ -1,9 +1,6 @@
 export { generateText, streamText, generateImage } from './ai_sdk.js';
 export { Agent, createMemoryConversationStore, skill } from './agent.js';
 export { loadPrompt } from './prompt/loader.js';
-export { registerProvider, getRegisteredProviders } from './ai_model.js';
-export { tavilySearch, tavilyExtract, tavilyCrawl, tavilyMap } from '@tavily/ai-sdk';
-export { webSearch as exaSearch } from '@exalabs/ai-sdk';
-export { perplexitySearch } from '@perplexity-ai/ai-sdk';
+export { registerProvider, getProviderNames } from './ai_provider.js';
 export { tool, Output, smoothStream, stepCountIs, hasToolCall, jsonSchema } from 'ai';
 export * as ai from 'ai';

package/src/prompt/validations.js

@@ -1,5 +1,8 @@
 import { ValidationError, z } from '@outputai/core';
 
+const toolConfigSchema = z.record( z.string(), z.unknown() );
+const toolsConfigSchema = z.record( z.string(), toolConfigSchema );
+
 export const promptSchema = z.object( {
   name: z.string(),
   config: z.object( {
@@ -13,7 +16,7 @@ export const promptSchema = z.object( {
     aspectRatio: z.string().regex( /^\d+:\d+$/ ).optional(),
     seed: z.number().int().optional(),
     skills: z.union( [ z.string().min( 1 ), z.array( z.string().min( 1 ) ) ] ).optional(),
-    tools: z.record( z.string(), z.object( {} ).loose() ).optional(),
+    tools: toolsConfigSchema.optional(),
     providerOptions: z.object( {
       thinking: z.object( {
         type: z.enum( [ 'enabled', 'disabled' ] ),

package/src/prompt/validations.spec.js

@@ -384,6 +384,71 @@ describe( 'validatePrompt', () => {
     expect( () => validatePrompt( promptWithSkill ) ).not.toThrow();
   } );
 
+  it( 'should validate provider tool config records', () => {
+    const promptWithTools = {
+      name: 'tools-prompt',
+      config: {
+        provider: 'vertex',
+        model: 'gemini-2.0-flash',
+        tools: {
+          googleSearch: {
+            mode: 'MODE_DYNAMIC',
+            dynamicThreshold: 0.8
+          },
+          urlContext: {}
+        }
+      },
+      messages: [
+        {
+          role: 'user',
+          content: 'Research this.'
+        }
+      ]
+    };
+
+    expect( () => validatePrompt( promptWithTools ) ).not.toThrow();
+  } );
+
+  it( 'should throw ValidationError when tools config is not a record', () => {
+    const invalidToolsPrompt = {
+      name: 'invalid-tools-prompt',
+      config: {
+        provider: 'vertex',
+        model: 'gemini-2.0-flash',
+        tools: [ 'googleSearch' ]
+      },
+      messages: [
+        {
+          role: 'user',
+          content: 'Research this.'
+        }
+      ]
+    };
+
+    expect( () => validatePrompt( invalidToolsPrompt ) ).toThrow( ValidationError );
+  } );
+
+  it( 'should throw ValidationError when a tool config is not a record', () => {
+    const invalidToolConfigPrompt = {
+      name: 'invalid-tool-config-prompt',
+      config: {
+        provider: 'vertex',
+        model: 'gemini-2.0-flash',
+        tools: {
+          googleSearch: 'MODE_DYNAMIC'
+        }
+      },
+      messages: [
+        {
+          role: 'user',
+          content: 'Research this.'
+        }
+      ]
+    };
+
+    expect( () => validatePrompt( invalidToolConfigPrompt ) ).toThrow( ValidationError );
+  } );
+
   it( 'should throw ValidationError for invalid skill path config', () => {
     const invalidSkillsPrompt = {
       name: 'invalid-skills-prompt',

package/src/utils/error_handler.js

@@ -13,6 +13,9 @@ import {
 } from 'ai';
 import { FatalError } from '@outputai/core';
 
+// AI SDK does not expose a dedicated schema-mismatch discriminator for NoObjectGeneratedError.
+const NO_OBJECT_SCHEMA_MISMATCH_MESSAGE = 'No object generated: response did not match schema.';
+
 /**
  * Recursively search an error cause chain until finds an error which is instance of given prototype.
  *
@@ -25,7 +28,7 @@ export const findInstanceInCauseChain = ( error, _class, depth = 0 ) => {
   if ( !error || typeof error !== 'object' ) {
     return null;
   }
-  if ( typeof _class === 'string' && error.constructor.name === _class ) {
+  if ( typeof _class === 'string' && error.constructor?.name === _class ) {
     return error;
   }
   if ( typeof _class === 'function' && error instanceof _class ) {
@@ -42,20 +45,34 @@ const toFatalError = ( error, extraMessage = '' ) => new FatalError(
   { cause: error }
 );
 
+/**
+ * Map an AI SDK error to a framework specific error:
+ *
+ * - AI SDK Unrecoverable errors become FatalErrors, check code to see options.
+ * - NoObjectGeneratedError from invalid schema are reinitialized with a better message.
+ * - Other errors are preserved.
+ * @param {object} error - Original Error
+ * @returns {object} A new Error
+ */
 export const mapAiError = error => {
   if ( error instanceof FatalError ) {
     return error;
   }
 
-  // NoObjectGeneratedError can be thrown when the response doesn't match the schema
-  // This adds a wrapper to that error serializing the first zod validation in the message, to make it easier to debug.
-  if ( NoObjectGeneratedError.isInstance( error ) && error.message.includes( 'No object generated: response did not match schema.' ) ) {
+  // NoObjectGeneratedError can be thrown when the response doesn't match the schema.
+  // This re-creates the error with a better message, making it easier to debug.
+  if ( NoObjectGeneratedError.isInstance( error ) && error.message.includes( NO_OBJECT_SCHEMA_MISMATCH_MESSAGE ) ) {
     const zodError = findInstanceInCauseChain( error, 'ZodError' );
     if ( zodError && zodError.issues?.length > 0 ) {
-      const { path, message } = zodError.issues[0];
-      const wrapper = new Error( `${error.message} First issue is "${message}" at path [${path.join( ', ' )}].`, { cause: error } );
-      wrapper.name = 'NoObjectGeneratedError';
-      return wrapper;
+      const [ { path, message } ] = zodError.issues;
+      return new NoObjectGeneratedError( {
+        message: `${error.message} First issue is "${message}" at path [${path.join( ', ' )}].`,
+        cause: error.cause,
+        text: error.text,
+        response: error.response,
+        usage: error.usage,
+        finishReason: error.finishReason
+      } );
     }
     return error;
   }

package/src/utils/error_handler.spec.js

@@ -171,6 +171,13 @@ describe( 'findInstanceInCauseChain', () => {
     expect( findInstanceInCauseChain( 'not an error', Error ) ).toBeNull();
   } );
 
+  it( 'returns null for object causes without constructors', () => {
+    const cause = Object.create( null );
+    const error = new FirstCustomError( 'first', { cause } );
+
+    expect( findInstanceInCauseChain( error, 'SecondCustomError' ) ).toBeNull();
+  } );
+
   it( 'stops searching after the depth limit', () => {
     const makeErrorChain = depth => depth === 0 ?
       new SecondCustomError( 'target' ) :
@@ -204,17 +211,25 @@ describe( 'mapAiError', () => {
     const error = new NoObjectGeneratedError( {
       message: 'No object generated: response did not match schema.',
       text: '{"items":[{}]}',
+      response: { id: 'response-1' },
+      usage: { totalTokens: 10 },
+      finishReason: 'stop',
       cause: validationError
     } );
 
     const result = mapAiError( error );
 
     expect( result ).not.toBe( error );
-    expect( result.name ).toBe( 'NoObjectGeneratedError' );
+    expect( NoObjectGeneratedError.isInstance( result ) ).toBe( true );
+    expect( result.name ).toBe( 'AI_NoObjectGeneratedError' );
     expect( result.message ).toBe(
       'No object generated: response did not match schema. First issue is "Expected string" at path [items, 0, title].'
     );
-    expect( result.cause ).toBe( error );
+    expect( result.cause ).toBe( validationError );
+    expect( result.text ).toBe( error.text );
+    expect( result.response ).toBe( error.response );
+    expect( result.usage ).toBe( error.usage );
+    expect( result.finishReason ).toBe( error.finishReason );
   } );
 
   it( 'preserves NoObjectGeneratedError schema mismatches when no schema issue is available', () => {