@sdk-it/rpc 0.30.0 → 0.31.0

package/dist/index.js

@@ -1,1324 +1,12 @@
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
-  for (var name16 in all)
-    __defProp(target, name16, { get: all[name16], enumerable: true });
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// node_modules/ai/node_modules/@ai-sdk/provider/dist/index.mjs
-var marker = "vercel.ai.error";
-var symbol = Symbol.for(marker);
-var _a;
-var _AISDKError = class _AISDKError2 extends Error {
-  /**
-   * Creates an AI SDK Error.
-   *
-   * @param {Object} params - The parameters for creating the error.
-   * @param {string} params.name - The name of the error.
-   * @param {string} params.message - The error message.
-   * @param {unknown} [params.cause] - The underlying cause of the error.
-   */
-  constructor({
-    name: name143,
-    message,
-    cause
-  }) {
-    super(message);
-    this[_a] = true;
-    this.name = name143;
-    this.cause = cause;
-  }
-  /**
-   * Checks if the given error is an AI SDK Error.
-   * @param {unknown} error - The error to check.
-   * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
-   */
-  static isInstance(error) {
-    return _AISDKError2.hasMarker(error, marker);
-  }
-  static hasMarker(error, marker153) {
-    const markerSymbol = Symbol.for(marker153);
-    return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
-  }
-};
-_a = symbol;
-var AISDKError = _AISDKError;
-var name = "AI_APICallError";
-var marker2 = `vercel.ai.error.${name}`;
-var symbol2 = Symbol.for(marker2);
-var _a2;
-_a2 = symbol2;
-var name2 = "AI_EmptyResponseBodyError";
-var marker3 = `vercel.ai.error.${name2}`;
-var symbol3 = Symbol.for(marker3);
-var _a3;
-_a3 = symbol3;
-function getErrorMessage(error) {
-  if (error == null) {
-    return "unknown error";
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return JSON.stringify(error);
-}
-var name3 = "AI_InvalidArgumentError";
-var marker4 = `vercel.ai.error.${name3}`;
-var symbol4 = Symbol.for(marker4);
-var _a4;
-var InvalidArgumentError = class extends AISDKError {
-  constructor({
-    message,
-    cause,
-    argument
-  }) {
-    super({ name: name3, message, cause });
-    this[_a4] = true;
-    this.argument = argument;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker4);
-  }
-};
-_a4 = symbol4;
-var name4 = "AI_InvalidPromptError";
-var marker5 = `vercel.ai.error.${name4}`;
-var symbol5 = Symbol.for(marker5);
-var _a5;
-_a5 = symbol5;
-var name5 = "AI_InvalidResponseDataError";
-var marker6 = `vercel.ai.error.${name5}`;
-var symbol6 = Symbol.for(marker6);
-var _a6;
-_a6 = symbol6;
-var name6 = "AI_JSONParseError";
-var marker7 = `vercel.ai.error.${name6}`;
-var symbol7 = Symbol.for(marker7);
-var _a7;
-var JSONParseError = class extends AISDKError {
-  constructor({ text: text2, cause }) {
-    super({
-      name: name6,
-      message: `JSON parsing failed: Text: ${text2}.
-Error message: ${getErrorMessage(cause)}`,
-      cause
-    });
-    this[_a7] = true;
-    this.text = text2;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker7);
-  }
-};
-_a7 = symbol7;
-var name7 = "AI_LoadAPIKeyError";
-var marker8 = `vercel.ai.error.${name7}`;
-var symbol8 = Symbol.for(marker8);
-var _a8;
-_a8 = symbol8;
-var name8 = "AI_LoadSettingError";
-var marker9 = `vercel.ai.error.${name8}`;
-var symbol9 = Symbol.for(marker9);
-var _a9;
-_a9 = symbol9;
-var name9 = "AI_NoContentGeneratedError";
-var marker10 = `vercel.ai.error.${name9}`;
-var symbol10 = Symbol.for(marker10);
-var _a10;
-_a10 = symbol10;
-var name10 = "AI_NoSuchModelError";
-var marker11 = `vercel.ai.error.${name10}`;
-var symbol11 = Symbol.for(marker11);
-var _a11;
-_a11 = symbol11;
-var name11 = "AI_TooManyEmbeddingValuesForCallError";
-var marker12 = `vercel.ai.error.${name11}`;
-var symbol12 = Symbol.for(marker12);
-var _a12;
-_a12 = symbol12;
-var name12 = "AI_TypeValidationError";
-var marker13 = `vercel.ai.error.${name12}`;
-var symbol13 = Symbol.for(marker13);
-var _a13;
-var _TypeValidationError = class _TypeValidationError2 extends AISDKError {
-  constructor({ value, cause }) {
-    super({
-      name: name12,
-      message: `Type validation failed: Value: ${JSON.stringify(value)}.
-Error message: ${getErrorMessage(cause)}`,
-      cause
-    });
-    this[_a13] = true;
-    this.value = value;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker13);
-  }
-  /**
-   * Wraps an error into a TypeValidationError.
-   * If the cause is already a TypeValidationError with the same value, it returns the cause.
-   * Otherwise, it creates a new TypeValidationError.
-   *
-   * @param {Object} params - The parameters for wrapping the error.
-   * @param {unknown} params.value - The value that failed validation.
-   * @param {unknown} params.cause - The original error or cause of the validation failure.
-   * @returns {TypeValidationError} A TypeValidationError instance.
-   */
-  static wrap({
-    value,
-    cause
-  }) {
-    return _TypeValidationError2.isInstance(cause) && cause.value === value ? cause : new _TypeValidationError2({ value, cause });
-  }
-};
-_a13 = symbol13;
-var TypeValidationError = _TypeValidationError;
-var name13 = "AI_UnsupportedFunctionalityError";
-var marker14 = `vercel.ai.error.${name13}`;
-var symbol14 = Symbol.for(marker14);
-var _a14;
-_a14 = symbol14;
-
-// node_modules/ai/node_modules/@ai-sdk/provider-utils/dist/index.mjs
-import * as z4 from "zod/v4";
-import zodToJsonSchema from "zod-to-json-schema";
-var createIdGenerator = ({
-  prefix,
-  size = 16,
-  alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
-  separator = "-"
-} = {}) => {
-  const generator = () => {
-    const alphabetLength = alphabet.length;
-    const chars = new Array(size);
-    for (let i = 0; i < size; i++) {
-      chars[i] = alphabet[Math.random() * alphabetLength | 0];
-    }
-    return chars.join("");
-  };
-  if (prefix == null) {
-    return generator;
-  }
-  if (alphabet.includes(separator)) {
-    throw new InvalidArgumentError({
-      argument: "separator",
-      message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
-    });
-  }
-  return () => `${prefix}${separator}${generator()}`;
-};
-var generateId = createIdGenerator();
-var suspectProtoRx = /"__proto__"\s*:/;
-var suspectConstructorRx = /"constructor"\s*:/;
-function _parse(text2) {
-  const obj = JSON.parse(text2);
-  if (obj === null || typeof obj !== "object") {
-    return obj;
-  }
-  if (suspectProtoRx.test(text2) === false && suspectConstructorRx.test(text2) === false) {
-    return obj;
-  }
-  return filter(obj);
-}
-function filter(obj) {
-  let next = [obj];
-  while (next.length) {
-    const nodes = next;
-    next = [];
-    for (const node of nodes) {
-      if (Object.prototype.hasOwnProperty.call(node, "__proto__")) {
-        throw new SyntaxError("Object contains forbidden prototype property");
-      }
-      if (Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
-        throw new SyntaxError("Object contains forbidden prototype property");
-      }
-      for (const key in node) {
-        const value = node[key];
-        if (value && typeof value === "object") {
-          next.push(value);
-        }
-      }
-    }
-  }
-  return obj;
-}
-function secureJsonParse(text2) {
-  const { stackTraceLimit } = Error;
-  Error.stackTraceLimit = 0;
-  try {
-    return _parse(text2);
-  } finally {
-    Error.stackTraceLimit = stackTraceLimit;
-  }
-}
-var validatorSymbol = Symbol.for("vercel.ai.validator");
-function validator(validate) {
-  return { [validatorSymbol]: true, validate };
-}
-function isValidator(value) {
-  return typeof value === "object" && value !== null && validatorSymbol in value && value[validatorSymbol] === true && "validate" in value;
-}
-function asValidator(value) {
-  return isValidator(value) ? value : standardSchemaValidator(value);
-}
-function standardSchemaValidator(standardSchema) {
-  return validator(async (value) => {
-    const result = await standardSchema["~standard"].validate(value);
-    return result.issues == null ? { success: true, value: result.value } : {
-      success: false,
-      error: new TypeValidationError({
-        value,
-        cause: result.issues
-      })
-    };
-  });
-}
-async function safeValidateTypes({
-  value,
-  schema
-}) {
-  const validator2 = asValidator(schema);
-  try {
-    if (validator2.validate == null) {
-      return { success: true, value, rawValue: value };
-    }
-    const result = await validator2.validate(value);
-    if (result.success) {
-      return { success: true, value: result.value, rawValue: value };
-    }
-    return {
-      success: false,
-      error: TypeValidationError.wrap({ value, cause: result.error }),
-      rawValue: value
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: TypeValidationError.wrap({ value, cause: error }),
-      rawValue: value
-    };
-  }
-}
-async function safeParseJSON({
-  text: text2,
-  schema
-}) {
-  try {
-    const value = secureJsonParse(text2);
-    if (schema == null) {
-      return { success: true, value, rawValue: value };
-    }
-    return await safeValidateTypes({ value, schema });
-  } catch (error) {
-    return {
-      success: false,
-      error: JSONParseError.isInstance(error) ? error : new JSONParseError({ text: text2, cause: error }),
-      rawValue: void 0
-    };
-  }
-}
-function tool(tool2) {
-  return tool2;
-}
-function zod3Schema(zodSchema2, options) {
-  var _a16;
-  const useReferences = (_a16 = options == null ? void 0 : options.useReferences) != null ? _a16 : false;
-  return jsonSchema(
-    zodToJsonSchema(zodSchema2, {
-      $refStrategy: useReferences ? "root" : "none",
-      target: "jsonSchema7"
-      // note: openai mode breaks various gemini conversions
-    }),
-    {
-      validate: async (value) => {
-        const result = await zodSchema2.safeParseAsync(value);
-        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
-      }
-    }
-  );
-}
-function zod4Schema(zodSchema2, options) {
-  var _a16;
-  const useReferences = (_a16 = options == null ? void 0 : options.useReferences) != null ? _a16 : false;
-  const z4JSONSchema = z4.toJSONSchema(zodSchema2, {
-    target: "draft-7",
-    io: "output",
-    reused: useReferences ? "ref" : "inline"
-  });
-  return jsonSchema(z4JSONSchema, {
-    validate: async (value) => {
-      const result = await z4.safeParseAsync(zodSchema2, value);
-      return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
-    }
-  });
-}
-function isZod4Schema(zodSchema2) {
-  return "_zod" in zodSchema2;
-}
-function zodSchema(zodSchema2, options) {
-  if (isZod4Schema(zodSchema2)) {
-    return zod4Schema(zodSchema2, options);
-  } else {
-    return zod3Schema(zodSchema2, options);
-  }
-}
-var schemaSymbol = Symbol.for("vercel.ai.schema");
-function jsonSchema(jsonSchema2, {
-  validate
-} = {}) {
-  return {
-    [schemaSymbol]: true,
-    _type: void 0,
-    // should never be used directly
-    [validatorSymbol]: true,
-    jsonSchema: jsonSchema2,
-    validate
-  };
-}
-function isSchema(value) {
-  return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true && "jsonSchema" in value && "validate" in value;
-}
-function asSchema(schema) {
-  return schema == null ? jsonSchema({
-    properties: {},
-    additionalProperties: false
-  }) : isSchema(schema) ? schema : zodSchema(schema);
-}
-var { btoa, atob } = globalThis;
-
-// node_modules/ai/dist/index.mjs
-import { z } from "zod/v4";
-import { z as z6 } from "zod/v4";
-import { z as z5 } from "zod/v4";
-import { z as z3 } from "zod/v4";
-import { z as z2 } from "zod/v4";
-import { z as z42 } from "zod/v4";
-import { z as z7 } from "zod/v4";
-import { z as z9 } from "zod/v4";
-import { z as z8 } from "zod/v4";
-var __defProp2 = Object.defineProperty;
-var __export2 = (target, all) => {
-  for (var name16 in all)
-    __defProp2(target, name16, { get: all[name16], enumerable: true });
-};
-var name14 = "AI_NoOutputSpecifiedError";
-var marker15 = `vercel.ai.error.${name14}`;
-var symbol15 = Symbol.for(marker15);
-var _a15;
-_a15 = symbol15;
-var name22 = "AI_InvalidArgumentError";
-var marker22 = `vercel.ai.error.${name22}`;
-var symbol22 = Symbol.for(marker22);
-var _a22;
-_a22 = symbol22;
-var name32 = "AI_RetryError";
-var marker32 = `vercel.ai.error.${name32}`;
-var symbol32 = Symbol.for(marker32);
-var _a32;
-_a32 = symbol32;
-var name42 = "AI_DownloadError";
-var marker42 = `vercel.ai.error.${name42}`;
-var symbol42 = Symbol.for(marker42);
-var _a42;
-_a42 = symbol42;
-var name52 = "AI_InvalidDataContentError";
-var marker52 = `vercel.ai.error.${name52}`;
-var symbol52 = Symbol.for(marker52);
-var _a52;
-_a52 = symbol52;
-var dataContentSchema = z.union([
-  z.string(),
-  z.instanceof(Uint8Array),
-  z.instanceof(ArrayBuffer),
-  z.custom(
-    // Buffer might not be available in some environments such as CloudFlare:
-    (value) => {
-      var _a16, _b;
-      return (_b = (_a16 = globalThis.Buffer) == null ? void 0 : _a16.isBuffer(value)) != null ? _b : false;
-    },
-    { message: "Must be a Buffer" }
-  )
-]);
-var name62 = "AI_InvalidMessageRoleError";
-var marker62 = `vercel.ai.error.${name62}`;
-var symbol62 = Symbol.for(marker62);
-var _a62;
-_a62 = symbol62;
-var name72 = "AI_InvalidStreamPartError";
-var marker72 = `vercel.ai.error.${name72}`;
-var symbol72 = Symbol.for(marker72);
-var _a72;
-_a72 = symbol72;
-var name82 = "AI_InvalidToolInputError";
-var marker82 = `vercel.ai.error.${name82}`;
-var symbol82 = Symbol.for(marker82);
-var _a82;
-_a82 = symbol82;
-var name92 = "AI_MCPClientError";
-var marker92 = `vercel.ai.error.${name92}`;
-var symbol92 = Symbol.for(marker92);
-var _a92;
-_a92 = symbol92;
-var name102 = "AI_NoImageGeneratedError";
-var marker102 = `vercel.ai.error.${name102}`;
-var symbol102 = Symbol.for(marker102);
-var _a102;
-_a102 = symbol102;
-var name112 = "AI_NoObjectGeneratedError";
-var marker112 = `vercel.ai.error.${name112}`;
-var symbol112 = Symbol.for(marker112);
-var _a112;
-var NoObjectGeneratedError = class extends AISDKError {
-  constructor({
-    message = "No object generated.",
-    cause,
-    text: text2,
-    response,
-    usage,
-    finishReason
-  }) {
-    super({ name: name112, message, cause });
-    this[_a112] = true;
-    this.text = text2;
-    this.response = response;
-    this.usage = usage;
-    this.finishReason = finishReason;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker112);
-  }
-};
-_a112 = symbol112;
-var name122 = "AI_NoSuchToolError";
-var marker122 = `vercel.ai.error.${name122}`;
-var symbol122 = Symbol.for(marker122);
-var _a122;
-_a122 = symbol122;
-var name132 = "AI_ToolCallRepairError";
-var marker132 = `vercel.ai.error.${name132}`;
-var symbol132 = Symbol.for(marker132);
-var _a132;
-_a132 = symbol132;
-var name142 = "AI_MessageConversionError";
-var marker142 = `vercel.ai.error.${name142}`;
-var symbol142 = Symbol.for(marker142);
-var _a142;
-_a142 = symbol142;
-var jsonValueSchema = z2.lazy(
-  () => z2.union([
-    z2.null(),
-    z2.string(),
-    z2.number(),
-    z2.boolean(),
-    z2.record(z2.string(), jsonValueSchema),
-    z2.array(jsonValueSchema)
-  ])
-);
-var providerMetadataSchema = z3.record(
-  z3.string(),
-  z3.record(z3.string(), jsonValueSchema)
-);
-var textPartSchema = z42.object({
-  type: z42.literal("text"),
-  text: z42.string(),
-  providerOptions: providerMetadataSchema.optional()
-});
-var imagePartSchema = z42.object({
-  type: z42.literal("image"),
-  image: z42.union([dataContentSchema, z42.instanceof(URL)]),
-  mediaType: z42.string().optional(),
-  providerOptions: providerMetadataSchema.optional()
-});
-var filePartSchema = z42.object({
-  type: z42.literal("file"),
-  data: z42.union([dataContentSchema, z42.instanceof(URL)]),
-  filename: z42.string().optional(),
-  mediaType: z42.string(),
-  providerOptions: providerMetadataSchema.optional()
-});
-var reasoningPartSchema = z42.object({
-  type: z42.literal("reasoning"),
-  text: z42.string(),
-  providerOptions: providerMetadataSchema.optional()
-});
-var toolCallPartSchema = z42.object({
-  type: z42.literal("tool-call"),
-  toolCallId: z42.string(),
-  toolName: z42.string(),
-  input: z42.unknown(),
-  providerOptions: providerMetadataSchema.optional(),
-  providerExecuted: z42.boolean().optional()
-});
-var outputSchema = z42.discriminatedUnion("type", [
-  z42.object({
-    type: z42.literal("text"),
-    value: z42.string()
-  }),
-  z42.object({
-    type: z42.literal("json"),
-    value: jsonValueSchema
-  }),
-  z42.object({
-    type: z42.literal("error-text"),
-    value: z42.string()
-  }),
-  z42.object({
-    type: z42.literal("error-json"),
-    value: jsonValueSchema
-  }),
-  z42.object({
-    type: z42.literal("content"),
-    value: z42.array(
-      z42.union([
-        z42.object({
-          type: z42.literal("text"),
-          text: z42.string()
-        }),
-        z42.object({
-          type: z42.literal("media"),
-          data: z42.string(),
-          mediaType: z42.string()
-        })
-      ])
-    )
-  })
-]);
-var toolResultPartSchema = z42.object({
-  type: z42.literal("tool-result"),
-  toolCallId: z42.string(),
-  toolName: z42.string(),
-  output: outputSchema,
-  providerOptions: providerMetadataSchema.optional()
-});
-var systemModelMessageSchema = z5.object(
-  {
-    role: z5.literal("system"),
-    content: z5.string(),
-    providerOptions: providerMetadataSchema.optional()
-  }
-);
-var userModelMessageSchema = z5.object({
-  role: z5.literal("user"),
-  content: z5.union([
-    z5.string(),
-    z5.array(z5.union([textPartSchema, imagePartSchema, filePartSchema]))
-  ]),
-  providerOptions: providerMetadataSchema.optional()
-});
-var assistantModelMessageSchema = z5.object({
-  role: z5.literal("assistant"),
-  content: z5.union([
-    z5.string(),
-    z5.array(
-      z5.union([
-        textPartSchema,
-        filePartSchema,
-        reasoningPartSchema,
-        toolCallPartSchema,
-        toolResultPartSchema
-      ])
-    )
-  ]),
-  providerOptions: providerMetadataSchema.optional()
-});
-var toolModelMessageSchema = z5.object({
-  role: z5.literal("tool"),
-  content: z5.array(toolResultPartSchema),
-  providerOptions: providerMetadataSchema.optional()
-});
-var modelMessageSchema = z5.union([
-  systemModelMessageSchema,
-  userModelMessageSchema,
-  assistantModelMessageSchema,
-  toolModelMessageSchema
-]);
-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]\n\n");
-      }
-    });
-  }
-};
-var uiMessageChunkSchema = z7.union([
-  z7.strictObject({
-    type: z7.literal("text-start"),
-    id: z7.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("text-delta"),
-    id: z7.string(),
-    delta: z7.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("text-end"),
-    id: z7.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("error"),
-    errorText: z7.string()
-  }),
-  z7.strictObject({
-    type: z7.literal("tool-input-start"),
-    toolCallId: z7.string(),
-    toolName: z7.string(),
-    providerExecuted: z7.boolean().optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("tool-input-delta"),
-    toolCallId: z7.string(),
-    inputTextDelta: z7.string()
-  }),
-  z7.strictObject({
-    type: z7.literal("tool-input-available"),
-    toolCallId: z7.string(),
-    toolName: z7.string(),
-    input: z7.unknown(),
-    providerExecuted: z7.boolean().optional(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("tool-output-available"),
-    toolCallId: z7.string(),
-    output: z7.unknown(),
-    providerExecuted: z7.boolean().optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("tool-output-error"),
-    toolCallId: z7.string(),
-    errorText: z7.string(),
-    providerExecuted: z7.boolean().optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("reasoning"),
-    text: z7.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("reasoning-start"),
-    id: z7.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("reasoning-delta"),
-    id: z7.string(),
-    delta: z7.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("reasoning-end"),
-    id: z7.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("reasoning-part-finish")
-  }),
-  z7.strictObject({
-    type: z7.literal("source-url"),
-    sourceId: z7.string(),
-    url: z7.string(),
-    title: z7.string().optional(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("source-document"),
-    sourceId: z7.string(),
-    mediaType: z7.string(),
-    title: z7.string(),
-    filename: z7.string().optional(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("file"),
-    url: z7.string(),
-    mediaType: z7.string(),
-    providerMetadata: providerMetadataSchema.optional()
-  }),
-  z7.strictObject({
-    type: z7.string().startsWith("data-"),
-    id: z7.string().optional(),
-    data: z7.unknown(),
-    transient: z7.boolean().optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("start-step")
-  }),
-  z7.strictObject({
-    type: z7.literal("finish-step")
-  }),
-  z7.strictObject({
-    type: z7.literal("start"),
-    messageId: z7.string().optional(),
-    messageMetadata: z7.unknown().optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("finish"),
-    messageMetadata: z7.unknown().optional()
-  }),
-  z7.strictObject({
-    type: z7.literal("abort")
-  }),
-  z7.strictObject({
-    type: z7.literal("message-metadata"),
-    messageMetadata: z7.unknown()
-  })
-]);
-function fixJson(input) {
-  const stack = ["ROOT"];
-  let lastValidIndex = -1;
-  let literalStart = null;
-  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();
-        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 === void 0) {
-    return { value: void 0, 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: void 0, state: "failed-parse" };
-}
-var originalGenerateId2 = createIdGenerator({
-  prefix: "aitxt",
-  size: 24
-});
-var originalGenerateId3 = createIdGenerator({ prefix: "aiobj", size: 24 });
-var originalGenerateId4 = createIdGenerator({ prefix: "aiobj", size: 24 });
-var output_exports = {};
-__export2(output_exports, {
-  object: () => object,
-  text: () => text
-});
-var text = () => ({
-  type: "text",
-  responseFormat: { type: "text" },
-  async parsePartial({ text: text2 }) {
-    return { partial: text2 };
-  },
-  async parseOutput({ text: text2 }) {
-    return text2;
-  }
-});
-var object = ({
-  schema: inputSchema
-}) => {
-  const schema = asSchema(inputSchema);
-  return {
-    type: "object",
-    responseFormat: {
-      type: "json",
-      schema: schema.jsonSchema
-    },
-    async parsePartial({ text: text2 }) {
-      const result = await parsePartialJson(text2);
-      switch (result.state) {
-        case "failed-parse":
-        case "undefined-input":
-          return void 0;
-        case "repaired-parse":
-        case "successful-parse":
-          return {
-            // Note: currently no validation of partial results:
-            partial: result.value
-          };
-        default: {
-          const _exhaustiveCheck = result.state;
-          throw new Error(`Unsupported parse state: ${_exhaustiveCheck}`);
-        }
-      }
-    },
-    async parseOutput({ text: text2 }, context) {
-      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: context.response,
-          usage: context.usage,
-          finishReason: context.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: context.response,
-          usage: context.usage,
-          finishReason: context.finishReason
-        });
-      }
-      return validationResult.value;
-    }
-  };
-};
-var name15 = "AI_NoSuchProviderError";
-var marker152 = `vercel.ai.error.${name15}`;
-var symbol152 = Symbol.for(marker152);
-var _a152;
-_a152 = symbol152;
-var ClientOrServerImplementationSchema = z8.object({
-  name: z8.string(),
-  version: z8.string()
-}).passthrough();
-var BaseParamsSchema = z8.object({
-  _meta: z8.optional(z8.object({}).passthrough())
-}).passthrough();
-var ResultSchema = BaseParamsSchema;
-var RequestSchema = z8.object({
-  method: z8.string(),
-  params: z8.optional(BaseParamsSchema)
-});
-var ServerCapabilitiesSchema = z8.object({
-  experimental: z8.optional(z8.object({}).passthrough()),
-  logging: z8.optional(z8.object({}).passthrough()),
-  prompts: z8.optional(
-    z8.object({
-      listChanged: z8.optional(z8.boolean())
-    }).passthrough()
-  ),
-  resources: z8.optional(
-    z8.object({
-      subscribe: z8.optional(z8.boolean()),
-      listChanged: z8.optional(z8.boolean())
-    }).passthrough()
-  ),
-  tools: z8.optional(
-    z8.object({
-      listChanged: z8.optional(z8.boolean())
-    }).passthrough()
-  )
-}).passthrough();
-var InitializeResultSchema = ResultSchema.extend({
-  protocolVersion: z8.string(),
-  capabilities: ServerCapabilitiesSchema,
-  serverInfo: ClientOrServerImplementationSchema,
-  instructions: z8.optional(z8.string())
-});
-var PaginatedResultSchema = ResultSchema.extend({
-  nextCursor: z8.optional(z8.string())
-});
-var ToolSchema = z8.object({
-  name: z8.string(),
-  description: z8.optional(z8.string()),
-  inputSchema: z8.object({
-    type: z8.literal("object"),
-    properties: z8.optional(z8.object({}).passthrough())
-  }).passthrough()
-}).passthrough();
-var ListToolsResultSchema = PaginatedResultSchema.extend({
-  tools: z8.array(ToolSchema)
-});
-var TextContentSchema = z8.object({
-  type: z8.literal("text"),
-  text: z8.string()
-}).passthrough();
-var ImageContentSchema = z8.object({
-  type: z8.literal("image"),
-  data: z8.string().base64(),
-  mimeType: z8.string()
-}).passthrough();
-var ResourceContentsSchema = z8.object({
-  /**
-   * The URI of this resource.
-   */
-  uri: z8.string(),
-  /**
-   * The MIME type of this resource, if known.
-   */
-  mimeType: z8.optional(z8.string())
-}).passthrough();
-var TextResourceContentsSchema = ResourceContentsSchema.extend({
-  text: z8.string()
-});
-var BlobResourceContentsSchema = ResourceContentsSchema.extend({
-  blob: z8.string().base64()
-});
-var EmbeddedResourceSchema = z8.object({
-  type: z8.literal("resource"),
-  resource: z8.union([TextResourceContentsSchema, BlobResourceContentsSchema])
-}).passthrough();
-var CallToolResultSchema = ResultSchema.extend({
-  content: z8.array(
-    z8.union([TextContentSchema, ImageContentSchema, EmbeddedResourceSchema])
-  ),
-  isError: z8.boolean().default(false).optional()
-}).or(
-  ResultSchema.extend({
-    toolResult: z8.unknown()
-  })
-);
-var JSONRPC_VERSION = "2.0";
-var JSONRPCRequestSchema = z9.object({
-  jsonrpc: z9.literal(JSONRPC_VERSION),
-  id: z9.union([z9.string(), z9.number().int()])
-}).merge(RequestSchema).strict();
-var JSONRPCResponseSchema = z9.object({
-  jsonrpc: z9.literal(JSONRPC_VERSION),
-  id: z9.union([z9.string(), z9.number().int()]),
-  result: ResultSchema
-}).strict();
-var JSONRPCErrorSchema = z9.object({
-  jsonrpc: z9.literal(JSONRPC_VERSION),
-  id: z9.union([z9.string(), z9.number().int()]),
-  error: z9.object({
-    code: z9.number().int(),
-    message: z9.string(),
-    data: z9.optional(z9.unknown())
-  })
-}).strict();
-var JSONRPCNotificationSchema = z9.object({
-  jsonrpc: z9.literal(JSONRPC_VERSION)
-}).merge(
-  z9.object({
-    method: z9.string(),
-    params: z9.optional(BaseParamsSchema)
-  })
-).strict();
-var JSONRPCMessageSchema = z9.union([
-  JSONRPCRequestSchema,
-  JSONRPCNotificationSchema,
-  JSONRPCResponseSchema,
-  JSONRPCErrorSchema
-]);
-
 // packages/rpc/src/lib/rpc.ts
