@arizeai/phoenix-client 5.9.0 → 6.0.0

package/dist/src/schemas/llm/anthropic/messageSchemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messageSchemas.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/llm/anthropic/messageSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAKpB;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,kCAAgC,CAAC;AAExE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAKnB,CAAC;AAEjB,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAAkC,CAAC;AAIvE,eAAO,MAAM,2BAA2B;;;;;CAMvC,CAAC"}
+{"version":3,"file":"messageSchemas.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/llm/anthropic/messageSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAIpB;;;;GAIG;AACH,eAAO,MAAM,0BAA0B;;;EAAgC,CAAC;AAExE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAkC,CAAC;AAEvE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAEvC,CAAC"}

package/dist/src/schemas/llm/anthropic/messageSchemas.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.anthropicMessagesJSONSchema = exports.anthropicMessagesSchema = exports.anthropicMessageSchema = exports.anthropicMessageRoleSchema = void 0;
 const zod_1 = __importDefault(require("zod"));
-const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
 const messagePartSchemas_1 = require("./messagePartSchemas");
 /**
  *
@@ -16,19 +15,10 @@ exports.anthropicMessageRoleSchema = zod_1.default.enum(["user", "assistant"]);
 /**
  * TODO: rewrite as discriminated union
  */
-exports.anthropicMessageSchema = zod_1.default
-    .object({
+exports.anthropicMessageSchema = zod_1.default.looseObject({
     role: exports.anthropicMessageRoleSchema,
     content: zod_1.default.union([zod_1.default.string(), zod_1.default.array(messagePartSchemas_1.anthropicMessagePartSchema)]),
-})
-    .passthrough();
-exports.anthropicMessagesSchema = zod_1.default.array(exports.anthropicMessageSchema);
-// Type assertion needed due to TypeScript's deep type instantiation limits with complex recursive schemas
-// This is safe because zodToJsonSchema works correctly at runtime regardless of TypeScript's type analysis
-exports.anthropicMessagesJSONSchema = (0, zod_to_json_schema_1.default)(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-exports.anthropicMessagesSchema, // TODO: use zod4 toJSONSchema instead
-{
-    removeAdditionalStrategy: "passthrough",
 });
+exports.anthropicMessagesSchema = zod_1.default.array(exports.anthropicMessageSchema);
+exports.anthropicMessagesJSONSchema = zod_1.default.toJSONSchema(exports.anthropicMessagesSchema);
 //# sourceMappingURL=messageSchemas.js.map

package/dist/src/schemas/llm/anthropic/messageSchemas.js.map

@@ -1 +1 @@
-{"version":3,"file":"messageSchemas.js","sourceRoot":"","sources":["../../../../../src/schemas/llm/anthropic/messageSchemas.ts"],"names":[],"mappings":";;;;;;AAAA,8CAAoB;AACpB,4EAAiD;AAEjD,6DAAkE;AAElE;;;;GAIG;AACU,QAAA,0BAA0B,GAAG,aAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;AAIxE;;GAEG;AACU,QAAA,sBAAsB,GAAG,aAAC;KACpC,MAAM,CAAC;IACN,IAAI,EAAE,kCAA0B;IAChC,OAAO,EAAE,aAAC,CAAC,KAAK,CAAC,CAAC,aAAC,CAAC,MAAM,EAAE,EAAE,aAAC,CAAC,KAAK,CAAC,+CAA0B,CAAC,CAAC,CAAC;CACpE,CAAC;KACD,WAAW,EAAE,CAAC;AAIJ,QAAA,uBAAuB,GAAG,aAAC,CAAC,KAAK,CAAC,8BAAsB,CAAC,CAAC;AAEvE,0GAA0G;AAC1G,2GAA2G;AAC9F,QAAA,2BAA2B,GAAG,IAAA,4BAAe;AACxD,8DAA8D;AAC9D,+BAA8B,EAAE,sCAAsC;AACtE;IACE,wBAAwB,EAAE,aAAa;CACxC,CACF,CAAC"}
+{"version":3,"file":"messageSchemas.js","sourceRoot":"","sources":["../../../../../src/schemas/llm/anthropic/messageSchemas.ts"],"names":[],"mappings":";;;;;;AAAA,8CAAoB;AAEpB,6DAAkE;AAElE;;;;GAIG;AACU,QAAA,0BAA0B,GAAG,aAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;AAIxE;;GAEG;AACU,QAAA,sBAAsB,GAAG,aAAC,CAAC,WAAW,CAAC;IAClD,IAAI,EAAE,kCAA0B;IAChC,OAAO,EAAE,aAAC,CAAC,KAAK,CAAC,CAAC,aAAC,CAAC,MAAM,EAAE,EAAE,aAAC,CAAC,KAAK,CAAC,+CAA0B,CAAC,CAAC,CAAC;CACpE,CAAC,CAAC;AAIU,QAAA,uBAAuB,GAAG,aAAC,CAAC,KAAK,CAAC,8BAAsB,CAAC,CAAC;AAE1D,QAAA,2BAA2B,GAAG,aAAC,CAAC,YAAY,CACvD,+BAAuB,CACxB,CAAC"}

package/dist/src/schemas/llm/anthropic/toolCallSchemas.d.ts

@@ -6,18 +6,8 @@ export declare const anthropicToolCallSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodLiteral<"tool_use">;
     name: z.ZodString;
-    input: z.ZodType<import("../../jsonLiteralSchema").JSONLiteral, z.ZodTypeDef, import("../../jsonLiteralSchema").JSONLiteral>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    id: string;
-    input: import("../../jsonLiteralSchema").JSONLiteral;
-    type: "tool_use";
-}, {
-    name: string;
-    id: string;
-    input: import("../../jsonLiteralSchema").JSONLiteral;
-    type: "tool_use";
-}>;
+    input: z.ZodType<import("../../jsonLiteralSchema").JSONLiteral, unknown, z.core.$ZodTypeInternals<import("../../jsonLiteralSchema").JSONLiteral, unknown>>;
+}, z.core.$strip>;
 /**
  * The type of an Anthropic tool call
  */
