@pensar/apex 2.5.0 → 2.6.1-canary.0cc77dcc

package/build/index-qnyevb6q.js

@@ -0,0 +1,1563 @@
+import {
+  init_v4,
+  cancelResponseBody,
+  DownloadError,
+  fetchWithValidatedRedirects,
+  DEFAULT_MAX_DOWNLOAD_SIZE,
+  readResponseWithSizeLimit,
+  createIdGenerator,
+  getRuntimeEnvironmentUserAgent,
+  withUserAgentSuffix,
+  lazySchema,
+  asSchema,
+  zodSchema,
+  safeValidateTypes,
+  safeParseJSON,
+  resolve,
+  init_dist2
+} from "./cli-pwm29ks7.js";
+import {
+  AISDKError,
+  TypeValidationError,
+  init_dist3
+} from "./cli-gsaf4jk3.js";
+import {
+  string,
+  number,
+  boolean,
+  _null,
+  unknown,
+  never,
+  array,
+  object,
+  strictObject,
+  union,
+  discriminatedUnion,
+  record,
+  _enum,
+  literal,
+  lazy,
+  custom,
+  _instanceof
+} from "./cli-mz5pk30x.js";
+
+// node_modules/ai/dist/index.mjs
+init_dist2();
+init_dist3();
+init_dist2();
+init_v4();
+init_v4();
+init_v4();
+init_v4();
+init_v4();
+init_dist3();
+init_dist2();
+init_dist2();
+init_dist2();
+init_v4();
+init_dist2();
+init_dist2();
+init_v4();
+init_dist2();
+init_dist2();
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name22 in all)
+    __defProp(target, name22, { get: all[name22], enumerable: true });
+};
+var name = "AI_InvalidArgumentError";
+var marker = `vercel.ai.error.${name}`;
+var symbol = Symbol.for(marker);
+var _a;
+_a = symbol;
+var name2 = "AI_InvalidStreamPartError";
+var marker2 = `vercel.ai.error.${name2}`;
+var symbol2 = Symbol.for(marker2);
+var _a2;
+_a2 = symbol2;
+var name3 = "AI_InvalidToolApprovalError";
+var marker3 = `vercel.ai.error.${name3}`;
+var symbol3 = Symbol.for(marker3);
+var _a3;
+_a3 = symbol3;
+var name4 = "AI_InvalidToolApprovalSignatureError";
+var marker4 = `vercel.ai.error.${name4}`;
+var symbol4 = Symbol.for(marker4);
+var _a4;
+_a4 = symbol4;
+var name5 = "AI_InvalidToolInputError";
+var marker5 = `vercel.ai.error.${name5}`;
+var symbol5 = Symbol.for(marker5);
+var _a5;
+_a5 = symbol5;
+var name6 = "AI_ToolCallNotFoundForApprovalError";
+var marker6 = `vercel.ai.error.${name6}`;
+var symbol6 = Symbol.for(marker6);
+var _a6;
+_a6 = symbol6;
+var name7 = "AI_MissingToolResultsError";
+var marker7 = `vercel.ai.error.${name7}`;
+var symbol7 = Symbol.for(marker7);
+var _a7;
+_a7 = symbol7;
+var name8 = "AI_NoImageGeneratedError";
+var marker8 = `vercel.ai.error.${name8}`;
+var symbol8 = Symbol.for(marker8);
+var _a8;
+_a8 = symbol8;
+var name9 = "AI_NoObjectGeneratedError";
+var marker9 = `vercel.ai.error.${name9}`;
+var symbol9 = Symbol.for(marker9);
+var _a9;
+var NoObjectGeneratedError = class extends AISDKError {
+  constructor({
+    message = "No object generated.",
+    cause,
+    text: text2,
+    response,
+    usage,
+    finishReason
+  }) {
+    super({ name: name9, message, cause });
+    this[_a9] = true;
+    this.text = text2;
+    this.response = response;
+    this.usage = usage;
+    this.finishReason = finishReason;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker9);
+  }
+};
+_a9 = symbol9;
+var name10 = "AI_NoOutputGeneratedError";
+var marker10 = `vercel.ai.error.${name10}`;
+var symbol10 = Symbol.for(marker10);
+var _a10;
+_a10 = symbol10;
+var name11 = "AI_NoSpeechGeneratedError";
+var marker11 = `vercel.ai.error.${name11}`;
+var symbol11 = Symbol.for(marker11);
+var _a11;
+_a11 = symbol11;
+var name12 = "AI_NoTranscriptGeneratedError";
+var marker12 = `vercel.ai.error.${name12}`;
+var symbol12 = Symbol.for(marker12);
+var _a12;
+_a12 = symbol12;
+var name13 = "AI_NoVideoGeneratedError";
+var marker13 = `vercel.ai.error.${name13}`;
+var symbol13 = Symbol.for(marker13);
+var _a13;
+_a13 = symbol13;
+var name14 = "AI_NoSuchToolError";
+var marker14 = `vercel.ai.error.${name14}`;
+var symbol14 = Symbol.for(marker14);
+var _a14;
+_a14 = symbol14;
+var name15 = "AI_ToolCallRepairError";
+var marker15 = `vercel.ai.error.${name15}`;
+var symbol15 = Symbol.for(marker15);
+var _a15;
+_a15 = symbol15;
+var name16 = "AI_UIMessageStreamError";
+var marker16 = `vercel.ai.error.${name16}`;
+var symbol16 = Symbol.for(marker16);
+var _a16;
+_a16 = symbol16;
+var name17 = "AI_InvalidDataContentError";
+var marker17 = `vercel.ai.error.${name17}`;
+var symbol17 = Symbol.for(marker17);
+var _a17;
+_a17 = symbol17;
+var name18 = "AI_InvalidMessageRoleError";
+var marker18 = `vercel.ai.error.${name18}`;
+var symbol18 = Symbol.for(marker18);
+var _a18;
+_a18 = symbol18;
+var name19 = "AI_MessageConversionError";
+var marker19 = `vercel.ai.error.${name19}`;
+var symbol19 = Symbol.for(marker19);
+var _a19;
+_a19 = symbol19;
+var name20 = "AI_RetryError";
+var marker20 = `vercel.ai.error.${name20}`;
+var symbol20 = Symbol.for(marker20);
+var _a20;
+_a20 = symbol20;
+var VERSION = "6.0.208";
+var download = async ({
+  url,
+  maxBytes,
+  abortSignal
+}) => {
+  var _a22;
+  const urlText = url.toString();
+  try {
+    const headers = withUserAgentSuffix({}, `ai-sdk/${VERSION}`, getRuntimeEnvironmentUserAgent());
+    const response = await fetchWithValidatedRedirects({
+      url: urlText,
+      headers,
+      abortSignal
+    });
+    if (!response.ok) {
+      await cancelResponseBody(response);
+      throw new DownloadError({
+        url: urlText,
+        statusCode: response.status,
+        statusText: response.statusText
+      });
+    }
+    const data = await readResponseWithSizeLimit({
+      response,
+      url: urlText,
+      maxBytes: maxBytes != null ? maxBytes : DEFAULT_MAX_DOWNLOAD_SIZE
+    });
+    return {
+      data,
+      mediaType: (_a22 = response.headers.get("content-type")) != null ? _a22 : undefined
+    };
+  } catch (error) {
+    if (DownloadError.isInstance(error)) {
+      throw error;
+    }
+    throw new DownloadError({ url: urlText, cause: error });
+  }
+};
+var dataContentSchema = union([
+  string(),
+  _instanceof(Uint8Array),
+  _instanceof(ArrayBuffer),
+  custom((value) => {
+    var _a22, _b;
+    return (_b = (_a22 = globalThis.Buffer) == null ? undefined : _a22.isBuffer(value)) != null ? _b : false;
+  }, { message: "Must be a Buffer" })
+]);
+var jsonValueSchema = lazy(() => union([
+  _null(),
+  string(),
+  number(),
+  boolean(),
+  record(string(), jsonValueSchema.optional()),
+  array(jsonValueSchema)
+]));
+var providerMetadataSchema = record(string(), record(string(), jsonValueSchema.optional()));
+var textPartSchema = object({
+  type: literal("text"),
+  text: string(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var imagePartSchema = object({
+  type: literal("image"),
+  image: union([dataContentSchema, _instanceof(URL)]),
+  mediaType: string().optional(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var filePartSchema = object({
+  type: literal("file"),
+  data: union([dataContentSchema, _instanceof(URL)]),
+  filename: string().optional(),
+  mediaType: string(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var reasoningPartSchema = object({
+  type: literal("reasoning"),
+  text: string(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var toolCallPartSchema = object({
+  type: literal("tool-call"),
+  toolCallId: string(),
+  toolName: string(),
+  input: unknown(),
+  providerOptions: providerMetadataSchema.optional(),
+  providerExecuted: boolean().optional()
+});
+var outputSchema = discriminatedUnion("type", [
+  object({
+    type: literal("text"),
+    value: string(),
+    providerOptions: providerMetadataSchema.optional()
+  }),
+  object({
+    type: literal("json"),
+    value: jsonValueSchema,
+    providerOptions: providerMetadataSchema.optional()
+  }),
+  object({
+    type: literal("execution-denied"),
+    reason: string().optional(),
+    providerOptions: providerMetadataSchema.optional()
+  }),
+  object({
+    type: literal("error-text"),
+    value: string(),
+    providerOptions: providerMetadataSchema.optional()
+  }),
+  object({
+    type: literal("error-json"),
+    value: jsonValueSchema,
+    providerOptions: providerMetadataSchema.optional()
+  }),
+  object({
+    type: literal("content"),
+    value: array(union([
+      object({
+        type: literal("text"),
+        text: string(),
+        providerOptions: providerMetadataSchema.optional()
+      }),
+      object({
+        type: literal("media"),
+        data: string(),
+        mediaType: string()
+      }),
+      object({
+        type: literal("file-data"),
+        data: string(),
+        mediaType: string(),
+        filename: string().optional(),
+        providerOptions: providerMetadataSchema.optional()
+      }),
+      object({
+        type: literal("file-url"),
+        url: string(),
+        providerOptions: providerMetadataSchema.optional()
+      }),
+      object({
+        type: literal("file-id"),
+        fileId: union([string(), record(string(), string())]),
+        providerOptions: providerMetadataSchema.optional()
+      }),
+      object({
+        type: literal("image-data"),
+        data: string(),
+        mediaType: string(),
+        providerOptions: providerMetadataSchema.optional()
+      }),
+      object({
+        type: literal("image-url"),
+        url: string(),
+        providerOptions: providerMetadataSchema.optional()
+      }),
+      object({
+        type: literal("image-file-id"),
+        fileId: union([string(), record(string(), string())]),
+        providerOptions: providerMetadataSchema.optional()
+      }),
+      object({
+        type: literal("custom"),
+        providerOptions: providerMetadataSchema.optional()
+      })
+    ]))
+  })
+]);
+var toolResultPartSchema = object({
+  type: literal("tool-result"),
+  toolCallId: string(),
+  toolName: string(),
+  output: outputSchema,
+  providerOptions: providerMetadataSchema.optional()
+});
+var toolApprovalRequestSchema = object({
+  type: literal("tool-approval-request"),
+  approvalId: string(),
+  toolCallId: string()
+});
+var toolApprovalResponseSchema = object({
+  type: literal("tool-approval-response"),
+  approvalId: string(),
+  approved: boolean(),
+  reason: string().optional()
+});
+var systemModelMessageSchema = object({
+  role: literal("system"),
+  content: string(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var userModelMessageSchema = object({
+  role: literal("user"),
+  content: union([
+    string(),
+    array(union([textPartSchema, imagePartSchema, filePartSchema]))
+  ]),
+  providerOptions: providerMetadataSchema.optional()
+});
+var assistantModelMessageSchema = object({
+  role: literal("assistant"),
+  content: union([
+    string(),
+    array(union([
+      textPartSchema,
+      filePartSchema,
+      reasoningPartSchema,
+      toolCallPartSchema,
+      toolResultPartSchema,
+      toolApprovalRequestSchema
+    ]))
+  ]),
+  providerOptions: providerMetadataSchema.optional()
+});
+var toolModelMessageSchema = object({
+  role: literal("tool"),
+  content: array(union([toolResultPartSchema, toolApprovalResponseSchema])),
+  providerOptions: providerMetadataSchema.optional()
+});
+var modelMessageSchema = union([
+  systemModelMessageSchema,
+  userModelMessageSchema,
+  assistantModelMessageSchema,
+  toolModelMessageSchema
+]);
+var encoder = new TextEncoder;
+var output_exports = {};
+__export(output_exports, {
+  array: () => array2,
+  choice: () => choice,
+  json: () => json,
+  object: () => object2,
+  text: () => text
+});
+function fixJson(input) {
+  const stack = ["ROOT"];
+  let lastValidIndex = -1;
+  let literalStart = null;
+  let unicodeEscapeDigits = 0;
+  function isHexDigit(char) {
+    return char >= "0" && char <= "9" || char >= "A" && char <= "F" || char >= "a" && char <= "f";
+  }
+  function processValueStart(char, i, swapState) {
+    {
+      switch (char) {
+        case '"': {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_STRING");
+          break;
+        }
+        case "f":
+        case "t":
+        case "n": {
+          lastValidIndex = i;
+          literalStart = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_LITERAL");
+          break;
+        }
+        case "-": {
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_NUMBER");
+          break;
+        }
+        case "0":
+        case "1":
+        case "2":
+        case "3":
+        case "4":
+        case "5":
+        case "6":
+        case "7":
+        case "8":
+        case "9": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_NUMBER");
+          break;
+        }
+        case "{": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_OBJECT_START");
+          break;
+        }
+        case "[": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_ARRAY_START");
+          break;
+        }
+      }
+    }
+  }
+  function processAfterObjectValue(char, i) {
+    switch (char) {
+      case ",": {
+        stack.pop();
+        stack.push("INSIDE_OBJECT_AFTER_COMMA");
+        break;
+      }
+      case "}": {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+  function processAfterArrayValue(char, i) {
+    switch (char) {
+      case ",": {
+        stack.pop();
+        stack.push("INSIDE_ARRAY_AFTER_COMMA");
+        break;
+      }
+      case "]": {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+  for (let i = 0;i < input.length; i++) {
+    const char = input[i];
+    const currentState = stack[stack.length - 1];
+    switch (currentState) {
+      case "ROOT":
+        processValueStart(char, i, "FINISH");
+        break;
+      case "INSIDE_OBJECT_START": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+          case "}": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_COMMA": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_KEY": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_AFTER_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_KEY": {
+        switch (char) {
+          case ":": {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_BEFORE_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_BEFORE_VALUE": {
+        processValueStart(char, i, "INSIDE_OBJECT_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        processAfterObjectValue(char, i);
+        break;
+      }
+      case "INSIDE_STRING": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            lastValidIndex = i;
+            break;
+          }
+          case "\\": {
+            stack.push("INSIDE_STRING_ESCAPE");
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_START": {
+        switch (char) {
+          case "]": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+            processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        switch (char) {
+          case ",": {
+            stack.pop();
+            stack.push("INSIDE_ARRAY_AFTER_COMMA");
+            break;
+          }
+          case "]": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_COMMA": {
+        processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_STRING_ESCAPE": {
+        stack.pop();
+        if (char === "u") {
+          unicodeEscapeDigits = 0;
+          stack.push("INSIDE_STRING_UNICODE_ESCAPE");
+        } else {
+          lastValidIndex = i;
+        }
+        break;
+      }
+      case "INSIDE_STRING_UNICODE_ESCAPE": {
+        if (isHexDigit(char)) {
+          unicodeEscapeDigits++;
+          if (unicodeEscapeDigits === 4) {
+            stack.pop();
+            lastValidIndex = i;
+          }
+        }
+        break;
+      }
+      case "INSIDE_NUMBER": {
+        switch (char) {
+          case "0":
+          case "1":
+          case "2":
+          case "3":
+          case "4":
+          case "5":
+          case "6":
+          case "7":
+          case "8":
+          case "9": {
+            lastValidIndex = i;
+            break;
+          }
+          case "e":
+          case "E":
+          case "-":
+          case ".": {
+            break;
+          }
+          case ",": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+              processAfterArrayValue(char, i);
+            }
+            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+              processAfterObjectValue(char, i);
+            }
+            break;
+          }
+          case "}": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+              processAfterObjectValue(char, i);
+            }
+            break;
+          }
+          case "]": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+              processAfterArrayValue(char, i);
+            }
+            break;
+          }
+          default: {
+            stack.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const partialLiteral = input.substring(literalStart, i + 1);
+        if (!"false".startsWith(partialLiteral) && !"true".startsWith(partialLiteral) && !"null".startsWith(partialLiteral)) {
+          stack.pop();
+          if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+            processAfterObjectValue(char, i);
+          } else if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+            processAfterArrayValue(char, i);
+          }
+        } else {
+          lastValidIndex = i;
+        }
+        break;
+      }
+    }
+  }
+  let result = input.slice(0, lastValidIndex + 1);
+  for (let i = stack.length - 1;i >= 0; i--) {
+    const state = stack[i];
+    switch (state) {
+      case "INSIDE_STRING": {
+        result += '"';
+        break;
+      }
+      case "INSIDE_OBJECT_KEY":
+      case "INSIDE_OBJECT_AFTER_KEY":
+      case "INSIDE_OBJECT_AFTER_COMMA":
+      case "INSIDE_OBJECT_START":
+      case "INSIDE_OBJECT_BEFORE_VALUE":
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        result += "}";
+        break;
+      }
+      case "INSIDE_ARRAY_START":
+      case "INSIDE_ARRAY_AFTER_COMMA":
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        result += "]";
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const partialLiteral = input.substring(literalStart, input.length);
+        if ("true".startsWith(partialLiteral)) {
+          result += "true".slice(partialLiteral.length);
+        } else if ("false".startsWith(partialLiteral)) {
+          result += "false".slice(partialLiteral.length);
+        } else if ("null".startsWith(partialLiteral)) {
+          result += "null".slice(partialLiteral.length);
+        }
+      }
+    }
+  }
+  return result;
+}
+async function parsePartialJson(jsonText) {
+  if (jsonText === undefined) {
+    return { value: undefined, state: "undefined-input" };
+  }
+  let result = await safeParseJSON({ text: jsonText });
+  if (result.success) {
+    return { value: result.value, state: "successful-parse" };
+  }
+  result = await safeParseJSON({ text: fixJson(jsonText) });
+  if (result.success) {
+    return { value: result.value, state: "repaired-parse" };
+  }
+  return { value: undefined, state: "failed-parse" };
+}
+var text = () => ({
+  name: "text",
+  responseFormat: Promise.resolve({ type: "text" }),
+  async parseCompleteOutput({ text: text2 }) {
+    return text2;
+  },
+  async parsePartialOutput({ text: text2 }) {
+    return { partial: text2 };
+  },
+  createElementStreamTransform() {
+    return;
+  }
+});
+var object2 = ({
+  schema: inputSchema,
+  name: name22,
+  description
+}) => {
+  const schema = asSchema(inputSchema);
+  return {
+    name: "object",
+    responseFormat: resolve(schema.jsonSchema).then((jsonSchema2) => ({
+      type: "json",
+      schema: jsonSchema2,
+      ...name22 != null && { name: name22 },
+      ...description != null && { description }
+    })),
+    async parseCompleteOutput({ text: text2 }, context2) {
+      const parseResult = await safeParseJSON({ text: text2 });
+      if (!parseResult.success) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: could not parse the response.",
+          cause: parseResult.error,
+          text: text2,
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
+        });
+      }
+      const validationResult = await safeValidateTypes({
+        value: parseResult.value,
+        schema
+      });
+      if (!validationResult.success) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: response did not match schema.",
+          cause: validationResult.error,
+          text: text2,
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
+        });
+      }
+      return validationResult.value;
+    },
+    async parsePartialOutput({ text: text2 }) {
+      const result = await parsePartialJson(text2);
+      switch (result.state) {
+        case "failed-parse":
+        case "undefined-input": {
+          return;
+        }
+        case "repaired-parse":
+        case "successful-parse": {
+          return {
+            partial: result.value
+          };
+        }
+      }
+    },
+    createElementStreamTransform() {
+      return;
+    }
+  };
+};
+var array2 = ({
+  element: inputElementSchema,
+  name: name22,
+  description
+}) => {
+  const elementSchema = asSchema(inputElementSchema);
+  return {
+    name: "array",
+    responseFormat: resolve(elementSchema.jsonSchema).then((jsonSchema2) => {
+      const { $schema, ...itemSchema } = jsonSchema2;
+      return {
+        type: "json",
+        schema: {
+          $schema: "http://json-schema.org/draft-07/schema#",
+          type: "object",
+          properties: {
+            elements: { type: "array", items: itemSchema }
+          },
+          required: ["elements"],
+          additionalProperties: false
+        },
+        ...name22 != null && { name: name22 },
+        ...description != null && { description }
+      };
+    }),
+    async parseCompleteOutput({ text: text2 }, context2) {
+      const parseResult = await safeParseJSON({ text: text2 });
+      if (!parseResult.success) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: could not parse the response.",
+          cause: parseResult.error,
+          text: text2,
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
+        });
+      }
+      const outerValue = parseResult.value;
+      if (outerValue == null || typeof outerValue !== "object" || !("elements" in outerValue) || !Array.isArray(outerValue.elements)) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: response did not match schema.",
+          cause: new TypeValidationError({
+            value: outerValue,
+            cause: "response must be an object with an elements array"
+          }),
+          text: text2,
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
+        });
+      }
+      for (const element of outerValue.elements) {
+        const validationResult = await safeValidateTypes({
+          value: element,
+          schema: elementSchema
+        });
+        if (!validationResult.success) {
+          throw new NoObjectGeneratedError({
+            message: "No object generated: response did not match schema.",
+            cause: validationResult.error,
+            text: text2,
+            response: context2.response,
+            usage: context2.usage,
+            finishReason: context2.finishReason
+          });
+        }
+      }
+      return outerValue.elements;
+    },
+    async parsePartialOutput({ text: text2 }) {
+      const result = await parsePartialJson(text2);
+      switch (result.state) {
+        case "failed-parse":
+        case "undefined-input": {
+          return;
+        }
+        case "repaired-parse":
+        case "successful-parse": {
+          const outerValue = result.value;
+          if (outerValue == null || typeof outerValue !== "object" || !("elements" in outerValue) || !Array.isArray(outerValue.elements)) {
+            return;
+          }
+          const rawElements = result.state === "repaired-parse" && outerValue.elements.length > 0 ? outerValue.elements.slice(0, -1) : outerValue.elements;
+          const parsedElements = [];
+          for (const rawElement of rawElements) {
+            const validationResult = await safeValidateTypes({
+              value: rawElement,
+              schema: elementSchema
+            });
+            if (validationResult.success) {
+              parsedElements.push(validationResult.value);
+            }
+          }
+          return { partial: parsedElements };
+        }
+      }
+    },
+    createElementStreamTransform() {
+      let publishedElements = 0;
+      return new TransformStream({
+        transform({ partialOutput }, controller) {
+          if (partialOutput != null) {
+            for (;publishedElements < partialOutput.length; publishedElements++) {
+              controller.enqueue(partialOutput[publishedElements]);
+            }
+          }
+        }
+      });
+    }
+  };
+};
+var choice = ({
+  options: choiceOptions,
+  name: name22,
+  description
+}) => {
+  return {
+    name: "choice",
+    responseFormat: Promise.resolve({
+      type: "json",
+      schema: {
+        $schema: "http://json-schema.org/draft-07/schema#",
+        type: "object",
+        properties: {
+          result: { type: "string", enum: choiceOptions }
+        },
+        required: ["result"],
+        additionalProperties: false
+      },
+      ...name22 != null && { name: name22 },
+      ...description != null && { description }
+    }),
+    async parseCompleteOutput({ text: text2 }, context2) {
+      const parseResult = await safeParseJSON({ text: text2 });
+      if (!parseResult.success) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: could not parse the response.",
+          cause: parseResult.error,
+          text: text2,
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
+        });
+      }
+      const outerValue = parseResult.value;
+      if (outerValue == null || typeof outerValue !== "object" || !("result" in outerValue) || typeof outerValue.result !== "string" || !choiceOptions.includes(outerValue.result)) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: response did not match schema.",
+          cause: new TypeValidationError({
+            value: outerValue,
+            cause: "response must be an object that contains a choice value."
+          }),
+          text: text2,
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
+        });
+      }
+      return outerValue.result;
+    },
+    async parsePartialOutput({ text: text2 }) {
+      const result = await parsePartialJson(text2);
+      switch (result.state) {
+        case "failed-parse":
+        case "undefined-input": {
+          return;
+        }
+        case "repaired-parse":
+        case "successful-parse": {
+          const outerValue = result.value;
+          if (outerValue == null || typeof outerValue !== "object" || !("result" in outerValue) || typeof outerValue.result !== "string") {
+            return;
+          }
+          const potentialMatches = choiceOptions.filter((choiceOption) => choiceOption.startsWith(outerValue.result));
+          if (result.state === "successful-parse") {
+            return potentialMatches.includes(outerValue.result) ? { partial: outerValue.result } : undefined;
+          } else {
+            return potentialMatches.length === 1 ? { partial: potentialMatches[0] } : undefined;
+          }
+        }
+      }
+    },
+    createElementStreamTransform() {
+      return;
+    }
+  };
+};
+var json = ({
+  name: name22,
+  description
+} = {}) => {
+  return {
+    name: "json",
+    responseFormat: Promise.resolve({
+      type: "json",
+      ...name22 != null && { name: name22 },
+      ...description != null && { description }
+    }),
+    async parseCompleteOutput({ text: text2 }, context2) {
+      const parseResult = await safeParseJSON({ text: text2 });
+      if (!parseResult.success) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: could not parse the response.",
+          cause: parseResult.error,
+          text: text2,
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
+        });
+      }
+      return parseResult.value;
+    },
+    async parsePartialOutput({ text: text2 }) {
+      const result = await parsePartialJson(text2);
+      switch (result.state) {
+        case "failed-parse":
+        case "undefined-input": {
+          return;
+        }
+        case "repaired-parse":
+        case "successful-parse": {
+          return result.value === undefined ? undefined : { partial: result.value };
+        }
+      }
+    },
+    createElementStreamTransform() {
+      return;
+    }
+  };
+};
+function stepCountIs(stepCount) {
+  return ({ steps }) => steps.length === stepCount;
+}
+var originalGenerateId = createIdGenerator({
+  prefix: "aitxt",
+  size: 24
+});
+var JsonToSseTransformStream = class extends TransformStream {
+  constructor() {
+    super({
+      transform(part, controller) {
+        controller.enqueue(`data: ${JSON.stringify(part)}
+
+`);
+      },
+      flush(controller) {
+        controller.enqueue(`data: [DONE]
+
+`);
+      }
+    });
+  }
+};
+var toolMetadataSchema = record(string(), jsonValueSchema.optional());
+var uiMessageChunkSchema = lazySchema(() => zodSchema(union([
+  strictObject({
+    type: literal("text-start"),
+    id: string(),
+    providerMetadata: providerMetadataSchema.optional()
+  }),
+  strictObject({
+    type: literal("text-delta"),
+    id: string(),
+    delta: string(),
+    providerMetadata: providerMetadataSchema.optional()
+  }),
+  strictObject({
+    type: literal("text-end"),
+    id: string(),
+    providerMetadata: providerMetadataSchema.optional()
+  }),
+  strictObject({
+    type: literal("error"),
+    errorText: string()
+  }),
+  strictObject({
+    type: literal("tool-input-start"),
+    toolCallId: string(),
+    toolName: string(),
+    providerExecuted: boolean().optional(),
+    providerMetadata: providerMetadataSchema.optional(),
+    toolMetadata: toolMetadataSchema.optional(),
+    dynamic: boolean().optional(),
+    title: string().optional()
+  }),
+  strictObject({
+    type: literal("tool-input-delta"),
+    toolCallId: string(),
+    inputTextDelta: string()
+  }),
+  strictObject({
+    type: literal("tool-input-available"),
+    toolCallId: string(),
+    toolName: string(),
+    input: unknown(),
+    providerExecuted: boolean().optional(),
+    providerMetadata: providerMetadataSchema.optional(),
+    toolMetadata: toolMetadataSchema.optional(),
+    dynamic: boolean().optional(),
+    title: string().optional()
+  }),
+  strictObject({
+    type: literal("tool-input-error"),
+    toolCallId: string(),
+    toolName: string(),
+    input: unknown(),
+    providerExecuted: boolean().optional(),
+    providerMetadata: providerMetadataSchema.optional(),
+    toolMetadata: toolMetadataSchema.optional(),
+    dynamic: boolean().optional(),
+    errorText: string(),
+    title: string().optional()
+  }),
+  strictObject({
+    type: literal("tool-approval-request"),
+    approvalId: string(),
+    toolCallId: string(),
+    signature: string().optional()
+  }),
+  strictObject({
+    type: literal("tool-output-available"),
+    toolCallId: string(),
+    output: unknown(),
+    providerExecuted: boolean().optional(),
+    providerMetadata: providerMetadataSchema.optional(),
+    toolMetadata: toolMetadataSchema.optional(),
+    dynamic: boolean().optional(),
+    preliminary: boolean().optional()
+  }),
+  strictObject({
+    type: literal("tool-output-error"),
+    toolCallId: string(),
+    errorText: string(),
+    providerExecuted: boolean().optional(),
+    providerMetadata: providerMetadataSchema.optional(),
+    toolMetadata: toolMetadataSchema.optional(),
+    dynamic: boolean().optional()
+  }),
+  strictObject({
+    type: literal("tool-output-denied"),
+    toolCallId: string()
+  }),
+  strictObject({
+    type: literal("reasoning-start"),
+    id: string(),
+    providerMetadata: providerMetadataSchema.optional()
+  }),
+  strictObject({
+    type: literal("reasoning-delta"),
+    id: string(),
+    delta: string(),
+    providerMetadata: providerMetadataSchema.optional()
+  }),
+  strictObject({
+    type: literal("reasoning-end"),
+    id: string(),
+    providerMetadata: providerMetadataSchema.optional()
+  }),
+  strictObject({
+    type: literal("source-url"),
+    sourceId: string(),
+    url: string(),
+    title: string().optional(),
+    providerMetadata: providerMetadataSchema.optional()
+  }),
+  strictObject({
+    type: literal("source-document"),
+    sourceId: string(),
+    mediaType: string(),
+    title: string(),
+    filename: string().optional(),
+    providerMetadata: providerMetadataSchema.optional()
+  }),
+  strictObject({
+    type: literal("file"),
+    url: string(),
+    mediaType: string(),
+    providerMetadata: providerMetadataSchema.optional()
+  }),
+  strictObject({
+    type: custom((value) => typeof value === "string" && value.startsWith("data-"), { message: 'Type must start with "data-"' }),
+    id: string().optional(),
+    data: unknown(),
+    transient: boolean().optional()
+  }),
+  strictObject({
+    type: literal("start-step")
+  }),
+  strictObject({
+    type: literal("finish-step")
+  }),
+  strictObject({
+    type: literal("start"),
+    messageId: string().optional(),
+    messageMetadata: unknown().optional()
+  }),
+  strictObject({
+    type: literal("finish"),
+    finishReason: _enum([
+      "stop",
+      "length",
+      "content-filter",
+      "tool-calls",
+      "error",
+      "other"
+    ]).optional(),
+    messageMetadata: unknown().optional()
+  }),
+  strictObject({
+    type: literal("abort"),
+    reason: string().optional()
+  }),
+  strictObject({
+    type: literal("message-metadata"),
+    messageMetadata: unknown()
+  })
+])));
+var originalGenerateId2 = createIdGenerator({
+  prefix: "aitxt",
+  size: 24
+});
+var toolMetadataSchema2 = record(string(), jsonValueSchema.optional());
+var uiMessagesSchema = lazySchema(() => zodSchema(array(object({
+  id: string(),
+  role: _enum(["system", "user", "assistant"]),
+  metadata: unknown().optional(),
+  parts: array(union([
+    object({
+      type: literal("text"),
+      text: string(),
+      state: _enum(["streaming", "done"]).optional(),
+      providerMetadata: providerMetadataSchema.optional()
+    }),
+    object({
+      type: literal("reasoning"),
+      text: string(),
+      state: _enum(["streaming", "done"]).optional(),
+      providerMetadata: providerMetadataSchema.optional()
+    }),
+    object({
+      type: literal("source-url"),
+      sourceId: string(),
+      url: string(),
+      title: string().optional(),
+      providerMetadata: providerMetadataSchema.optional()
+    }),
+    object({
+      type: literal("source-document"),
+      sourceId: string(),
+      mediaType: string(),
+      title: string(),
+      filename: string().optional(),
+      providerMetadata: providerMetadataSchema.optional()
+    }),
+    object({
+      type: literal("file"),
+      mediaType: string(),
+      filename: string().optional(),
+      url: string(),
+      providerMetadata: providerMetadataSchema.optional()
+    }),
+    object({
+      type: literal("step-start")
+    }),
+    object({
+      type: string().startsWith("data-"),
+      id: string().optional(),
+      data: unknown()
+    }),
+    object({
+      type: literal("dynamic-tool"),
+      toolName: string(),
+      toolCallId: string(),
+      toolMetadata: toolMetadataSchema2.optional(),
+      state: literal("input-streaming"),
+      input: unknown().optional(),
+      providerExecuted: boolean().optional(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      output: never().optional(),
+      errorText: never().optional(),
+      approval: never().optional()
+    }),
+    object({
+      type: literal("dynamic-tool"),
+      toolName: string(),
+      toolCallId: string(),
+      toolMetadata: toolMetadataSchema2.optional(),
+      state: literal("input-available"),
+      input: unknown(),
+      providerExecuted: boolean().optional(),
+      output: never().optional(),
+      errorText: never().optional(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      approval: never().optional()
+    }),
+    object({
+      type: literal("dynamic-tool"),
+      toolName: string(),
+      toolCallId: string(),
+      toolMetadata: toolMetadataSchema2.optional(),
+      state: literal("approval-requested"),
+      input: unknown(),
+      providerExecuted: boolean().optional(),
+      output: never().optional(),
+      errorText: never().optional(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      approval: object({
+        id: string(),
+        approved: never().optional(),
+        reason: never().optional(),
+        signature: string().optional()
+      })
+    }),
+    object({
+      type: literal("dynamic-tool"),
+      toolName: string(),
+      toolCallId: string(),
+      toolMetadata: toolMetadataSchema2.optional(),
+      state: literal("approval-responded"),
+      input: unknown(),
+      providerExecuted: boolean().optional(),
+      output: never().optional(),
+      errorText: never().optional(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      approval: object({
+        id: string(),
+        approved: boolean(),
+        reason: string().optional(),
+        signature: string().optional()
+      })
+    }),
+    object({
+      type: literal("dynamic-tool"),
+      toolName: string(),
+      toolCallId: string(),
+      toolMetadata: toolMetadataSchema2.optional(),
+      state: literal("output-available"),
+      input: unknown(),
+      providerExecuted: boolean().optional(),
+      output: unknown(),
+      errorText: never().optional(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      resultProviderMetadata: providerMetadataSchema.optional(),
+      preliminary: boolean().optional(),
+      approval: object({
+        id: string(),
+        approved: literal(true),
+        reason: string().optional(),
+        signature: string().optional()
+      }).optional()
+    }),
+    object({
+      type: literal("dynamic-tool"),
+      toolName: string(),
+      toolCallId: string(),
+      toolMetadata: toolMetadataSchema2.optional(),
+      state: literal("output-error"),
+      input: unknown().optional(),
+      rawInput: unknown().optional(),
+      providerExecuted: boolean().optional(),
+      output: never().optional(),
+      errorText: string(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      resultProviderMetadata: providerMetadataSchema.optional(),
+      approval: object({
+        id: string(),
+        approved: literal(true),
+        reason: string().optional(),
+        signature: string().optional()
+      }).optional()
+    }),
+    object({
+      type: literal("dynamic-tool"),
+      toolName: string(),
+      toolCallId: string(),
+      toolMetadata: toolMetadataSchema2.optional(),
+      state: literal("output-denied"),
+      input: unknown(),
+      providerExecuted: boolean().optional(),
+      output: never().optional(),
+      errorText: never().optional(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      approval: object({
+        id: string(),
+        approved: literal(false),
+        reason: string().optional(),
+        signature: string().optional()
+      })
+    }),
+    object({
+      type: string().startsWith("tool-"),
+      toolCallId: string(),
+      toolMetadata: toolMetadataSchema2.optional(),
+      state: literal("input-streaming"),
+      providerExecuted: boolean().optional(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      input: unknown().optional(),
+      output: never().optional(),
+      errorText: never().optional(),
+      approval: never().optional()
+    }),
+    object({
+      type: string().startsWith("tool-"),
+      toolCallId: string(),
+      toolMetadata: toolMetadataSchema2.optional(),
+      state: literal("input-available"),
+      providerExecuted: boolean().optional(),
+      input: unknown(),
+      output: never().optional(),
+      errorText: never().optional(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      approval: never().optional()
+    }),
+    object({
+      type: string().startsWith("tool-"),
+      toolCallId: string(),
+      toolMetadata: toolMetadataSchema2.optional(),
+      state: literal("approval-requested"),
+      input: unknown(),
+      providerExecuted: boolean().optional(),
+      output: never().optional(),
+      errorText: never().optional(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      approval: object({
+        id: string(),
+        approved: never().optional(),
+        reason: never().optional(),
+        signature: string().optional()
+      })
+    }),
+    object({
+      type: string().startsWith("tool-"),
+      toolCallId: string(),
+      toolMetadata: toolMetadataSchema2.optional(),
+      state: literal("approval-responded"),
+      input: unknown(),
+      providerExecuted: boolean().optional(),
+      output: never().optional(),
+      errorText: never().optional(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      approval: object({
+        id: string(),
+        approved: boolean(),
+        reason: string().optional(),
+        signature: string().optional()
+      })
+    }),
+    object({
+      type: string().startsWith("tool-"),
+      toolCallId: string(),
+      toolMetadata: toolMetadataSchema2.optional(),
+      state: literal("output-available"),
+      providerExecuted: boolean().optional(),
+      input: unknown(),
+      output: unknown(),
+      errorText: never().optional(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      resultProviderMetadata: providerMetadataSchema.optional(),
+      preliminary: boolean().optional(),
+      approval: object({
+        id: string(),
+        approved: literal(true),
+        reason: string().optional(),
+        signature: string().optional()
+      }).optional()
+    }),
+    object({
+      type: string().startsWith("tool-"),
+      toolCallId: string(),
+      toolMetadata: toolMetadataSchema2.optional(),
+      state: literal("output-error"),
+      providerExecuted: boolean().optional(),
+      input: unknown().optional(),
+      rawInput: unknown().optional(),
+      output: never().optional(),
+      errorText: string(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      resultProviderMetadata: providerMetadataSchema.optional(),
+      approval: object({
+        id: string(),
+        approved: literal(true),
+        reason: string().optional(),
+        signature: string().optional()
+      }).optional()
+    }),
+    object({
+      type: string().startsWith("tool-"),
+      toolCallId: string(),
+      toolMetadata: toolMetadataSchema2.optional(),
+      state: literal("output-denied"),
+      providerExecuted: boolean().optional(),
+      input: unknown(),
+      output: never().optional(),
+      errorText: never().optional(),
+      callProviderMetadata: providerMetadataSchema.optional(),
+      approval: object({
+        id: string(),
+        approved: literal(false),
+        reason: string().optional(),
+        signature: string().optional()
+      })
+    })
+  ])).nonempty("Message must contain at least one part")
+})).nonempty("Messages array must not be empty")));
+var originalGenerateId3 = createIdGenerator({ prefix: "aiobj", size: 24 });
+function createDownload(options) {
+  return ({ url, abortSignal }) => download({ url, maxBytes: options == null ? undefined : options.maxBytes, abortSignal });
+}
+var originalGenerateId4 = createIdGenerator({ prefix: "aiobj", size: 24 });
+var defaultDownload = createDownload();
+var name21 = "AI_NoSuchProviderError";
+var marker21 = `vercel.ai.error.${name21}`;
+var symbol21 = Symbol.for(marker21);
+var _a21;
+_a21 = symbol21;
+var defaultDownload2 = createDownload();
+export {
+  stepCountIs
+};