@ai-sdk/quiverai 2.0.46 → 2.0.48

package/src/quiverai-language-model.ts

@@ -0,0 +1,162 @@
+import {
+  InvalidArgumentError,
+  type LanguageModelV4,
+  type LanguageModelV4CallOptions,
+  type LanguageModelV4StreamPart,
+  type SharedV4ProviderMetadata,
+  type SharedV4Warning,
+} from '@ai-sdk/provider';
+import {
+  createOpenResponses,
+  type OpenResponsesProviderSettings,
+} from '@ai-sdk/open-responses';
+import {
+  serializeModelOptions,
+  WORKFLOW_DESERIALIZE,
+  WORKFLOW_SERIALIZE,
+} from '@ai-sdk/provider-utils';
+import {
+  getQuiverAIResponseErrorMetadata,
+  quiveraiFailedResponseHandler,
+} from './quiverai-error';
+
+/** Applies QuiverAI's request policy while reusing the Open Responses transport. */
+export class QuiverAILanguageModel implements LanguageModelV4 {
+  readonly specificationVersion = 'v4';
+
+  static [WORKFLOW_SERIALIZE](model: QuiverAILanguageModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: string;
+    config: OpenResponsesProviderSettings;
+  }) {
+    // Restore QuiverAI's handlers, which cannot cross workflow boundaries.
+    const config: OpenResponsesProviderSettings = {
+      ...options.config,
+      failedResponseHandler: quiveraiFailedResponseHandler,
+      getResponseErrorMetadata: getQuiverAIResponseErrorMetadata,
+    };
+
+    return new QuiverAILanguageModel(
+      createOpenResponses(config).languageModel(options.modelId),
+      config,
+    );
+  }
+
+  constructor(
+    private readonly model: LanguageModelV4,
+    private readonly config: OpenResponsesProviderSettings,
+  ) {}
+
+  get modelId() {
+    return this.model.modelId;
+  }
+
+  get provider() {
+    return this.model.provider;
+  }
+
+  get supportedUrls() {
+    return this.model.supportedUrls;
+  }
+
+  async doGenerate(options: LanguageModelV4CallOptions) {
+    const prepared = prepareQuiverAICall(options);
+    const result = await this.model.doGenerate(prepared.options);
+    return { ...result, warnings: [...prepared.warnings, ...result.warnings] };
+  }
+
+  async doStream(options: LanguageModelV4CallOptions) {
+    const prepared = prepareQuiverAICall(options);
+    const result = await this.model.doStream(prepared.options);
+    if (prepared.warnings.length === 0) return result;
+    return {
+      ...result,
+      stream: result.stream.pipeThrough(
+        new TransformStream<
+          LanguageModelV4StreamPart,
+          LanguageModelV4StreamPart
+        >({
+          transform(part, controller) {
+            controller.enqueue(
+              part.type === 'stream-start'
+                ? {
+                    ...part,
+                    warnings: [...prepared.warnings, ...part.warnings],
+                  }
+                : part,
+            );
+          },
+        }),
+      ),
+    };
+  }
+}
+
+function prepareQuiverAICall(options: LanguageModelV4CallOptions): {
+  options: LanguageModelV4CallOptions;
+  warnings: SharedV4Warning[];
+} {
+  const { reasoningEffort, reasoningSummary } =
+    options.providerOptions?.quiverai ?? {};
+  if (
+    reasoningEffort != null &&
+    (typeof reasoningEffort !== 'string' ||
+      !['low', 'medium', 'high', 'xhigh'].includes(reasoningEffort))
+  ) {
+    throw new InvalidArgumentError({
+      argument: 'providerOptions',
+      message: `Unsupported reasoning effort: ${reasoningEffort}`,
+    });
+  }
+  if (reasoningSummary != null && reasoningSummary !== 'auto') {
+    throw new InvalidArgumentError({
+      argument: 'providerOptions',
+      message: `Unsupported reasoning summary: ${reasoningSummary}`,
+    });
+  }
+
+  const warnings: SharedV4Warning[] = [];
+  const omitReasoning = options.reasoning === 'none' && reasoningEffort == null;
+  if (omitReasoning) {
+    warnings.push({ type: 'unsupported', feature: 'reasoning effort none' });
+  }
+
+  return {
+    warnings,
+    options: {
+      ...options,
+      reasoning: omitReasoning ? undefined : options.reasoning,
+      prompt: options.prompt.map(message =>
+        message.role !== 'assistant'
+          ? message
+          : {
+              ...message,
+              content: message.content.map(part => {
+                if (part.type !== 'reasoning') return part;
+                const metadata =
+                  part.providerOptions?.quiverai ??
+                  (part as { providerMetadata?: SharedV4ProviderMetadata })
+                    .providerMetadata?.quiverai;
+                return {
+                  ...part,
+                  text: '',
+                  providerOptions: {
+                    ...part.providerOptions,
+                    quiverai: {
+                      itemId: metadata?.itemId,
+                      reasoningSummary: metadata?.reasoningSummary,
+                    },
+                  },
+                };
+              }),
+            },
+      ),
+    },
+  };
+}

