ai 6.0.33 → 6.0.35

package/src/generate-object/parse-and-validate-object-result.ts

@@ -0,0 +1,111 @@
+import { JSONParseError, TypeValidationError } from '@ai-sdk/provider';
+import { safeParseJSON } from '@ai-sdk/provider-utils';
+import { NoObjectGeneratedError } from '../error/no-object-generated-error';
+import type {
+  FinishReason,
+  LanguageModelResponseMetadata,
+  LanguageModelUsage,
+} from '../types';
+import type { OutputStrategy } from './output-strategy';
+import { RepairTextFunction } from './repair-text';
+
+/**
+ * Parses and validates a result string by parsing it as JSON and validating against the output strategy.
+ *
+ * @param result - The result string to parse and validate
+ * @param outputStrategy - The output strategy containing validation logic
+ * @param context - Additional context for error reporting
+ * @returns The validated result
+ * @throws NoObjectGeneratedError if parsing or validation fails
+ */
+async function parseAndValidateObjectResult<RESULT>(
+  result: string,
+  outputStrategy: OutputStrategy<any, RESULT, any>,
+  context: {
+    response: LanguageModelResponseMetadata;
+    usage: LanguageModelUsage;
+    finishReason: FinishReason;
+  },
+): Promise<RESULT> {
+  const parseResult = await safeParseJSON({ text: result });
+
+  if (!parseResult.success) {
+    throw new NoObjectGeneratedError({
+      message: 'No object generated: could not parse the response.',
+      cause: parseResult.error,
+      text: result,
+      response: context.response,
+      usage: context.usage,
+      finishReason: context.finishReason,
+    });
+  }
+
+  const validationResult = await outputStrategy.validateFinalResult(
+    parseResult.value,
+    {
+      text: result,
+      response: context.response,
+      usage: context.usage,
+    },
+  );
+
+  if (!validationResult.success) {
+    throw new NoObjectGeneratedError({
+      message: 'No object generated: response did not match schema.',
+      cause: validationResult.error,
+      text: result,
+      response: context.response,
+      usage: context.usage,
+      finishReason: context.finishReason,
+    });
+  }
+
+  return validationResult.value;
+}
+
+/**
+ * Parses and validates a result string by parsing it as JSON and validating against the output strategy.
+ * If the result cannot be parsed, it attempts to repair the result using the repairText function.
+ *
+ * @param result - The result string to parse and validate
+ * @param outputStrategy - The output strategy containing validation logic
+ * @param repairText - A function that attempts to repair the result string
+ * @param context - Additional context for error reporting
+ * @returns The validated result
+ * @throws NoObjectGeneratedError if parsing or validation fails
+ */
+export async function parseAndValidateObjectResultWithRepair<RESULT>(
+  result: string,
+  outputStrategy: OutputStrategy<any, RESULT, any>,
+  repairText: RepairTextFunction | undefined,
+  context: {
+    response: LanguageModelResponseMetadata;
+    usage: LanguageModelUsage;
+    finishReason: FinishReason;
+  },
+): Promise<RESULT> {
+  try {
+    return await parseAndValidateObjectResult(result, outputStrategy, context);
+  } catch (error) {
+    if (
+      repairText != null &&
+      NoObjectGeneratedError.isInstance(error) &&
+      (JSONParseError.isInstance(error.cause) ||
+        TypeValidationError.isInstance(error.cause))
+    ) {
+      const repairedText = await repairText({
+        text: result,
+        error: error.cause,
+      });
+      if (repairedText === null) {
+        throw error;
+      }
+      return await parseAndValidateObjectResult(
+        repairedText,
+        outputStrategy,
+        context,
+      );
+    }
+    throw error;
+  }
+}

package/src/generate-object/repair-text.ts

@@ -0,0 +1,12 @@
+import { JSONParseError, TypeValidationError } from '@ai-sdk/provider';
+
+/**
+A function that attempts to repair the raw output of the model
+to enable JSON parsing.
+
+Should return the repaired text or null if the text cannot be repaired.
+     */
+export type RepairTextFunction = (options: {
+  text: string;
+  error: JSONParseError | TypeValidationError;
+}) => Promise<string | null>;

package/src/generate-object/stream-object-result.ts

