@sdk-it/rpc 0.43.0 → 0.44.0

package/dist/index.js

@@ -4,20 +4,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// packages/rpc/src/lib/rpc.ts
-import { tool } from "ai";
-import { z as z3 } from "zod";
-import {
-  forEachOperation,
-  loadSpec,
-  toIR
-} from "@sdk-it/spec";
-import {
-  buildInput,
-  operationSchema,
-  toHttpOutput
-} from "@sdk-it/typescript";
-
 // packages/rpc/src/lib/http/dispatcher.ts
 import z from "zod";
 
@@ -52,6 +38,78 @@ var createBaseUrlInterceptor = (baseUrl) => {
     }
   };
 };
+var logInterceptor = {
+  before({ url, init }) {
+    console.log("Request:", { url, init });
+    return { url, init };
+  },
+  after(response) {
+    console.log("Response:", response);
+    return response;
+  }
+};
+var createDetailedLogInterceptor = (options) => {
+  const logLevel = options?.logLevel || "info";
+  const includeRequestBody = options?.includeRequestBody || false;
+  const includeResponseBody = options?.includeResponseBody || false;
+  return {
+    async before(request) {
+      const logData = {
+        url: request.url,
+        method: request.method,
+        contentType: request.headers.get("Content-Type"),
+        headers: Object.fromEntries([...request.headers.entries()])
+      };
+      console[logLevel]("\u{1F680} Outgoing Request:", logData);
+      if (includeRequestBody) {
+        try {
+          const clonedRequest = request.clone();
+          if (clonedRequest.headers.get("Content-Type")?.includes("application/json")) {
+            const body = await clonedRequest.json().catch(() => null);
+            console[logLevel]("Request Body:", body);
+          } else {
+            const body = await clonedRequest.text().catch(() => null);
+            console[logLevel]("Request Body:", body);
+          }
+        } catch (error) {
+          console.error("Could not log request body:", error);
+        }
+      }
+      return request;
+    },
+    async after(response) {
+      const logData = {
+        status: response.status,
+        statusText: response.statusText,
+        url: response.url,
+        headers: Object.fromEntries([...response.headers.entries()])
+      };
+      console[logLevel]("\u{1F4E5} Incoming Response:", logData);
+      if (includeResponseBody && response.body) {
+        try {
+          const clonedResponse = response.clone();
+          if (clonedResponse.headers.get("Content-Type")?.includes("application/json")) {
+            const body = await clonedResponse.json().catch(() => null);
+            console[logLevel]("Response Body:", body);
+          } else {
+            const body = await clonedResponse.text().catch(() => null);
+            if (body) {
+              console[logLevel](
+                "Response Body:",
+                body.substring(0, 500) + (body.length > 500 ? "..." : "")
+              );
+            } else {
+              console[logLevel]("No response body");
+            }
+          }
+        } catch (error) {
+          console.error("Could not log response body:", error);
+        }
+      }
+      return response;
+    }
+  };
+};
 
 // packages/rpc/src/lib/http/request.ts
 function template(templateString, templateVariables) {
@@ -64,6 +122,9 @@ function template(templateString, templateVariables) {
     return result === null || result === void 0 ? "" : String(result);
   });
 }
+function toWireValue(value) {
+  return value instanceof Date ? value.toISOString() : String(value);
+}
 var Serializer = class {
   input;
   props;
@@ -80,26 +141,29 @@ var Serializer = class {
       {}
     );
     const url = new URL(template(path, params), `local://`);
-    const headers = new Headers({});
+    const headers = { ...this.getHeaders() };
     for (const header of this.props.inputHeaders) {
-      headers.set(header, this.input[header]);
+      const value = this.input[header];
+      if (value !== void 0) {
+        headers[header] = toWireValue(value);
+      }
     }
     for (const key of this.props.inputQuery) {
       const value = this.input[key];
       if (value !== void 0) {
         if (Array.isArray(value)) {
           for (const item of value) {
-            url.searchParams.append(key, String(item));
+            url.searchParams.append(key, toWireValue(item));
           }
         } else {
-          url.searchParams.set(key, String(value));
+          url.searchParams.set(key, toWireValue(value));
         }
       }
     }
     return {
       body: this.getBody(),
       url,
-      headers: this.getHeaders()
+      headers
     };
   }
 };
