@sdk-it/rpc 0.29.0 → 0.30.0

package/dist/index.js

@@ -1,16 +1,1334 @@
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name16 in all)
+    __defProp(target, name16, { get: all[name16], 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 z2 } from "zod";
-import { augmentSpec, forEachOperation, loadSpec } from "@sdk-it/spec";
-import { buildInput, inputToPath, toHttpOutput } from "@sdk-it/typescript";
+import { z as z12 } from "zod";
+import { forEachOperation, loadSpec, toIR } from "@sdk-it/spec";
+import {
+  buildInput,
+  inputToPath,
+  operationSchema,
+  toHttpOutput
+} from "@sdk-it/typescript";
 
 // packages/rpc/src/lib/http/dispatcher.ts
-import z from "zod";
+import z10 from "zod";
 
 // packages/rpc/src/lib/http/interceptors.ts
 var createHeadersInterceptor = (defaultHeaders, requestHeaders) => {
@@ -198,8 +1516,8 @@ async function buffered(response) {
     case "application/xml":
       return response.text();
     case "application/x-www-form-urlencoded": {
-      const text = await response.text();
-      return Object.fromEntries(new URLSearchParams(text));
+      const text2 = await response.text();
+      return Object.fromEntries(new URLSearchParams(text2));
     }
     case "multipart/form-data":
       return response.formData();
@@ -580,7 +1898,7 @@ var GatewayTimeout = class _GatewayTimeout extends APIError {
 };
 
 // packages/rpc/src/lib/http/dispatcher.ts
-var fetchType = z.function().args(z.instanceof(Request)).returns(z.promise(z.instanceof(Response))).optional();
+var fetchType = z10.function().args(z10.instanceof(Request)).returns(z10.promise(z10.instanceof(Response))).optional();
 async function parse2(outputs, response) {
   let output = null;
   let parser = buffered;
@@ -649,11 +1967,386 @@ var Dispatcher = class {
   }
 };
 
+// packages/rpc/src/lib/zod.ts
+import { z as z11 } from "zod";
+var RuntimeZodConverter = class {
+  constructor(resolveRef) {
+    this.resolveRef = resolveRef;
+  }
+  #resolvedRefs = /* @__PURE__ */ new Map();
+  #object(schema) {
+    const properties = schema.properties || {};
+    const required = schema.required || [];
+    const shape = {};
+    for (const [key, propSchema] of Object.entries(properties)) {
+      const isRequired = required.includes(key);
+      shape[key] = this.handle(propSchema, isRequired);
+    }
+    let result = z11.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());
+      }
+    }
+    return result;
+  }
+  #array(schema) {
+    const { items } = schema;
+    if (!items) {
+      let result2 = z11.array(z11.unknown());
+      if (schema.default !== void 0) {
+        result2 = z11.array(z11.unknown()).default(schema.default);
+      }
+      return result2;
+    }
+    if (Array.isArray(items)) {
+      const tupleItems = items.map((sub) => this.handle(sub, true));
+      return z11.tuple(tupleItems);
+    }
+    const itemsSchema = this.handle(items, true);
+    let result = z11.array(itemsSchema);
+    if (schema.default !== void 0) {
+      result = z11.array(itemsSchema).default(schema.default);
+    }
+    return result;
+  }
+  #ref($ref) {
+    const cached = this.#resolvedRefs.get($ref);
+    if (cached) {
+      return cached;
+    }
+    if (!this.resolveRef) {
+      throw new Error(
+        `Cannot resolve reference ${$ref} - no resolver provided`
+      );
+    }
+    const resolvedSchema = this.resolveRef($ref);
+    const zodSchema2 = this.handle(resolvedSchema, true);
+    this.#resolvedRefs.set($ref, zodSchema2);
+    return zodSchema2;
+  }
+  #toIntersection(schemas) {
+    const [left, ...right] = schemas;
+    if (!right.length) {
+      return left;
+    }
+    return z11.intersection(left, this.#toIntersection(right));
+  }
+  allOf(schemas) {
+    const allOfSchemas = schemas.map((sub) => this.handle(sub, true));
+    if (allOfSchemas.length === 0) {
+      return z11.unknown();
+    }
+    if (allOfSchemas.length === 1) {
+      return allOfSchemas[0];
+    }
+    return this.#toIntersection(allOfSchemas);
+  }
+  anyOf(schemas) {
+    const anyOfSchemas = schemas.map((sub) => this.handle(sub, true));
+    if (anyOfSchemas.length === 1) {
+      return anyOfSchemas[0];
+    }
+    return z11.union(anyOfSchemas);
+  }
+  oneOf(schemas) {
+    const oneOfSchemas = schemas.map((sub) => this.handle(sub, true));
+    if (oneOfSchemas.length === 1) {
+      return oneOfSchemas[0];
+    }
+    return z11.union(oneOfSchemas);
+  }
+  enum(type, values) {
+    if (values.length === 1) {
+      return z11.literal(values[0]);
+    }
+    if (type === "integer") {
+      if (values.length >= 2) {
+        const [first, second, ...rest] = values.map(
+          (val) => z11.literal(val)
+        );
+        return z11.union([first, second, ...rest]);
+      }
+      return z11.literal(values[0]);
+    }
+    const stringValues = values;
+    if (stringValues.length >= 2) {
+      const [first, ...rest] = stringValues;
+      return z11.enum([first, ...rest]);
+    }
+    return z11.literal(stringValues[0]);
+  }
+  /**
+   * Handle a `string` schema with possible format keywords (JSON Schema).
+   */
+  string(schema) {
+    if (schema.contentEncoding === "binary") {
+      return z11.instanceof(Blob);
+    }
+    let base = z11.string();
+    switch (schema.format) {
+      case "date-time":
+      case "datetime":
+        base = z11.string().datetime();
+        break;
+      case "date":
+        base = z11.coerce.date();
+        break;
+      case "time":
+        base = z11.string();
+        break;
+      case "email":
+        base = z11.string().email();
+        break;
+      case "uuid":
+        base = z11.string().uuid();
+        break;
+      case "url":
+      case "uri":
+        base = z11.string().url();
+        break;
+      case "ipv4":
+        base = z11.string().ip({ version: "v4" });
+        break;
+      case "ipv6":
+        base = z11.string().ip({ version: "v6" });
+        break;
+      case "byte":
+      case "binary":
+        base = z11.instanceof(Blob);
+        break;
+      case "int64":
+        base = z11.string();
+        break;
+      default:
+        break;
+    }
+    return base;
+  }
+  /**
+   * Handle number/integer constraints from OpenAPI/JSON Schema.
+   */
+  #number(schema) {
+    let base = z11.number();
+    if (schema.format === "int64") {
+      base = z11.bigint();
+    }
+    if (schema.format === "int32") {
+      base = z11.number().int();
+    }
+    if (typeof schema.exclusiveMinimum === "number") {
+      if (schema.format === "int64") {
+        base = base.gt(BigInt(schema.exclusiveMinimum));
+      } else {
+        base = base.gt(schema.exclusiveMinimum);
+      }
+    }
+    if (typeof schema.exclusiveMaximum === "number") {
+      if (schema.format === "int64") {
+        base = base.lt(BigInt(schema.exclusiveMaximum));
+      } else {
+        base = base.lt(schema.exclusiveMaximum);
+      }
+    }
+    if (typeof schema.minimum === "number") {
+      if (schema.format === "int64") {
+        base = base.min(BigInt(schema.minimum));
+      } else {
+        base = base.min(schema.minimum);
+      }
+    }
+    if (typeof schema.maximum === "number") {
+      if (schema.format === "int64") {
+        base = base.max(BigInt(schema.maximum));
+      } else {
+        base = base.max(schema.maximum);
+      }
+    }
+    if (typeof schema.multipleOf === "number") {
+      const multipleOf = schema.multipleOf;
+      base = base.refine(
+        (val) => Number.isInteger(Number(val) / multipleOf),
+        `Must be a multiple of ${multipleOf}`
+      );
+    }
+    return base;
+  }
+  /**
+   * Convert a basic type to Zod schema with proper chaining
+   */
+  normal(type, schema, required = false, nullable = false) {
+    let base;
+    switch (type) {
+      case "string":
+        base = this.string(schema);
+        break;
+      case "number":
+      case "integer":
+        base = this.#number(schema);
+        break;
+      case "boolean":
+        base = z11.boolean();
+        break;
+      case "object":
+        base = this.#object(schema);
+        break;
+      case "array":
+        base = this.#array(schema);
+        break;
+      case "null":
+        base = z11.null();
+        break;
+      default:
+        base = z11.unknown();
+        break;
+    }
+    if (nullable) {
+      base = base.nullable();
+    }
+    if (schema.default !== void 0) {
+      if (schema.format === "int64" && typeof schema.default === "number") {
+        base = z11.bigint().default(BigInt(schema.default));
+      } else {
+        const defaultValue = schema.default;
+        switch (type) {
+          case "string":
+            base = this.string(schema).default(defaultValue);
+            break;
+          case "number":
+          case "integer":
+            base = this.#number(schema);
+            break;
+          case "boolean":
+            base = z11.boolean().default(defaultValue);
+            break;
+          case "object":
+            base = this.#object(schema).default(defaultValue);
+            break;
+          case "array":
+            break;
+          case "null":
+            base = z11.null().default(defaultValue);
+            break;
+          default:
+            base = z11.unknown().default(defaultValue);
+            break;
+        }
+      }
+    }
+    if (!required) {
+      base = base.optional();
+    }
+    if (schema["x-prefix"]) {
+      const prefix = schema["x-prefix"];
+      if (!required) {
+        base = base.transform((val) => val ? `${prefix}${val}` : void 0);
+      } else {
+        base = base.transform((val) => `${prefix}${val}`);
+      }
+    }
+    return base;
+  }
+  handle(schema, required = false) {
+    if ("$ref" in schema) {
+      let result = this.#ref(schema.$ref);
+      if (!required) {
+        result = result.optional();
+      }
+      return result;
+    }
+    if (schema.allOf && Array.isArray(schema.allOf)) {
+      let result = this.allOf(schema.allOf);
+      if (!required) {
+        result = result.optional();
+      }
+      return result;
+    }
+    if (schema.anyOf && Array.isArray(schema.anyOf)) {
+      let result = this.anyOf(schema.anyOf);
+      if (!required) {
+        result = result.optional();
+      }
+      return result;
+    }
+    if (schema.oneOf && Array.isArray(schema.oneOf) && schema.oneOf.length) {
+      let result = this.oneOf(schema.oneOf);
+      if (!required) {
+        result = result.optional();
+      }
+      return result;
+    }
+    if (schema.enum && Array.isArray(schema.enum)) {
+      let result = this.enum(schema.type, schema.enum);
+      if (schema.default !== void 0 && schema.enum.includes(schema.default)) {
+        const defaultValue = schema.default;
+        const enumValues = schema.enum;
+        const enumType = schema.type;
+        if (enumValues.length === 1) {
+          result = z11.literal(enumValues[0]).default(defaultValue);
+        } else if (enumType === "integer") {
+          if (enumValues.length >= 2) {
+            const [first, second, ...rest] = enumValues.map(
+              (val) => z11.literal(val)
+            );
+            result = z11.union([first, second, ...rest]).default(defaultValue);
+          } else {
+            result = z11.literal(enumValues[0]).default(defaultValue);
+          }
+        } else {
+          const stringValues = enumValues;
+          if (stringValues.length >= 2) {
+            const [first, ...rest] = stringValues;
+            result = z11.enum([first, ...rest]).default(defaultValue);
+          } else {
+            result = z11.literal(stringValues[0]).default(defaultValue);
+          }
+        }
+      }
+      if (!required) {
+        result = result.optional();
+      }
+      return result;
+    }
+    const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
+    if ("nullable" in schema && schema.nullable) {
+      types.push("null");
+    } else if (schema.default === null) {
+      types.push("null");
+    }
+    if (!types.length) {
+      return required ? z11.unknown() : z11.unknown().optional();
+    }
+    if (types.length > 1) {
+      const realTypes = types.filter((t) => t !== "null");
+      if (realTypes.length === 1 && types.includes("null")) {
+        return this.normal(realTypes[0], schema, required, true);
+      }
+      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]);
+        if (!required) {
+          result = result.optional();
+        }
+        return result;
+      }
+    }
+    return this.normal(types[0], schema, required, false);
+  }
+};
+function schemaToZod(schema, options) {
+  const converter = new RuntimeZodConverter(options?.resolveRef);
+  return converter.handle(schema, options?.required ?? false);
+}
+
 // packages/rpc/src/lib/rpc.ts