@@ -0,0 +1,120 @@
+import { ServerResponse } from 'http';
+import { AsyncIterableStream } from '../util/async-iterable-stream';
+import {
+  CallWarning,
+  FinishReason,
+  LanguageModelRequestMetadata,
+  LanguageModelResponseMetadata,
+  ProviderMetadata,
+} from '../types';
+import { LanguageModelUsage } from '../types/usage';
+
+/**
+The result of a `streamObject` call that contains the partial object stream and additional information.
+ */
+export interface StreamObjectResult<PARTIAL, RESULT, ELEMENT_STREAM> {
+  /**
+  Warnings from the model provider (e.g. unsupported settings)
+     */
+  readonly warnings: Promise<CallWarning[] | undefined>;
+
+  /**
+  The token usage of the generated response. Resolved when the response is finished.
+     */
+  readonly usage: Promise<LanguageModelUsage>;
+
+  /**
+Additional provider-specific metadata. They are passed through
+from the provider to the AI SDK and enable provider-specific
+results that can be fully encapsulated in the provider.
+   */
+  readonly providerMetadata: Promise<ProviderMetadata | undefined>;
+
+  /**
+Additional request information from the last step.
+ */
+  readonly request: Promise<LanguageModelRequestMetadata>;
+
+  /**
+Additional response information.
+ */
+  readonly response: Promise<LanguageModelResponseMetadata>;
+
+  /**
+The reason why the generation finished. Taken from the last step.
+
+Resolved when the response is finished.
+     */
+  readonly finishReason: Promise<FinishReason>;
+
+  /**
+  The generated object (typed according to the schema). Resolved when the response is finished.
+     */
+  readonly object: Promise<RESULT>;
+
+  /**
+  Stream of partial objects. It gets more complete as the stream progresses.
+
+  Note that the partial object is not validated.
+  If you want to be certain that the actual content matches your schema, you need to implement your own validation for partial results.
+     */
+  readonly partialObjectStream: AsyncIterableStream<PARTIAL>;
+
+  /**
+   * Stream over complete array elements. Only available if the output strategy is set to `array`.
+   */
+  readonly elementStream: ELEMENT_STREAM;
+
+  /**
+  Text stream of the JSON representation of the generated object. It contains text chunks.
+  When the stream is finished, the object is valid JSON that can be parsed.
+     */
+  readonly textStream: AsyncIterableStream<string>;
+
+  /**
+  Stream of different types of events, including partial objects, errors, and finish events.
+  Only errors that stop the stream, such as network errors, are thrown.
+     */
+  readonly fullStream: AsyncIterableStream<ObjectStreamPart<PARTIAL>>;
+
+  /**
+  Writes text delta output to a Node.js response-like object.
+  It sets a `Content-Type` header to `text/plain; charset=utf-8` and
+  writes each text delta as a separate chunk.
+
+  @param response A Node.js response-like object (ServerResponse).
+  @param init Optional headers, status code, and status text.
+     */
+  pipeTextStreamToResponse(response: ServerResponse, init?: ResponseInit): void;
+
+  /**
+  Creates a simple text stream response.
+  The response has a `Content-Type` header set to `text/plain; charset=utf-8`.
+  Each text delta is encoded as UTF-8 and sent as a separate chunk.
+  Non-text-delta events are ignored.
+
+  @param init Optional headers, status code, and status text.
+     */
+  toTextStreamResponse(init?: ResponseInit): Response;
+}
+
+export type ObjectStreamPart<PARTIAL> =
+  | {
+      type: 'object';
+      object: PARTIAL;
+    }
+  | {
+      type: 'text-delta';
+      textDelta: string;
+    }
+  | {
+      type: 'error';
+      error: unknown;
+    }
+  | {
+      type: 'finish';
+      finishReason: FinishReason;
+      usage: LanguageModelUsage;
+      response: LanguageModelResponseMetadata;
+      providerMetadata?: ProviderMetadata;
+    };

package/src/generate-object/stream-object.test-d.ts

@@ -0,0 +1,74 @@
+import { JSONValue } from '@ai-sdk/provider';
+import { expectTypeOf } from 'vitest';
+import { z } from 'zod/v4';
+import { AsyncIterableStream } from '../util/async-iterable-stream';
+import { FinishReason } from '../types';
+import { streamObject } from './stream-object';
+import { describe, it } from 'vitest';
+
+describe('streamObject', () => {
+  it('should have finishReason property with correct type', () => {
+    const result = streamObject({
+      schema: z.object({ number: z.number() }),
+      model: undefined!,
+      prompt: 'test',
+    });
+
+    expectTypeOf<typeof result.finishReason>().toEqualTypeOf<
+      Promise<FinishReason>
+    >();
+  });
+
+  it('should support enum types', async () => {
+    const result = await streamObject({
+      output: 'enum',
+      enum: ['a', 'b', 'c'] as const,
+      model: undefined!,
+      prompt: 'test',
+    });
+
+    expectTypeOf<typeof result.object>().toEqualTypeOf<
+      Promise<'a' | 'b' | 'c'>
+    >;
+
+    for await (const text of result.partialObjectStream) {
+      expectTypeOf(text).toEqualTypeOf<string>();
+    }
+  });
+
+  it('should support schema types', async () => {
+    const result = streamObject({
+      schema: z.object({ number: z.number() }),
+      model: undefined!,
+      prompt: 'test',
+    });
+
+    expectTypeOf<typeof result.object>().toEqualTypeOf<
+      Promise<{ number: number }>
+    >();
+  });
+
+  it('should support no-schema output mode', async () => {
+    const result = streamObject({
+      output: 'no-schema',
+      model: undefined!,
+      prompt: 'test',
+    });
+
+    expectTypeOf<typeof result.object>().toEqualTypeOf<Promise<JSONValue>>();
+  });
+
+  it('should support array output mode', async () => {
+    const result = streamObject({
+      output: 'array',
+      schema: z.number(),
+      model: undefined!,
+      prompt: 'test',
+    });
+
+    expectTypeOf<typeof result.partialObjectStream>().toEqualTypeOf<
+      AsyncIterableStream<number[]>
+    >();
+    expectTypeOf<typeof result.object>().toEqualTypeOf<Promise<number[]>>();
+  });
+});