@@ -125,7 +189,7 @@ var UrlencodedSerializer = class extends Serializer {
   getBody() {
     const body = new URLSearchParams();
     for (const prop of this.props.inputBody) {
-      body.set(prop, this.input[prop]);
+      body.set(prop, toWireValue(this.input[prop]));
     }
     return body;
   }
@@ -185,23 +249,53 @@ function toRequest(endpoint, serializer) {
 
 // packages/rpc/src/lib/http/parse-response.ts
 import { parse } from "fast-content-type-parse";
+function isBinaryContentType(contentType) {
+  const type = contentType.toLowerCase();
+  if (type.startsWith("image/")) {
+    return true;
+  }
+  if (type.startsWith("audio/")) {
+    return true;
+  }
+  if (type.startsWith("video/")) {
+    return true;
+  }
+  switch (type) {
+    case "application/pdf":
+    case "application/zip":
+    case "application/gzip":
+    case "application/x-7z-compressed":
+    case "application/x-tar":
+    case "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
+    case "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+    case "application/vnd.openxmlformats-officedocument.presentationml.presentation":
+    case "application/vnd.ms-excel":
+    case "application/vnd.ms-powerpoint":
+    case "application/msword":
+    case "application/octet-stream":
+      return true;
+    default:
+      return false;
+  }
+}
 async function buffered(response) {
+  if (response.status === 204 || response.status === 205 || response.status === 304) {
+    return null;
+  }
   const contentType = response.headers.get("Content-Type");
   if (!contentType) {
     throw new Error("Content-Type header is missing");
   }
-  if (response.status === 204) {
-    return null;
-  }
   const { type } = parse(contentType);
+  if (isBinaryContentType(type)) {
+    return response.blob();
+  }
+  if (type.startsWith("text/")) {
+    return response.text();
+  }
   switch (type) {
     case "application/json":
       return response.json();
-    case "text/plain":
-      return response.text();
-    case "text/html":
-      return response.text();
-    case "text/xml":
     case "application/xml":
       return response.text();
     case "application/x-www-form-urlencoded": {
@@ -229,7 +323,6 @@ __export(response_exports, {
   GatewayTimeout: () => GatewayTimeout,
   Gone: () => Gone,
   InternalServerError: () => InternalServerError,
-  KIND: () => KIND,
   MethodNotAllowed: () => MethodNotAllowed,
   NoContent: () => NoContent,
   NotAcceptable: () => NotAcceptable,
@@ -245,357 +338,246 @@ __export(response_exports, {
   UnprocessableEntity: () => UnprocessableEntity,
   UnsupportedMediaType: () => UnsupportedMediaType
 });
-var KIND = Symbol("APIDATA");
 var APIResponse = class {
   static status;
-  static kind = Symbol.for("APIResponse");
   status;
   data;
-  constructor(status, data) {
+  headers;
+  constructor(status, headers, data) {
     this.status = status;
+    this.headers = headers;
     this.data = data;
   }
-  static create(status, data) {
-    return new this(status, data);
+  static create(status, headers, data) {
+    return new this(status, headers, data);
   }
 };
 var APIError = class extends APIResponse {
-  static create(status, data) {
-    return new this(status, data);
+  static create(status, headers, data) {
+    return new this(status, headers, data);
   }
 };
 var Ok = class _Ok extends APIResponse {
-  static kind = Symbol.for("Ok");
   static status = 200;
-  constructor(data) {
-    super(_Ok.status, data);
-  }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
+  constructor(headers, data) {
+    super(_Ok.status, headers, data);
   }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var Created = class _Created extends APIResponse {
-  static kind = Symbol.for("Created");
   static status = 201;
-  constructor(data) {
-    super(_Created.status, data);
+  constructor(headers, data) {
+    super(_Created.status, headers, data);
   }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var Accepted = class _Accepted extends APIResponse {
-  static kind = Symbol.for("Accepted");
   static status = 202;
-  constructor(data) {
-    super(_Accepted.status, data);
+  constructor(headers, data) {
+    super(_Accepted.status, headers, data);
   }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var NoContent = class _NoContent extends APIResponse {
-  static kind = Symbol.for("NoContent");
   static status = 204;
-  constructor() {
-    super(_NoContent.status, null);
-  }
-  static create(status, data) {
-    return new this();
+  constructor(headers) {
+    super(_NoContent.status, headers, null);
   }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers);
   }
 };
 var BadRequest = class _BadRequest extends APIError {
-  static kind = Symbol.for("BadRequest");
   static status = 400;
-  constructor(data) {
-    super(_BadRequest.status, data);
+  constructor(headers, data) {
+    super(_BadRequest.status, headers, data);
   }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var Unauthorized = class _Unauthorized extends APIError {
-  static kind = Symbol.for("Unauthorized");
   static status = 401;
-  constructor(data) {
-    super(_Unauthorized.status, data);
+  constructor(headers, data) {
+    super(_Unauthorized.status, headers, data);
   }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var PaymentRequired = class _PaymentRequired extends APIError {
-  static kind = Symbol.for("PaymentRequired");
   static status = 402;
-  constructor(data) {
-    super(_PaymentRequired.status, data);
-  }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
+  constructor(headers, data) {
+    super(_PaymentRequired.status, headers, data);
   }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var Forbidden = class _Forbidden extends APIError {
-  static kind = Symbol.for("Forbidden");
   static status = 403;
-  constructor(data) {
-    super(_Forbidden.status, data);
-  }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
+  constructor(headers, data) {
+    super(_Forbidden.status, headers, data);
   }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var NotFound = class _NotFound extends APIError {
-  static kind = Symbol.for("NotFound");
   static status = 404;
-  constructor(data) {
-    super(_NotFound.status, data);
-  }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
+  constructor(headers, data) {
+    super(_NotFound.status, headers, data);
   }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var MethodNotAllowed = class _MethodNotAllowed extends APIError {
-  static kind = Symbol.for("MethodNotAllowed");
   static status = 405;
-  constructor(data) {
-    super(_MethodNotAllowed.status, data);
+  constructor(headers, data) {
+    super(_MethodNotAllowed.status, headers, data);
   }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var NotAcceptable = class _NotAcceptable extends APIError {
-  static kind = Symbol.for("NotAcceptable");
   static status = 406;
-  constructor(data) {
-    super(_NotAcceptable.status, data);
+  constructor(headers, data) {
+    super(_NotAcceptable.status, headers, data);
   }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var Conflict = class _Conflict extends APIError {
-  static kind = Symbol.for("Conflict");
   static status = 409;
-  constructor(data) {
-    super(_Conflict.status, data);
-  }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
+  constructor(headers, data) {
+    super(_Conflict.status, headers, data);
   }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var Gone = class _Gone extends APIError {
-  static kind = Symbol.for("Gone");
   static status = 410;
-  constructor(data) {
-    super(_Gone.status, data);
-  }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
+  constructor(headers, data) {
+    super(_Gone.status, headers, data);
   }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var PreconditionFailed = class _PreconditionFailed extends APIError {
-  static kind = Symbol.for("PreconditionFailed");
   static status = 412;
-  constructor(data) {
-    super(_PreconditionFailed.status, data);
-  }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
+  constructor(headers, data) {
+    super(_PreconditionFailed.status, headers, data);
   }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var UnprocessableEntity = class _UnprocessableEntity extends APIError {
-  static kind = Symbol.for("UnprocessableEntity");
   static status = 422;
-  constructor(data) {
-    super(_UnprocessableEntity.status, data);
-  }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
+  constructor(headers, data) {
+    super(_UnprocessableEntity.status, headers, data);
   }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var TooManyRequests = class _TooManyRequests extends APIError {
-  static kind = Symbol.for("TooManyRequests");
   static status = 429;
-  constructor(data) {
-    super(_TooManyRequests.status, data);
-  }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
+  constructor(headers, data) {
+    super(_TooManyRequests.status, headers, data);
   }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var PayloadTooLarge = class _PayloadTooLarge extends APIError {
-  static kind = Symbol.for("PayloadTooLarge");
   static status = 413;
-  constructor(data) {
-    super(_PayloadTooLarge.status, data);
+  constructor(headers, data) {
+    super(_PayloadTooLarge.status, headers, data);
   }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var UnsupportedMediaType = class _UnsupportedMediaType extends APIError {
-  static kind = Symbol.for("UnsupportedMediaType");
   static status = 415;
-  constructor(data) {
-    super(_UnsupportedMediaType.status, data);
+  constructor(headers, data) {
+    super(_UnsupportedMediaType.status, headers, data);
   }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var InternalServerError = class _InternalServerError extends APIError {
-  static kind = Symbol.for("InternalServerError");
   static status = 500;
-  constructor(data) {
-    super(_InternalServerError.status, data);
-  }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
+  constructor(headers, data) {
+    super(_InternalServerError.status, headers, data);
   }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var NotImplemented = class _NotImplemented extends APIError {
-  static kind = Symbol.for("NotImplemented");
   static status = 501;
-  constructor(data) {
-    super(_NotImplemented.status, data);
-  }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
+  constructor(headers, data) {
+    super(_NotImplemented.status, headers, data);
   }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var BadGateway = class _BadGateway extends APIError {
-  static kind = Symbol.for("BadGateway");
   static status = 502;
-  constructor(data) {
-    super(_BadGateway.status, data);
-  }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
+  constructor(headers, data) {
+    super(_BadGateway.status, headers, data);
   }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var ServiceUnavailable = class _ServiceUnavailable extends APIError {
-  static kind = Symbol.for("ServiceUnavailable");
   static status = 503;
-  constructor(data) {
-    super(_ServiceUnavailable.status, data);
+  constructor(headers, data) {
+    super(_ServiceUnavailable.status, headers, data);
   }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 var GatewayTimeout = class _GatewayTimeout extends APIError {
-  static kind = Symbol.for("GatewayTimeout");
   static status = 504;
-  constructor(data) {
-    super(_GatewayTimeout.status, data);
+  constructor(headers, data) {
+    super(_GatewayTimeout.status, headers, data);
   }
-  static create(status, data) {
-    Object.defineProperty(data, KIND, { value: this.kind });
-    return new this(data);
-  }
-  static is(value) {
-    return typeof value === "object" && value !== null && KIND in value && value[KIND] === this.kind;
+  static create(status, headers, data) {
+    return new this(headers, data);
   }
 };
 
 // packages/rpc/src/lib/http/dispatcher.ts
-var fetchType = z.function().args(z.custom()).returns(z.promise(z.custom())).optional();
-async function parse2(outputs, response) {
+var fetchType = z.function({
+  input: [z.custom()],
+  output: z.custom()
+}).optional();
+async function parse2(outputs, response, mapper) {
   let output = null;
   let parser = buffered;
   for (const outputType of outputs) {
     if ("parser" in outputType) {
-      parser = outputType.parser;
       if (isTypeOf(outputType.type, APIResponse)) {
         if (response.status === outputType.type.status) {
+          parser = outputType.parser;
           output = outputType.type;
           break;
         }
@@ -608,13 +590,20 @@ async function parse2(outputs, response) {
     }
   }
   if (response.ok) {
+    const data = await parser(response);
+    const mapped = mapper ? mapper(data) : data;
     const apiresponse = (output || APIResponse).create(
       response.status,
-      await parser(response)
+      response.headers,
+      mapped
     );
     return apiresponse;
   }
-  throw (output || APIError).create(response.status, await parser(response));
+  throw (output || APIError).create(
+    response.status,
+    response.headers,
+    await parser(response)
+  );
 }
 function isTypeOf(instance, baseType) {
   if (instance === baseType) {
@@ -633,7 +622,7 @@ var Dispatcher = class {
     this.#interceptors = interceptors;
     this.#fetch = fetch2;
   }
-  async send(config, outputs, signal) {
+  async send(config, outputs, signal, mapper) {
     for (const interceptor of this.#interceptors) {
       if (interceptor.before) {
         config = await interceptor.before(config);
@@ -647,13 +636,52 @@ var Dispatcher = class {
         response = await interceptor.after(response.clone());
       }
     }
+    if (mapper) {
+      return await parse2(outputs, response, mapper);
+    }
     return await parse2(outputs, response);
   }
 };
 
-// packages/rpc/src/lib/zod.ts
+// packages/rpc/src/lib/http/parser.ts
 import { z as z2 } from "zod";
+var ParseError = class extends Error {
+  data;
+  constructor(data) {
+    super("Validation failed");
+    this.name = "ParseError";
+    this.data = data;
+  }
+};
+function parseInput(schema, input) {
+  const result = schema.safeParse(input);
+  if (!result.success) {
+    const error = z2.flattenError(result.error, (issue) => issue);
+    throw new ParseError(error);
+  }
+  return result.data;
+}
+
+// packages/rpc/src/lib/rpc.ts
+import { jsonSchema, tool } from "ai";
+import { z as z4 } from "zod";
+import {
+  forEachOperation,
+  loadSpec,
+  toIR
+} from "@sdk-it/spec";
+import {
+  buildInput,
+  operationSchema,
+  toHttpOutput
+} from "@sdk-it/typescript";
+
+// packages/rpc/src/lib/zod.ts
+import { z as z3 } from "zod";
 import { followRef, isRef } from "@sdk-it/core";
+var isoTime = z3.string().regex(
+  /^([01]\d|2[0-3]):[0-5]\d(:[0-5]\d(\.\d+)?)?(Z|[+-]([01]\d|2[0-3]):[0-5]\d)?$/
+);
 var RuntimeZodConverter = class {
   #spec;
   constructor(spec) {
@@ -667,13 +695,13 @@ var RuntimeZodConverter = class {
       const isRequired = required.includes(key);
       shape[key] = this.handle(propSchema, isRequired);
     }
-    let result = z2.object(shape);
+    let result = z3.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(z2.unknown());
+        result = result.catchall(z3.unknown());
       }
     }
     return result;
@@ -681,20 +709,20 @@ var RuntimeZodConverter = class {
   #array(schema) {
     const { items } = schema;
     if (!items) {
-      let result2 = z2.array(z2.unknown());
+      let result2 = z3.array(z3.unknown());
       if (schema.default !== void 0) {
-        result2 = z2.array(z2.unknown()).default(schema.default);
+        result2 = z3.array(z3.unknown()).default(schema.default);
       }
       return result2;
     }
     if (Array.isArray(items)) {
       const tupleItems = items.map((sub) => this.handle(sub, true));
-      return z2.tuple(tupleItems);
+      return z3.tuple(tupleItems);
     }
     const itemsSchema = this.handle(items, true);
-    let result = z2.array(itemsSchema);
+    let result = z3.array(itemsSchema);
     if (schema.default !== void 0) {
-      result = z2.array(itemsSchema).default(schema.default);
+      result = z3.array(itemsSchema).default(schema.default);
     }
     return result;
   }
@@ -708,12 +736,12 @@ var RuntimeZodConverter = class {
     if (!right.length) {
       return left;
     }
-    return z2.intersection(left, this.#toIntersection(right));
+    return z3.intersection(left, this.#toIntersection(right));
   }
   allOf(schemas) {
     const allOfSchemas = schemas.map((sub) => this.handle(sub, true));
     if (allOfSchemas.length === 0) {
-      return z2.unknown();
+      return z3.unknown();
     }
     if (allOfSchemas.length === 1) {
       return allOfSchemas[0];
@@ -725,74 +753,66 @@ var RuntimeZodConverter = class {
     if (anyOfSchemas.length === 1) {
       return anyOfSchemas[0];
     }
-    return z2.union(anyOfSchemas);
+    return z3.union(anyOfSchemas);
   }
   oneOf(schemas) {
     const oneOfSchemas = schemas.map((sub) => this.handle(sub, true));
     if (oneOfSchemas.length === 1) {
       return oneOfSchemas[0];
     }
-    return z2.union(oneOfSchemas);
+    return z3.xor(oneOfSchemas);
   }
   enum(type, values) {
     if (values.length === 1) {
-      return z2.literal(values[0]);
+      return z3.literal(values[0]);
     }
-    if (type === "integer") {
-      if (values.length >= 2) {
-        const [first, second, ...rest] = values.map(
-          (val) => z2.literal(val)
-        );
-        return z2.union([first, second, ...rest]);
-      }
-      return z2.literal(values[0]);
+    if (values.every((value) => typeof value === "string")) {
+      return z3.enum(values);
     }
-    const stringValues = values;
-    if (stringValues.length >= 2) {
-      const [first, ...rest] = stringValues;
-      return z2.enum([first, ...rest]);
-    }
-    return z2.literal(stringValues[0]);
+    return z3.literal(values);
   }
   /**
    * Handle a `string` schema with possible format keywords (JSON Schema).
    */
   string(schema) {
     if (schema.contentEncoding === "binary") {
-      return z2.custom();
+      return z3.custom();
     }
-    const base = schema["x-zod-type"] === "coerce-string" ? z2.coerce.string() : z2.string();
+    const coerced = schema["x-zod-type"] === "coerce-string";
+    const base = coerced ? z3.coerce.string() : z3.string();
+    const withFormat = (format) => coerced ? base.pipe(format) : format;
     switch (schema.format) {
       case "date-time":
       case "datetime":
         if (schema["x-zod-type"] === "coerce-date") {
-          return z2.coerce.date();
+          return z3.coerce.date();
         } else if (schema["x-zod-type"] === "date") {
-          return z2.date();
+          return z3.date();
         } else {
-          return base.datetime();
+          return withFormat(z3.iso.datetime({ offset: true }));
         }
       case "date":
-        return base.date();
+        return withFormat(z3.iso.date());
       case "time":
-        return base;
-      // Could add regex for HH:MM:SS format
+        return withFormat(isoTime);
       case "email":
-        return base.email();
+        return withFormat(z3.email());
       case "uuid":
-        return base.uuid();
+        return withFormat(z3.guid());
       case "url":
       case "uri":
-        return base.url();
+        return withFormat(z3.url());
       case "ipv4":
-        return base.ip({ version: "v4" });
+        return withFormat(z3.ipv4());
       case "ipv6":
-        return base.ip({ version: "v6" });
+        return withFormat(z3.ipv6());
+      case "cidrv4":
+        return withFormat(z3.cidrv4());
+      case "cidrv6":
+        return withFormat(z3.cidrv6());
       case "byte":
       case "binary":
-        return z2.custom();
-      case "int64":
-        return base;
+        return z3.custom();
       default:
         return base;
     }
@@ -801,23 +821,7 @@ var RuntimeZodConverter = class {
    * Handle number/integer constraints from OpenAPI/JSON Schema.
    */
   #number(schema) {
-    if (schema.format === "int64") {
-      let base2 = schema["x-zod-type"] === "coerce-bigint" ? z2.coerce.bigint() : z2.bigint();
-      if (typeof schema.exclusiveMinimum === "number") {
-        base2 = base2.gt(BigInt(schema.exclusiveMinimum));
-      }
-      if (typeof schema.exclusiveMaximum === "number") {
-        base2 = base2.lt(BigInt(schema.exclusiveMaximum));
-      }
-      if (typeof schema.minimum === "number") {
-        base2 = base2.min(BigInt(schema.minimum));
-      }
-      if (typeof schema.maximum === "number") {
-        base2 = base2.max(BigInt(schema.maximum));
-      }
-      return base2;
-    }
-    let base = schema["x-zod-type"] === "coerce-number" ? z2.coerce.number() : z2.number();
+    let base = schema["x-zod-type"] === "coerce-number" ? z3.coerce.number() : z3.number();
     if (schema.type === "integer" || schema.format === "int32") {
       base = base.int();
     }
@@ -835,7 +839,7 @@ var RuntimeZodConverter = class {
     }
     if (typeof schema.multipleOf === "number") {
       const multipleOf = schema.multipleOf;
-      base = base.refine(
+      return base.refine(
         (val) => Number.isInteger(Number(val) / multipleOf),
         `Must be a multiple of ${multipleOf}`
       );
@@ -856,7 +860,7 @@ var RuntimeZodConverter = class {
         base = this.#number(schema);
         break;
       case "boolean":
-        base = schema["x-zod-type"] === "coerce-boolean" ? z2.coerce.boolean() : z2.boolean();
+        base = schema["x-zod-type"] === "coerce-boolean" ? z3.union([z3.boolean(), z3.stringbool()]) : z3.boolean();
         break;
       case "object":
         base = this.#object(schema);
@@ -865,10 +869,10 @@ var RuntimeZodConverter = class {
         base = this.#array(schema);
         break;
       case "null":
-        base = z2.null();
+        base = z3.null();
         break;
       default:
-        base = z2.unknown();
+        base = z3.unknown();
         break;
     }
     if (nullable) {
@@ -878,7 +882,7 @@ var RuntimeZodConverter = class {
       base = base.optional();
     }
     if (schema.default !== void 0) {
-      const defaultValue = schema.format === "int64" ? BigInt(schema.default) : (schema["x-zod-type"] === "date" || schema["x-zod-type"] === "coerce-date") && schema.default ? new Date(schema.default) : schema.default;
+      const defaultValue = (schema["x-zod-type"] === "date" || schema["x-zod-type"] === "coerce-date") && schema.default ? new Date(schema.default) : schema.default;
       base = base.default(defaultValue);
     }
     if (schema["x-prefix"]) {
@@ -902,7 +906,7 @@ var RuntimeZodConverter = class {
       }
       return result2;
     }
-    let result = z2.unknown();
+    let result = z3.unknown();
     if (schema.allOf && Array.isArray(schema.allOf)) {
       result = this.allOf(schema.allOf);
       if (!required) {
@@ -920,30 +924,8 @@ var RuntimeZodConverter = class {
       }
     } else if (schema.enum && Array.isArray(schema.enum)) {
       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 = z2.literal(enumValues[0]).default(defaultValue);
-        } else if (enumType === "integer") {
-          if (enumValues.length >= 2) {
-            const [first, second, ...rest] = enumValues.map(
-              (val) => z2.literal(val)
-            );
-            result = z2.union([first, second, ...rest]).default(defaultValue);
-          } else {
-            result = z2.literal(enumValues[0]).default(defaultValue);
-          }
-        } else {
-          const stringValues = enumValues;
-          if (stringValues.length >= 2) {
-            const [first, ...rest] = stringValues;
-            result = z2.enum([first, ...rest]).default(defaultValue);
-          } else {
-            result = z2.literal(stringValues[0]).default(defaultValue);
-          }
-        }
+      if (schema.default !== void 0 && schema.enum.includes(schema.default) && required) {
+        result = result.default(schema.default);
       }
       if (!required) {
         result = result.optional();
@@ -956,21 +938,15 @@ var RuntimeZodConverter = class {
         types.push("null");
       }
       if (!types.length) {
-        result = required ? z2.unknown() : z2.unknown().optional();
+        result = required ? z3.unknown() : z3.unknown().optional();
       } else if (types.length > 1) {
         const realTypes = types.filter((t) => t !== "null");
         if (realTypes.length === 1 && types.includes("null")) {
           result = this.normal(realTypes[0], schema, required, true);
         } else {
-          const subSchemas = types.map((t) => this.normal(t, schema, true));
-          if (subSchemas.length >= 2) {
-            const [first, second, ...rest] = subSchemas;
-            result = z2.union([first, second, ...rest]);
-            if (!required) {
-              result = result.optional();
-            }
-          } else {
-            result = this.normal(types[0], schema, required, false);
+          result = z3.union(types.map((t) => this.normal(t, schema, true)));
+          if (!required) {
+            result = result.optional();
           }
         }
       } else {
@@ -989,29 +965,36 @@ function schemaToZod(schema, spec, options) {
 }
 
 // packages/rpc/src/lib/rpc.ts
-var baseUrlSchema = z3.union([
-  z3.string(),
-  z3.function().returns(z3.union([z3.string(), z3.promise(z3.string())]))
-]).transform(async (baseUrl) => {
-  if (typeof baseUrl === "function") {
-    return Promise.resolve(baseUrl());
-  }
-  return baseUrl;
+var callable = z4.custom(
+  (value) => typeof value === "function"
+);
+var baseUrlSchema = z4.union([z4.string(), callable]).transform(async (baseUrl, ctx) => {
+  const value = typeof baseUrl === "function" ? await baseUrl() : baseUrl;
+  if (typeof value !== "string") {
+    ctx.addIssue({
+      code: "custom",
+      message: "baseUrl must resolve to a string"
+    });
+    return z4.NEVER;
+  }
+  return value;
 });
-var optionsSchema = z3.object({
-  token: z3.union([
-    z3.string(),
-    z3.function().returns(z3.union([z3.string(), z3.promise(z3.string())]))
-  ]).optional().transform(async (token) => {
+var optionsSchema = z4.object({
+  token: z4.union([z4.string(), callable]).optional().transform(async (token, ctx) => {
     if (!token) return void 0;
-    if (typeof token === "function") {
-      token = await Promise.resolve(token());
+    const value = typeof token === "function" ? await token() : token;
+    if (typeof value !== "string") {
+      ctx.addIssue({
+        code: "custom",
+        message: "token must resolve to a string"
+      });
+      return z4.NEVER;
     }
-    return `Bearer ${token}`;
+    return `Bearer ${value}`;
   }),
   fetch: fetchType,
   baseUrl: baseUrlSchema,
-  headers: z3.record(z3.string()).optional()
+  headers: z4.record(z4.string(), z4.string()).optional()
 });
 function inputToPath(operation, inputs) {
   const inputHeaders = [];
@@ -1052,7 +1035,7 @@ var Client = class {
   async request(endpoint, input, options) {
     const route = this.schemas[endpoint];
     const withDefaultInputs = Object.assign({}, this.#defaultInputs, input);
-    const parsedInput = input;
+    const parsedInput = parseInput(route.schema, withDefaultInputs);
     const clientOptions = await optionsSchema.parseAsync(this.options);
     const result = await route.dispatch(parsedInput, {
       fetch: clientOptions.fetch,
@@ -1165,9 +1148,8 @@ async function toAgents(openapi, options) {
       groups[entry.tag].tools[toolInfo?.name || operation["x-fn-name"]] = tool({
         type: "function",
         description: toolInfo?.description || operation.description || operation.summary,
-        inputSchema: client.schemas[endpoint].schema,
+        inputSchema: toToolSchema(client.schemas[endpoint].schema),
         execute: async (input) => {
-          console.log("Executing tool with input:", input);
           const response = await client.request(endpoint, input);
           return JSON.stringify(response);
         }
@@ -1194,13 +1176,121 @@ async function toAgents(openapi, options) {
 function defaultSerializer(ct) {
   throw new Error(`Unsupported content type: ${ct}`);
 }
+var TOOL_COERCE_MARKER = "x-sdkit-tool-coerce";
+function coerceToolValue(value, schema) {
+  if (!schema || typeof schema !== "object" || value === null || value === void 0) {
+    return value;
+  }
+  const marker = schema[TOOL_COERCE_MARKER];
+  if (marker === "date" && typeof value === "string") {
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? value : date;
+  }
+  if (Array.isArray(value)) {
+    if (Array.isArray(schema.items)) {
+      return value.map(
+        (item, index) => coerceToolValue(item, schema.items[index] ?? schema.additionalItems)
+      );
+    }
+    if (schema.items) {
+      return value.map((item) => coerceToolValue(item, schema.items));
+    }
+    return value;
+  }
+  if (typeof value === "object" && (schema.properties || schema.additionalProperties)) {
+    const out = { ...value };
+    for (const [key, propValue] of Object.entries(out)) {
+      const propSchema = schema.properties?.[key] ?? (typeof schema.additionalProperties === "object" ? schema.additionalProperties : void 0);
+      if (propSchema) out[key] = coerceToolValue(propValue, propSchema);
+    }
+    return out;
+  }
+  for (const key of ["anyOf", "oneOf", "allOf"]) {
+    if (Array.isArray(schema[key])) {
+      for (const member of schema[key]) {
+        const coerced = coerceToolValue(value, member);
+        if (coerced !== value) return coerced;
+      }
+    }
+  }
+  return value;
+}
+function toToolSchema(schema) {
+  const marked = z4.toJSONSchema(schema, {
+    target: "draft-7",
+    io: "input",
+    unrepresentable: "any",
+    override(ctx) {
+      const def = ctx.zodSchema._zod.def;
+      const json2 = ctx.jsonSchema;
+      if (def.type === "date") {
+        json2.type = "string";
+        json2.format = "date-time";
+        json2[TOOL_COERCE_MARKER] = "date";
+      }
+    }
+  });
+  const advertised = JSON.parse(
+    JSON.stringify(
+      marked,
+      (key, value) => key === TOOL_COERCE_MARKER ? void 0 : value
+    )
+  );
+  return jsonSchema(advertised, {
+    validate: (value) => {
+      const coerced = coerceToolValue(value, marked);
+      const result = schema.safeParse(coerced);
+      return result.success ? { success: true, value: coerced } : { success: false, error: result.error };
+    }
+  });
+}
 export {
+  APIError,
+  APIResponse,
+  Accepted,
+  BadGateway,
+  BadRequest,
   Client,
+  Conflict,
+  Created,
+  Dispatcher,
+  Forbidden,
+  GatewayTimeout,
+  Gone,
+  InternalServerError,
+  MethodNotAllowed,
+  NoContent,
+  NotAcceptable,
+  NotFound,
+  NotImplemented,
+  Ok,
+  ParseError,
+  PayloadTooLarge,
+  PaymentRequired,
+  PreconditionFailed,
   RuntimeZodConverter,
+  ServiceUnavailable,
+  TooManyRequests,
+  Unauthorized,
+  UnprocessableEntity,
+  UnsupportedMediaType,
+  createBaseUrlInterceptor,
+  createDetailedLogInterceptor,
+  createHeadersInterceptor,
   createRpc,
+  empty,
+  fetchType,
+  formdata,
   inputToPath,
+  isTypeOf,
+  json,
+  logInterceptor,
+  parse2 as parse,
+  parseInput,
   rpc,
   schemaToZod,
-  toAgents
+  toAgents,
+  toRequest,
+  urlencoded
 };
 //# sourceMappingURL=index.js.map