@@ -29,18 +19,8 @@ export declare const anthropicToolCallsSchema: z.ZodArray<z.ZodObject<{
     id: z.ZodString;
     type: z.ZodLiteral<"tool_use">;
     name: z.ZodString;
-    input: z.ZodType<import("../../jsonLiteralSchema").JSONLiteral, z.ZodTypeDef, import("../../jsonLiteralSchema").JSONLiteral>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    id: string;
-    input: import("../../jsonLiteralSchema").JSONLiteral;
-    type: "tool_use";
-}, {
-    name: string;
-    id: string;
-    input: import("../../jsonLiteralSchema").JSONLiteral;
-    type: "tool_use";
-}>, "many">;
+    input: z.ZodType<import("../../jsonLiteralSchema").JSONLiteral, unknown, z.core.$ZodTypeInternals<import("../../jsonLiteralSchema").JSONLiteral, unknown>>;
+}, z.core.$strip>>;
 /**
  * Creates an empty Anthropic tool call with fields but no values filled in
  */

package/dist/src/schemas/llm/anthropic/toolCallSchemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolCallSchemas.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/llm/anthropic/toolCallSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAIpB;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;EAKlC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;WAAmC,CAAC;AAEzE;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,iBAAiB,CAO3D"}
+{"version":3,"file":"toolCallSchemas.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/llm/anthropic/toolCallSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAIpB;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;iBAKlC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;kBAAmC,CAAC;AAEzE;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,iBAAiB,CAO3D"}

package/dist/src/schemas/llm/anthropic/toolChoiceSchemas.d.ts

@@ -4,27 +4,13 @@ import z from "zod";
  *
  * @see https://docs.anthropic.com/en/api/messages
  */
-export declare const anthropicToolChoiceSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+export declare const anthropicToolChoiceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"tool">;
     name: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    type: "tool";
-}, {
-    name: string;
-    type: "tool";
-}>, z.ZodObject<{
+}, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"auto">;
-}, "strip", z.ZodTypeAny, {
-    type: "auto";
-}, {
-    type: "auto";
-}>, z.ZodObject<{
+}, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"any">;
-}, "strip", z.ZodTypeAny, {
-    type: "any";
-}, {
-    type: "any";
-}>]>;
+}, z.core.$strip>], "type">;
 export type AnthropicToolChoice = z.infer<typeof anthropicToolChoiceSchema>;
 //# sourceMappingURL=toolChoiceSchemas.d.ts.map