-import { z as z12 } from "zod";
+import { tool } from "ai";
+import { z as z3 } from "zod";
 import { forEachOperation, loadSpec, toIR } from "@sdk-it/spec";
 import {
   buildInput,
@@ -1328,7 +16,7 @@ import {
 } from "@sdk-it/typescript";
 
 // packages/rpc/src/lib/http/dispatcher.ts
-import z10 from "zod";
+import z from "zod";
 
 // packages/rpc/src/lib/http/interceptors.ts
 var createHeadersInterceptor = (defaultHeaders, requestHeaders) => {
@@ -1516,8 +204,8 @@ async function buffered(response) {
     case "application/xml":
       return response.text();
     case "application/x-www-form-urlencoded": {
-      const text2 = await response.text();
-      return Object.fromEntries(new URLSearchParams(text2));
+      const text = await response.text();
+      return Object.fromEntries(new URLSearchParams(text));
     }
     case "multipart/form-data":
       return response.formData();
@@ -1898,7 +586,7 @@ var GatewayTimeout = class _GatewayTimeout extends APIError {
 };
 
 // packages/rpc/src/lib/http/dispatcher.ts
-var fetchType = z10.function().args(z10.instanceof(Request)).returns(z10.promise(z10.instanceof(Response))).optional();
+var fetchType = z.function().args(z.instanceof(Request)).returns(z.promise(z.instanceof(Response))).optional();
 async function parse2(outputs, response) {
   let output = null;
   let parser = buffered;
@@ -1968,7 +656,8 @@ var Dispatcher = class {
 };
 
 // packages/rpc/src/lib/zod.ts
-import { z as z11 } from "zod";
+import { isRef } from "@sdk-it/core";
+import { z as z2 } from "zod";
 var RuntimeZodConverter = class {
   constructor(resolveRef) {
     this.resolveRef = resolveRef;
@@ -1982,13 +671,13 @@ var RuntimeZodConverter = class {
       const isRequired = required.includes(key);
       shape[key] = this.handle(propSchema, isRequired);
     }
-    let result = z11.object(shape);
+    let result = z2.object(shape);
     if (schema.additionalProperties) {
       if (typeof schema.additionalProperties === "object") {
         const addPropSchema = this.handle(schema.additionalProperties, true);
         result = result.catchall(addPropSchema);
       } else if (schema.additionalProperties === true) {
-        result = result.catchall(z11.unknown());
+        result = result.catchall(z2.unknown());
       }
     }
     return result;
@@ -1996,20 +685,20 @@ var RuntimeZodConverter = class {
   #array(schema) {
     const { items } = schema;
     if (!items) {
-      let result2 = z11.array(z11.unknown());
+      let result2 = z2.array(z2.unknown());
       if (schema.default !== void 0) {
-        result2 = z11.array(z11.unknown()).default(schema.default);
+        result2 = z2.array(z2.unknown()).default(schema.default);
       }
       return result2;
     }
     if (Array.isArray(items)) {
       const tupleItems = items.map((sub) => this.handle(sub, true));
-      return z11.tuple(tupleItems);
+      return z2.tuple(tupleItems);
     }
     const itemsSchema = this.handle(items, true);
-    let result = z11.array(itemsSchema);
+    let result = z2.array(itemsSchema);
     if (schema.default !== void 0) {
-      result = z11.array(itemsSchema).default(schema.default);
+      result = z2.array(itemsSchema).default(schema.default);
     }
     return result;
   }
@@ -2024,21 +713,21 @@ var RuntimeZodConverter = class {
       );
     }
     const resolvedSchema = this.resolveRef($ref);
-    const zodSchema2 = this.handle(resolvedSchema, true);
-    this.#resolvedRefs.set($ref, zodSchema2);
-    return zodSchema2;
+    const zodSchema = this.handle(resolvedSchema, true);
+    this.#resolvedRefs.set($ref, zodSchema);
+    return zodSchema;
   }
   #toIntersection(schemas) {
     const [left, ...right] = schemas;
     if (!right.length) {
       return left;
     }
-    return z11.intersection(left, this.#toIntersection(right));
+    return z2.intersection(left, this.#toIntersection(right));
   }
   allOf(schemas) {
     const allOfSchemas = schemas.map((sub) => this.handle(sub, true));
     if (allOfSchemas.length === 0) {
-      return z11.unknown();
+      return z2.unknown();
     }
     if (allOfSchemas.length === 1) {
       return allOfSchemas[0];
@@ -2050,76 +739,76 @@ var RuntimeZodConverter = class {
     if (anyOfSchemas.length === 1) {
       return anyOfSchemas[0];
     }
-    return z11.union(anyOfSchemas);
+    return z2.union(anyOfSchemas);
   }
   oneOf(schemas) {
     const oneOfSchemas = schemas.map((sub) => this.handle(sub, true));
     if (oneOfSchemas.length === 1) {
       return oneOfSchemas[0];
     }
-    return z11.union(oneOfSchemas);
+    return z2.union(oneOfSchemas);
   }
   enum(type, values) {
     if (values.length === 1) {
-      return z11.literal(values[0]);
+      return z2.literal(values[0]);
     }
     if (type === "integer") {
       if (values.length >= 2) {
         const [first, second, ...rest] = values.map(
-          (val) => z11.literal(val)
+          (val) => z2.literal(val)
         );
-        return z11.union([first, second, ...rest]);
+        return z2.union([first, second, ...rest]);
       }
-      return z11.literal(values[0]);
+      return z2.literal(values[0]);
     }
     const stringValues = values;
     if (stringValues.length >= 2) {
       const [first, ...rest] = stringValues;
-      return z11.enum([first, ...rest]);
+      return z2.enum([first, ...rest]);
     }
-    return z11.literal(stringValues[0]);
+    return z2.literal(stringValues[0]);
   }
   /**
    * Handle a `string` schema with possible format keywords (JSON Schema).
    */
   string(schema) {
     if (schema.contentEncoding === "binary") {
-      return z11.instanceof(Blob);
+      return z2.instanceof(Blob);
     }
-    let base = z11.string();
+    let base = z2.string();
     switch (schema.format) {
       case "date-time":
       case "datetime":
-        base = z11.string().datetime();
+        base = z2.string().datetime();
         break;
       case "date":
-        base = z11.coerce.date();
+        base = z2.coerce.date();
         break;
       case "time":
-        base = z11.string();
+        base = z2.string();
         break;
       case "email":
-        base = z11.string().email();
+        base = z2.string().email();
         break;
       case "uuid":
-        base = z11.string().uuid();
+        base = z2.string().uuid();
         break;
       case "url":
       case "uri":
-        base = z11.string().url();
+        base = z2.string().url();
         break;
       case "ipv4":
-        base = z11.string().ip({ version: "v4" });
+        base = z2.string().ip({ version: "v4" });
         break;
       case "ipv6":
-        base = z11.string().ip({ version: "v6" });
+        base = z2.string().ip({ version: "v6" });
         break;
       case "byte":
       case "binary":
-        base = z11.instanceof(Blob);
+        base = z2.instanceof(Blob);
         break;
       case "int64":
-        base = z11.string();
+        base = z2.string();
         break;
       default:
         break;
@@ -2130,12 +819,12 @@ var RuntimeZodConverter = class {
    * Handle number/integer constraints from OpenAPI/JSON Schema.
    */
   #number(schema) {
-    let base = z11.number();
+    let base = z2.number();
     if (schema.format === "int64") {
-      base = z11.bigint();
+      base = z2.bigint();
     }
     if (schema.format === "int32") {
-      base = z11.number().int();
+      base = z2.number().int();
     }
     if (typeof schema.exclusiveMinimum === "number") {
       if (schema.format === "int64") {
@@ -2188,7 +877,7 @@ var RuntimeZodConverter = class {
         base = this.#number(schema);
         break;
       case "boolean":
-        base = z11.boolean();
+        base = z2.boolean();
         break;
       case "object":
         base = this.#object(schema);
@@ -2197,10 +886,10 @@ var RuntimeZodConverter = class {
         base = this.#array(schema);
         break;
       case "null":
-        base = z11.null();
+        base = z2.null();
         break;
       default:
-        base = z11.unknown();
+        base = z2.unknown();
         break;
     }
     if (nullable) {
@@ -2208,7 +897,7 @@ var RuntimeZodConverter = class {
     }
     if (schema.default !== void 0) {
       if (schema.format === "int64" && typeof schema.default === "number") {
-        base = z11.bigint().default(BigInt(schema.default));
+        base = z2.bigint().default(BigInt(schema.default));
       } else {
         const defaultValue = schema.default;
         switch (type) {
@@ -2220,7 +909,7 @@ var RuntimeZodConverter = class {
             base = this.#number(schema);
             break;
           case "boolean":
-            base = z11.boolean().default(defaultValue);
+            base = z2.boolean().default(defaultValue);
             break;
           case "object":
             base = this.#object(schema).default(defaultValue);
@@ -2228,10 +917,10 @@ var RuntimeZodConverter = class {
           case "array":
             break;
           case "null":
-            base = z11.null().default(defaultValue);
+            base = z2.null().default(defaultValue);
             break;
           default:
-            base = z11.unknown().default(defaultValue);
+            base = z2.unknown().default(defaultValue);
             break;
         }
       }
@@ -2250,7 +939,7 @@ var RuntimeZodConverter = class {
     return base;
   }
   handle(schema, required = false) {
-    if ("$ref" in schema) {
+    if (isRef(schema)) {
       let result = this.#ref(schema.$ref);
       if (!required) {
         result = result.optional();
@@ -2285,23 +974,23 @@ var RuntimeZodConverter = class {
         const enumValues = schema.enum;
         const enumType = schema.type;
         if (enumValues.length === 1) {
-          result = z11.literal(enumValues[0]).default(defaultValue);
+          result = z2.literal(enumValues[0]).default(defaultValue);
         } else if (enumType === "integer") {
           if (enumValues.length >= 2) {
             const [first, second, ...rest] = enumValues.map(
-              (val) => z11.literal(val)
+              (val) => z2.literal(val)
             );
-            result = z11.union([first, second, ...rest]).default(defaultValue);
+            result = z2.union([first, second, ...rest]).default(defaultValue);
           } else {
-            result = z11.literal(enumValues[0]).default(defaultValue);
+            result = z2.literal(enumValues[0]).default(defaultValue);
           }
         } else {
           const stringValues = enumValues;
           if (stringValues.length >= 2) {
             const [first, ...rest] = stringValues;
-            result = z11.enum([first, ...rest]).default(defaultValue);
+            result = z2.enum([first, ...rest]).default(defaultValue);
           } else {
-            result = z11.literal(stringValues[0]).default(defaultValue);
+            result = z2.literal(stringValues[0]).default(defaultValue);
           }
         }
       }
@@ -2317,7 +1006,7 @@ var RuntimeZodConverter = class {
       types.push("null");
     }
     if (!types.length) {
-      return required ? z11.unknown() : z11.unknown().optional();
+      return required ? z2.unknown() : z2.unknown().optional();
     }
     if (types.length > 1) {
       const realTypes = types.filter((t) => t !== "null");
@@ -2327,7 +1016,7 @@ var RuntimeZodConverter = class {
       const subSchemas = types.map((t) => this.normal(t, schema, true));
       if (subSchemas.length >= 2) {
         const [first, second, ...rest] = subSchemas;
-        let result = z11.union([first, second, ...rest]);
+        let result = z2.union([first, second, ...rest]);
         if (!required) {
           result = result.optional();
         }
@@ -2343,10 +1032,10 @@ function schemaToZod(schema, options) {
 }
 
 // packages/rpc/src/lib/rpc.ts
-var optionsSchema = z12.object({
-  token: z12.string().optional().transform((val) => val ? `Bearer ${val}` : void 0),
+var optionsSchema = z3.object({
+  token: z3.string().optional().transform((val) => val ? `Bearer ${val}` : void 0),
   fetch: fetchType,
-  baseUrl: z12.string()
+  baseUrl: z3.string()
 });
 var Client = class {
   options;