package/src/quiverai-provider.ts

@@ -1,8 +1,13 @@
 import {
   NoSuchModelError,
   type ImageModelV4,
+  type LanguageModelV4,
   type ProviderV4,
 } from '@ai-sdk/provider';
+import {
+  createOpenResponses,
+  type OpenResponsesProviderSettings,
+} from '@ai-sdk/open-responses';
 import {
   loadApiKey,
   loadOptionalSetting,
@@ -10,8 +15,14 @@ import {
   withUserAgentSuffix,
   type FetchFunction,
 } from '@ai-sdk/provider-utils';
+import {
+  getQuiverAIResponseErrorMetadata,
+  quiveraiFailedResponseHandler,
+} from './quiverai-error';
+import { QuiverAILanguageModel } from './quiverai-language-model';
 import { QuiverAIImageModel } from './quiverai-image-model';
 import type { QuiverAIImageModelId } from './quiverai-image-settings';
+import type { QuiverAILanguageModelId } from './quiverai-language-model-settings';
 import { VERSION } from './version';
 
 export interface QuiverAIProviderSettings {
@@ -40,6 +51,16 @@ export interface QuiverAIProviderSettings {
 }
 
 export interface QuiverAIProvider extends ProviderV4 {
+  /**
+   * Creates a language model for the QuiverAI Responses API.
+   */
+  (modelId: QuiverAILanguageModelId): LanguageModelV4;
+
+  /**
+   * Creates a language model for the QuiverAI Responses API.
+   */
+  languageModel(modelId: QuiverAILanguageModelId): LanguageModelV4;
+
   /**
    * Creates a model for image generation.
    */
@@ -54,6 +75,11 @@ export interface QuiverAIProvider extends ProviderV4 {
    * @deprecated Use `embeddingModel` instead.
    */
   textEmbeddingModel(modelId: string): never;
+
+  /**
+   * QuiverAI caller-executed tools.
+   */
+  tools: ReturnType<typeof createOpenResponses>['tools'];
 }
 
 const defaultBaseURL = 'https://api.quiver.ai/v1';
@@ -69,24 +95,43 @@ export function createQuiverAI(
       }),
     ) ?? defaultBaseURL;
 
-  const getHeaders = () =>
-    withUserAgentSuffix(
-      {
-        Authorization: `Bearer ${loadApiKey({
-          apiKey: options.apiKey,
-          environmentVariableName: 'QUIVERAI_API_KEY',
-          description: 'QuiverAI',
-        })}`,
-        ...options.headers,
-      },
-      `ai-sdk/quiverai/${VERSION}`,
+  const getHeaders = () => ({
+    Authorization: `Bearer ${loadApiKey({
+      apiKey: options.apiKey,
+      environmentVariableName: 'QUIVERAI_API_KEY',
+      description: 'QuiverAI',
+    })}`,
+    ...options.headers,
+  });
+
+  const getImageHeaders = () =>
+    withUserAgentSuffix(getHeaders(), `ai-sdk/quiverai/${VERSION}`);
+
+  const responsesConfig: OpenResponsesProviderSettings = {
+    name: 'quiverai',
+    url: `${baseURL}/responses`,
+    headers: getHeaders,
+    fetch: options.fetch,
+    failedResponseHandler: quiveraiFailedResponseHandler,
+    getResponseErrorMetadata: getQuiverAIResponseErrorMetadata,
+    strictResponseInput: true,
+    customToolId: 'quiverai.custom',
+    structuredOutputs: false,
+    userAgentSuffix: `ai-sdk/quiverai/${VERSION}`,
+  };
+  const responsesProvider = createOpenResponses(responsesConfig);
+
+  const createLanguageModel = (modelId: QuiverAILanguageModelId) =>
+    new QuiverAILanguageModel(
+      responsesProvider.languageModel(modelId),
+      responsesConfig,
     );
 
   const createImageModel = (modelId: QuiverAIImageModelId) =>
     new QuiverAIImageModel(modelId, {
       provider: 'quiverai.image',
       baseURL,
-      headers: getHeaders,
+      headers: getImageHeaders,
       fetch: options.fetch,
     });
 
@@ -97,19 +142,19 @@ export function createQuiverAI(
     });
   };
 
-  return {
-    specificationVersion: 'v4',
-    image: createImageModel,
-    imageModel: createImageModel,
-    languageModel: (modelId: string) => {
-      throw new NoSuchModelError({
-        modelId,
-        modelType: 'languageModel',
-      });
-    },
-    embeddingModel,
-    textEmbeddingModel: embeddingModel,
+  const provider = function (modelId: QuiverAILanguageModelId) {
+    return createLanguageModel(modelId);
   };
+
+  provider.specificationVersion = 'v4' as const;
+  provider.languageModel = createLanguageModel;
+  provider.image = createImageModel;
+  provider.imageModel = createImageModel;
+  provider.embeddingModel = embeddingModel;
+  provider.textEmbeddingModel = embeddingModel;
+  provider.tools = responsesProvider.tools;
+
+  return provider as QuiverAIProvider;
 }
 
 export const quiverai = createQuiverAI();