package/dist/src/schemas/llm/anthropic/toolChoiceSchemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolChoiceSchemas.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/llm/anthropic/toolChoiceSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB;;;;GAIG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;IAWpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}
+{"version":3,"file":"toolChoiceSchemas.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/llm/anthropic/toolChoiceSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB;;;;GAIG;AACH,eAAO,MAAM,yBAAyB;;;;;;;2BAWpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/src/schemas/llm/anthropic/toolSchemas.d.ts

@@ -7,177 +7,37 @@ export declare const anthropicToolDefinitionSchema: z.ZodObject<{
     description: z.ZodString;
     input_schema: z.ZodObject<{
         type: z.ZodLiteral<"object">;
-        properties: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
-            type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-            description: z.ZodOptional<z.ZodString>;
-            enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-            type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-            description: z.ZodOptional<z.ZodString>;
-            enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-            type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-            description: z.ZodOptional<z.ZodString>;
-            enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
-            anyOf: z.ZodArray<z.ZodObject<{
-                type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-                description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-                type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-                description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-                type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-                description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, z.ZodTypeAny, "passthrough">>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            anyOf: z.objectOutputType<{
-                type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-                description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, z.ZodTypeAny, "passthrough">[];
-        }, {
-            anyOf: z.objectInputType<{
-                type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-                description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, z.ZodTypeAny, "passthrough">[];
-        }>]>>;
-        required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        additionalProperties: z.ZodOptional<z.ZodBoolean>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        type: z.ZodLiteral<"object">;
-        properties: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
-            type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-            description: z.ZodOptional<z.ZodString>;
-            enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-            type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-            description: z.ZodOptional<z.ZodString>;
-            enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-            type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-            description: z.ZodOptional<z.ZodString>;
-            enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
-            anyOf: z.ZodArray<z.ZodObject<{
-                type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-                description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-                type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-                description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-                type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-                description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, z.ZodTypeAny, "passthrough">>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            anyOf: z.objectOutputType<{
-                type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-                description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, z.ZodTypeAny, "passthrough">[];
-        }, {
-            anyOf: z.objectInputType<{
-                type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-                description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, z.ZodTypeAny, "passthrough">[];
-        }>]>>;
-        required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        additionalProperties: z.ZodOptional<z.ZodBoolean>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        type: z.ZodLiteral<"object">;
-        properties: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
-            type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-            description: z.ZodOptional<z.ZodString>;
-            enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-            type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-            description: z.ZodOptional<z.ZodString>;
-            enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-            type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-            description: z.ZodOptional<z.ZodString>;
-            enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
+        properties: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                null: "null";
+                array: "array";
+                integer: "integer";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$loose>, z.ZodObject<{
             anyOf: z.ZodArray<z.ZodObject<{
-                type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-                description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-                type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-                description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-                type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-                description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, z.ZodTypeAny, "passthrough">>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            anyOf: z.objectOutputType<{
-                type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-                description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, z.ZodTypeAny, "passthrough">[];
-        }, {
-            anyOf: z.objectInputType<{
-                type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-                description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, z.ZodTypeAny, "passthrough">[];
-        }>]>>;
-        required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    object: "object";
+                    null: "null";
+                    array: "array";
+                    integer: "integer";
+                }>;
+                description: z.ZodOptional<z.ZodString>;
+                enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$loose>>;
+        }, z.core.$strip>]>>;
+        required: z.ZodOptional<z.ZodArray<z.ZodString>>;
         additionalProperties: z.ZodOptional<z.ZodBoolean>;
-    }, z.ZodTypeAny, "passthrough">>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    description: string;
-    input_schema: {
-        type: "object";
-        properties: Record<string, z.objectOutputType<{
-            type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-            description: z.ZodOptional<z.ZodString>;
-            enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, z.ZodTypeAny, "passthrough"> | {
-            anyOf: z.objectOutputType<{
-                type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-                description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, z.ZodTypeAny, "passthrough">[];
-        }>;
-        required?: string[] | undefined;
-        additionalProperties?: boolean | undefined;
-    } & {
-        [k: string]: unknown;
-    };
-}, {
-    name: string;
-    description: string;
-    input_schema: {
-        type: "object";
-        properties: Record<string, z.objectInputType<{
-            type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-            description: z.ZodOptional<z.ZodString>;
-            enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, z.ZodTypeAny, "passthrough"> | {
-            anyOf: z.objectInputType<{
-                type: z.ZodEnum<["string", "number", "boolean", "object", "array", "null", "integer"]>;
-                description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, z.ZodTypeAny, "passthrough">[];
-        }>;
-        required?: string[] | undefined;
-        additionalProperties?: boolean | undefined;
-    } & {
-        [k: string]: unknown;
-    };
-}>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
 /**
  * The type of an anthropic tool definition
  */

package/dist/src/schemas/llm/anthropic/toolSchemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolSchemas.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/llm/anthropic/toolSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAIpB;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIxC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,MAAM,GACjB,uBAAuB,CAczB"}
+{"version":3,"file":"toolSchemas.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/llm/anthropic/toolSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAIpB;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIxC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,MAAM,GACjB,uBAAuB,CAczB"}