@arizeai/phoenix-client 0.0.1 → 1.0.1

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

@@ -0,0 +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;AAEvE,eAAO,MAAM,2BAA2B;;;;;CAKvC,CAAC"}

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

@@ -0,0 +1,23 @@
+import z from "zod";
+import zodToJsonSchema from "zod-to-json-schema";
+import { anthropicMessagePartSchema } from "./messagePartSchemas.js";
+/**
+ *
+ * Anthropic Message Schemas
+ *
+ */
+export const anthropicMessageRoleSchema = z.enum(["user", "assistant"]);
+/**
+ * TODO: rewrite as discriminated union
+ */
+export const anthropicMessageSchema = z
+    .object({
+    role: anthropicMessageRoleSchema,
+    content: z.union([z.string(), z.array(anthropicMessagePartSchema)]),
+})
+    .passthrough();
+export const anthropicMessagesSchema = z.array(anthropicMessageSchema);
+export const anthropicMessagesJSONSchema = zodToJsonSchema(anthropicMessagesSchema, {
+    removeAdditionalStrategy: "passthrough",
+});
+//# sourceMappingURL=messageSchemas.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"messageSchemas.js","sourceRoot":"","sources":["../../../../../src/schemas/llm/anthropic/messageSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AACpB,OAAO,eAAe,MAAM,oBAAoB,CAAC;AAEjD,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAElE;;;;GAIG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;AAIxE;;GAEG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC;KACpC,MAAM,CAAC;IACN,IAAI,EAAE,0BAA0B;IAChC,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,0BAA0B,CAAC,CAAC,CAAC;CACpE,CAAC;KACD,WAAW,EAAE,CAAC;AAIjB,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,sBAAsB,CAAC,CAAC;AAEvE,MAAM,CAAC,MAAM,2BAA2B,GAAG,eAAe,CACxD,uBAAuB,EACvB;IACE,wBAAwB,EAAE,aAAa;CACxC,CACF,CAAC"}

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

@@ -0,0 +1,48 @@
+import z from "zod";
+/**
+ * The schema for an Anthropic tool call, this is what a message that calls a tool looks like
+ */
+export declare const anthropicToolCallSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"tool_use">;
+    name: z.ZodString;
+    input: z.ZodType<import("../../jsonLiteralSchema.js").JSONLiteral, z.ZodTypeDef, import("../../jsonLiteralSchema.js").JSONLiteral>;
+}, "strip", z.ZodTypeAny, {
+    type: "tool_use";
+    input: import("../../jsonLiteralSchema.js").JSONLiteral;
+    id: string;
+    name: string;
+}, {
+    type: "tool_use";
+    input: import("../../jsonLiteralSchema.js").JSONLiteral;
+    id: string;
+    name: string;
+}>;
+/**
+ * The type of an Anthropic tool call
+ */
+export type AnthropicToolCall = z.infer<typeof anthropicToolCallSchema>;
+/**
+ * The zod schema for multiple Anthropic tool calls
+ */
+export declare const anthropicToolCallsSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"tool_use">;
+    name: z.ZodString;
+    input: z.ZodType<import("../../jsonLiteralSchema.js").JSONLiteral, z.ZodTypeDef, import("../../jsonLiteralSchema.js").JSONLiteral>;
+}, "strip", z.ZodTypeAny, {
+    type: "tool_use";
+    input: import("../../jsonLiteralSchema.js").JSONLiteral;
+    id: string;
+    name: string;
+}, {
+    type: "tool_use";
+    input: import("../../jsonLiteralSchema.js").JSONLiteral;
+    id: string;
+    name: string;
+}>, "many">;
+/**
+ * Creates an empty Anthropic tool call with fields but no values filled in
+ */
+export declare function createAnthropicToolCall(): AnthropicToolCall;
+//# sourceMappingURL=toolCallSchemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolCallSchemas.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/llm/anthropic/toolCallSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAGpB;;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"}

package/dist/esm/schemas/llm/anthropic/toolCallSchemas.js

@@ -0,0 +1,27 @@
+import z from "zod";
+import { jsonLiteralSchema } from "../../jsonLiteralSchema.js";
+/**
+ * The schema for an Anthropic tool call, this is what a message that calls a tool looks like
+ */
+export const anthropicToolCallSchema = z.object({
+    id: z.string().describe("The ID of the tool call"),
+    type: z.literal("tool_use"),
+    name: z.string().describe("The name of the tool"),
+    input: jsonLiteralSchema.describe("The input for the tool"),
+});
+/**
+ * The zod schema for multiple Anthropic tool calls
+ */
+export const anthropicToolCallsSchema = z.array(anthropicToolCallSchema);
+/**
+ * Creates an empty Anthropic tool call with fields but no values filled in
+ */
+export function createAnthropicToolCall() {
+    return {
+        id: "",
+        type: "tool_use",
+        name: "",
+        input: {},
+    };
+}
+//# sourceMappingURL=toolCallSchemas.js.map