-var optionsSchema = z2.object({
-  token: z2.string().optional().transform((val) => val ? `Bearer ${val}` : void 0),
+var optionsSchema = z12.object({
+  token: z12.string().optional().transform((val) => val ? `Bearer ${val}` : void 0),
   fetch: fetchType,
-  baseUrl: z2.string()
+  baseUrl: z12.string()
 });
 var Client = class {
   options;
@@ -697,7 +2390,7 @@ var Client = class {
 };
 async function rpc(openapi, options) {
   const spec = await loadSpec(openapi);
-  const ir = augmentSpec({ spec, responses: { flattenErrorResponses: true } });
+  const ir = toIR({ spec, responses: { flattenErrorResponses: true } });
   const schemas = {};
   forEachOperation(ir, (entry, operation) => {
     const endpoint = `${entry.method.toUpperCase()} ${entry.path}`;
@@ -708,7 +2401,6 @@ async function rpc(openapi, options) {
       formdata,
       empty
     };
-    console.log(operation.responses);
     const outputs = Object.keys(operation.responses).flatMap(
       (status) => toHttpOutput(
         spec,
@@ -720,24 +2412,18 @@ async function rpc(openapi, options) {
     );
     schemas[endpoint] = {
       output: outputs.map((it) => response_exports[it.replace("http.", "")]),
-      toRequest(input) {
+      schemas: schemaToZod(operationSchema(ir, operation, details.ct)),
+      async dispatch(input, options2) {
+        const dispatcher = new Dispatcher(options2.interceptors, options2.fetch);
         const serializer = contentTypeMap[details.outgoingContentType] || defaultSerializer(details.outgoingContentType);
-        return toRequest(
+        const request = toRequest(
           endpoint,
           serializer(input, inputToPath(operation, details.inputs))
         );
-      },
-      async dispatch(input, options2) {
-        const dispatcher = new Dispatcher(options2.interceptors, options2.fetch);
-        const result = await dispatcher.send(
-          this.toRequest(input),
-          this.output
-        );
-        return result;
+        return dispatcher.send(request, this.output);
       }
     };
   });
-  console.log(schemas);
   return new Client(
     {
       ...options,
@@ -746,11 +2432,31 @@ async function rpc(openapi, options) {
     schemas
   );
 }
+async function toTools(rpc2) {
+  const tools = {};
+  for (const [endpoint, route] of Object.entries(rpc2.schemas)) {
+    const operation = route.schemas;
+    tools[route.schemas.operationId] = tool({
+      description: operation.description,
+      type: "function",
+      inputSchema: route.schemas,
+      execute: async (input) => {
+        console.log("Executing tool with input:", input);
+        const response = await rpc2.request(endpoint, input);
+        return JSON.stringify(response);
+      }
+    });
+  }
+  return tools;
+}
 function defaultSerializer(ct) {
   throw new Error(`Unsupported content type: ${ct}`);
 }
 export {
   Client,
-  rpc
+  RuntimeZodConverter,
+  rpc,
+  schemaToZod,
+  toTools
 };
 //# sourceMappingURL=index.js.map