@drax/ai-back 3.62.0 → 3.62.1

package/dist/tools/BuilderTool.js

@@ -231,31 +231,38 @@ class BuilderTool {
     getTypeName(field) {
         return field?.constructor?.name;
     }
+    getDefType(field) {
+        return field?.def?.type;
+    }
     fieldAdapter(field) {
         const f = field;
         const typeName = this.getTypeName(f);
-        if (typeof f?.unwrap === "function" && typeName === "ZodOptional") {
+        const defType = this.getDefType(f);
+        if (typeof f?.unwrap === "function" && (typeName === "ZodOptional" || defType === "optional")) {
             return this.fieldAdapter(f.unwrap()).optional();
         }
-        if (typeof f?.unwrap === "function" && typeName === "ZodNullable") {
+        if (typeof f?.unwrap === "function" && (typeName === "ZodNullable" || defType === "nullable")) {
             return this.fieldAdapter(f.unwrap()).nullable();
         }
-        if (typeof f?.unwrap === "function" && typeName === "ZodDefault") {
+        if (typeof f?.unwrap === "function" && (typeName === "ZodDefault" || defType === "default")) {
             return this.fieldAdapter(f.unwrap()).default(f.def.defaultValue);
         }
-        if (typeof f?.unwrap === "function" && typeName === "ZodCatch") {
+        if (typeof f?.unwrap === "function" && (typeName === "ZodCatch" || defType === "catch")) {
             return this.fieldAdapter(f.unwrap()).catch(f.def.catchValue);
         }
-        if (typeof f?.unwrap === "function" && typeName === "ZodReadonly") {
+        if (typeof f?.unwrap === "function" && (typeName === "ZodReadonly" || defType === "readonly")) {
             return this.fieldAdapter(f.unwrap()).readonly();
         }
-        if (typeName === "ZodArray" && f?.element) {
+        if ((typeName === "ZodPipe" || defType === "pipe") && f?.def?.out) {
+            return this.fieldAdapter(f.def.out);
+        }
+        if ((typeName === "ZodArray" || defType === "array") && f?.element) {
             return z.array(this.fieldAdapter(f.element));
         }
-        if (typeName === "ZodObject" && f?.shape) {
+        if ((typeName === "ZodObject" || defType === "object") && f?.shape) {
             return this.schemaAdapter(f);
         }
-        if (typeName === "ZodDate") {
+        if (typeName === "ZodDate" || defType === "date") {
             return z.iso.datetime();
         }
         return f;

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.62.0",
+  "version": "3.62.1",
   "description": "Ai utils",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -46,5 +46,5 @@
     "typescript": "^5.9.3",
     "vitest": "^3.0.8"
   },
-  "gitHead": "9793c108e2bc40b0ebc6ed527259d69de63f668c"
+  "gitHead": "52472c2b45c1472ceb647b37a372ac4782eb11ad"
 }

package/src/tools/BuilderTool.ts

@@ -262,39 +262,48 @@ class BuilderTool<T = any, C = any, U = any> {
         return field?.constructor?.name;
     }
 
+    protected getDefType(field: any): string | undefined {
+        return field?.def?.type;
+    }
+
     protected fieldAdapter(field: unknown): ZodTypeAny {
         const f: any = field;
         const typeName = this.getTypeName(f);
+        const defType = this.getDefType(f);
 
-        if (typeof f?.unwrap === "function" && typeName === "ZodOptional") {
+        if (typeof f?.unwrap === "function" && (typeName === "ZodOptional" || defType === "optional")) {
             return this.fieldAdapter(f.unwrap()).optional();
         }
 
-        if (typeof f?.unwrap === "function" && typeName === "ZodNullable") {
+        if (typeof f?.unwrap === "function" && (typeName === "ZodNullable" || defType === "nullable")) {
             return this.fieldAdapter(f.unwrap()).nullable();
         }
 
-        if (typeof f?.unwrap === "function" && typeName === "ZodDefault") {
+        if (typeof f?.unwrap === "function" && (typeName === "ZodDefault" || defType === "default")) {
             return this.fieldAdapter(f.unwrap()).default(f.def.defaultValue);
         }
 
-        if (typeof f?.unwrap === "function" && typeName === "ZodCatch") {
+        if (typeof f?.unwrap === "function" && (typeName === "ZodCatch" || defType === "catch")) {
             return this.fieldAdapter(f.unwrap()).catch(f.def.catchValue);
         }
 
-        if (typeof f?.unwrap === "function" && typeName === "ZodReadonly") {
+        if (typeof f?.unwrap === "function" && (typeName === "ZodReadonly" || defType === "readonly")) {
             return this.fieldAdapter(f.unwrap()).readonly();
         }
 
-        if (typeName === "ZodArray" && f?.element) {
+        if ((typeName === "ZodPipe" || defType === "pipe") && f?.def?.out) {
+            return this.fieldAdapter(f.def.out);
+        }
+
+        if ((typeName === "ZodArray" || defType === "array") && f?.element) {
             return z.array(this.fieldAdapter(f.element));
         }
 
-        if (typeName === "ZodObject" && f?.shape) {
+        if ((typeName === "ZodObject" || defType === "object") && f?.shape) {
             return this.schemaAdapter(f);
         }
 
-        if (typeName === "ZodDate") {
+        if (typeName === "ZodDate" || defType === "date") {
             return z.iso.datetime();
         }
 

package/test/ToolBuilder.test.ts

@@ -125,6 +125,51 @@ describe("ToolBuilder", () => {
         expect(() => builder.getSystemPromptSection()).not.toThrow();
     });
 
+    test("adapts preprocessed date schemas to OpenAI-compatible JSON schema", () => {
+        const service: any = {
+            async create(data: any) {
+                return data;
+            },
+        };
+
+        const optionalNullableDateSchema = z.preprocess(value => {
+            if (value === "" || value === 0 || value === "0") {
+                return null;
+            }
+
+            return value;
+        }, z.coerce.date().nullable().optional());
+
+        const schema = z.object({
+            name: z.string().min(1),
+            timezone: z.string()
+                .default("America/Argentina/Buenos_Aires")
+                .refine(value => value.length > 0, "validation.timezone.invalid"),
+            runAt: optionalNullableDateSchema,
+        });
+
+        const builder = new BuilderTool({
+            entityName: "taskSchedule",
+            schema,
+            service,
+            methods: ["create"],
+        });
+
+        expect(() => builder.getTools()).not.toThrow();
+        expect(() => builder.getSystemPromptSection()).not.toThrow();
+
+        const tools = builder.getTools();
+        const createParameters: any = tools[0].parameters;
+        const dataSchema = createParameters.properties.data;
+
+        expect(dataSchema.properties.runAt).toMatchObject({
+            anyOf: [
+                {type: "string", format: "date-time"},
+                {type: "null"},
+            ],
+        });
+    });
+
     test("fails when a requested service method is not available", () => {
         const builder = new BuilderTool({
             entityName: "person",