package/dist/esm/schemas/llm/anthropic/toolCallSchemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolCallSchemas.js","sourceRoot":"","sources":["../../../../../src/schemas/llm/anthropic/toolCallSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AACpB,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAE5D;;GAEG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC9C,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,yBAAyB,CAAC;IAClD,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC;IAC3B,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,sBAAsB,CAAC;IACjD,KAAK,EAAE,iBAAiB,CAAC,QAAQ,CAAC,wBAAwB,CAAC;CAC5D,CAAC,CAAC;AAOH;;GAEG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;AAEzE;;GAEG;AACH,MAAM,UAAU,uBAAuB;IACrC,OAAO;QACL,EAAE,EAAE,EAAE;QACN,IAAI,EAAE,UAAU;QAChB,IAAI,EAAE,EAAE;QACR,KAAK,EAAE,EAAE;KACV,CAAC;AACJ,CAAC"}

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

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

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

@@ -0,0 +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"}

package/dist/esm/schemas/llm/anthropic/toolChoiceSchemas.js

@@ -0,0 +1,19 @@
+import z from "zod";
+/**
+ * Anthropic's tool choice schema
+ *
+ * @see https://docs.anthropic.com/en/api/messages
+ */
+export const anthropicToolChoiceSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("tool"),
+        name: z.string(),
+    }),
+    z.object({
+        type: z.literal("auto"),
+    }),
+    z.object({
+        type: z.literal("any"),
+    }),
+]);
+//# sourceMappingURL=toolChoiceSchemas.js.map

package/dist/esm/schemas/llm/anthropic/toolChoiceSchemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolChoiceSchemas.js","sourceRoot":"","sources":["../../../../../src/schemas/llm/anthropic/toolChoiceSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB;;;;GAIG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,kBAAkB,CAAC,MAAM,EAAE;IACpE,CAAC,CAAC,MAAM,CAAC;QACP,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;QACvB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;KACjB,CAAC;IACF,CAAC,CAAC,MAAM,CAAC;QACP,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;KACxB,CAAC;IACF,CAAC,CAAC,MAAM,CAAC;QACP,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;KACvB,CAAC;CACH,CAAC,CAAC"}

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

@@ -0,0 +1,191 @@
+import z from "zod";
+/**
+ * The zod schema for an anthropic tool definition
+ */
+export declare const anthropicToolDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    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<{
+            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">>;
+}, "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;
+    };
+}>;
+/**
+ * The type of an anthropic tool definition
+ */
+export type AnthropicToolDefinition = z.infer<typeof anthropicToolDefinitionSchema>;
+/**
+ * Creates an Anthropic tool definition
+ * @param toolNumber the number of the tool in that instance for example instance.tools.length + 1 to be used to fill in the name
+ * @returns an Anthropic tool definition
+ */
+export declare function createAnthropicToolDefinition(toolNumber: number): AnthropicToolDefinition;
+//# sourceMappingURL=toolSchemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolSchemas.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/llm/anthropic/toolSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAGpB;;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"}

package/dist/esm/schemas/llm/anthropic/toolSchemas.js

@@ -0,0 +1,31 @@
+import z from "zod";
+import { jsonSchemaZodSchema } from "../../jsonSchema.js";
+/**
+ * The zod schema for an anthropic tool definition
+ */
+export const anthropicToolDefinitionSchema = z.object({
+    name: z.string(),
+    description: z.string(),
+    input_schema: jsonSchemaZodSchema,
+});
+/**
+ * Creates an Anthropic tool definition
+ * @param toolNumber the number of the tool in that instance for example instance.tools.length + 1 to be used to fill in the name
+ * @returns an Anthropic tool definition
+ */
+export function createAnthropicToolDefinition(toolNumber) {
+    return {
+        name: `new_function_${toolNumber}`,
+        description: "",
+        input_schema: {
+            type: "object",
+            properties: {
+                new_arg: {
+                    type: "string",
+                },
+            },
+            required: [],
+        },
+    };
+}
+//# sourceMappingURL=toolSchemas.js.map

package/dist/esm/schemas/llm/anthropic/toolSchemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolSchemas.js","sourceRoot":"","sources":["../../../../../src/schemas/llm/anthropic/toolSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AACpB,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAEvD;;GAEG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,CAAC,MAAM,CAAC;IACpD,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,YAAY,EAAE,mBAAmB;CAClC,CAAC,CAAC;AASH;;;;GAIG;AACH,MAAM,UAAU,6BAA6B,CAC3C,UAAkB;IAElB,OAAO;QACL,IAAI,EAAE,gBAAgB,UAAU,EAAE;QAClC,WAAW,EAAE,EAAE;QACf,YAAY,EAAE;YACZ,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE;gBACV,OAAO,EAAE;oBACP,IAAI,EAAE,QAAQ;iBACf;aACF;YACD,QAAQ,EAAE,EAAE;SACb;KACF,CAAC;AACJ,CAAC"}