@arizeai/phoenix-client 0.0.1 → 1.0.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"messageSchemas.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/llm/openai/messageSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAcpB,eAAO,MAAM,uBAAuB,iEAOlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAgD9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAA+B,CAAC"}

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

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openAIMessagesSchema = exports.openAIMessageSchema = exports.openAIMessageRoleSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+const toolCallSchemas_1 = require("./toolCallSchemas");
+const messagePartSchemas_1 = require("./messagePartSchemas");
+/*
+ *
+ * OpenAI Message Schemas
+ *
+ */
+exports.openAIMessageRoleSchema = zod_1.default.enum([
+    "system",
+    "user",
+    "assistant",
+    "developer",
+    "tool",
+    // "function",
+]);
+exports.openAIMessageSchema = zod_1.default.discriminatedUnion("role", [
+    zod_1.default
+        .object({
+        role: zod_1.default.literal("assistant"),
+        content: zod_1.default.union([messagePartSchemas_1.openaiChatPartTextSchema.array(), zod_1.default.string()]),
+        name: zod_1.default.string().optional(),
+        tool_call_id: zod_1.default.string().optional(),
+        tool_calls: zod_1.default.array(toolCallSchemas_1.openAIToolCallSchema).optional(),
+    })
+        .passthrough(),
+    zod_1.default
+        .object({
+        role: zod_1.default.literal("tool"),
+        content: zod_1.default.union([messagePartSchemas_1.openaiChatPartTextSchema.array(), zod_1.default.string()]),
+        tool_call_id: zod_1.default.string(),
+    })
+        .passthrough(),
+    zod_1.default
+        .object({
+        role: zod_1.default.literal("function"),
+        content: zod_1.default.string().nullable(),
+        name: zod_1.default.string(),
+    })
+        .passthrough(),
+    zod_1.default
+        .object({
+        role: zod_1.default.literal("user"),
+        content: zod_1.default.union([
+            zod_1.default.array(zod_1.default.union([messagePartSchemas_1.openaiChatPartTextSchema, messagePartSchemas_1.openaiChatPartImageSchema])),
+            zod_1.default.string(),
+        ]),
+        name: zod_1.default.string().optional(),
+    })
+        .passthrough(),
+    zod_1.default
+        .object({
+        role: zod_1.default.literal("system"),
+        content: zod_1.default.union([messagePartSchemas_1.openaiChatPartTextSchema.array(), zod_1.default.string()]),
+        name: zod_1.default.string().optional(),
+    })
+        .passthrough(),
+    zod_1.default
+        .object({
+        role: zod_1.default.literal("developer"),
+        content: zod_1.default.union([messagePartSchemas_1.openaiChatPartTextSchema.array(), zod_1.default.string()]),
+        name: zod_1.default.string().optional(),
+    })
+        .passthrough(),
+]);
+exports.openAIMessagesSchema = zod_1.default.array(exports.openAIMessageSchema);
+//# sourceMappingURL=messageSchemas.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"messageSchemas.js","sourceRoot":"","sources":["../../../../../src/schemas/llm/openai/messageSchemas.ts"],"names":[],"mappings":";;;;;;AAAA,8CAAoB;AAEpB,uDAAyD;AACzD,6DAG8B;AAE9B;;;;GAIG;AAEU,QAAA,uBAAuB,GAAG,aAAC,CAAC,IAAI,CAAC;IAC5C,QAAQ;IACR,MAAM;IACN,WAAW;IACX,WAAW;IACX,MAAM;IACN,cAAc;CACf,CAAC,CAAC;AAIU,QAAA,mBAAmB,GAAG,aAAC,CAAC,kBAAkB,CAAC,MAAM,EAAE;IAC9D,aAAC;SACE,MAAM,CAAC;QACN,IAAI,EAAE,aAAC,CAAC,OAAO,CAAC,WAAW,CAAC;QAC5B,OAAO,EAAE,aAAC,CAAC,KAAK,CAAC,CAAC,6CAAwB,CAAC,KAAK,EAAE,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,CAAC;QAChE,IAAI,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC3B,YAAY,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QACnC,UAAU,EAAE,aAAC,CAAC,KAAK,CAAC,sCAAoB,CAAC,CAAC,QAAQ,EAAE;KACrD,CAAC;SACD,WAAW,EAAE;IAChB,aAAC;SACE,MAAM,CAAC;QACN,IAAI,EAAE,aAAC,CAAC,OAAO,CAAC,MAAM,CAAC;QACvB,OAAO,EAAE,aAAC,CAAC,KAAK,CAAC,CAAC,6CAAwB,CAAC,KAAK,EAAE,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,CAAC;QAChE,YAAY,EAAE,aAAC,CAAC,MAAM,EAAE;KACzB,CAAC;SACD,WAAW,EAAE;IAChB,aAAC;SACE,MAAM,CAAC;QACN,IAAI,EAAE,aAAC,CAAC,OAAO,CAAC,UAAU,CAAC;QAC3B,OAAO,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC9B,IAAI,EAAE,aAAC,CAAC,MAAM,EAAE;KACjB,CAAC;SACD,WAAW,EAAE;IAChB,aAAC;SACE,MAAM,CAAC;QACN,IAAI,EAAE,aAAC,CAAC,OAAO,CAAC,MAAM,CAAC;QACvB,OAAO,EAAE,aAAC,CAAC,KAAK,CAAC;YACf,aAAC,CAAC,KAAK,CAAC,aAAC,CAAC,KAAK,CAAC,CAAC,6CAAwB,EAAE,8CAAyB,CAAC,CAAC,CAAC;YACvE,aAAC,CAAC,MAAM,EAAE;SACX,CAAC;QACF,IAAI,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KAC5B,CAAC;SACD,WAAW,EAAE;IAChB,aAAC;SACE,MAAM,CAAC;QACN,IAAI,EAAE,aAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;QACzB,OAAO,EAAE,aAAC,CAAC,KAAK,CAAC,CAAC,6CAAwB,CAAC,KAAK,EAAE,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,CAAC;QAChE,IAAI,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KAC5B,CAAC;SACD,WAAW,EAAE;IAChB,aAAC;SACE,MAAM,CAAC;QACN,IAAI,EAAE,aAAC,CAAC,OAAO,CAAC,WAAW,CAAC;QAC5B,OAAO,EAAE,aAAC,CAAC,KAAK,CAAC,CAAC,6CAAwB,CAAC,KAAK,EAAE,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,CAAC;QAChE,IAAI,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KAC5B,CAAC;SACD,WAAW,EAAE;CACjB,CAAC,CAAC;AAIU,QAAA,oBAAoB,GAAG,aAAC,CAAC,KAAK,CAAC,2BAAmB,CAAC,CAAC"}

package/dist/src/schemas/llm/openai/responseFormatSchema.d.ts

@@ -0,0 +1,233 @@
+import z from "zod";
+/**
+ * OpenAI response format schema
+ */
+export declare const openaiResponseFormatSchema: z.ZodObject<{
+    type: z.ZodLiteral<"json_schema">;
+    json_schema: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        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;
+        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;
+        };
+        description?: string | undefined;
+    }, {
+        name: string;
+        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;
+        };
+        description?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    json_schema: {
+        name: string;
+        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;
+        };
+        description?: string | undefined;
+    };
+    type: "json_schema";
+}, {
+    json_schema: {
+        name: string;
+        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;
+        };
+        description?: string | undefined;
+    };
+    type: "json_schema";
+}>;
+export type OpenAIResponseFormat = z.infer<typeof openaiResponseFormatSchema>;
+//# sourceMappingURL=responseFormatSchema.d.ts.map

package/dist/src/schemas/llm/openai/responseFormatSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responseFormatSchema.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/llm/openai/responseFormatSchema.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AASpB;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOrC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}

package/dist/src/schemas/llm/openai/responseFormatSchema.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openaiResponseFormatSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+const jsonSchema_1 = require("../../jsonSchema");
+/*
+ *
+ * Reponse format zod schemas
+ *
+ */
+/**
+ * OpenAI response format schema
+ */
+exports.openaiResponseFormatSchema = zod_1.default.object({
+    type: zod_1.default.literal("json_schema"),
+    json_schema: zod_1.default.object({
+        name: zod_1.default.string(),
+        description: zod_1.default.string().optional(),
+        schema: jsonSchema_1.jsonSchemaZodSchema,
+    }),
+});
+//# sourceMappingURL=responseFormatSchema.js.map

package/dist/src/schemas/llm/openai/responseFormatSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"responseFormatSchema.js","sourceRoot":"","sources":["../../../../../src/schemas/llm/openai/responseFormatSchema.ts"],"names":[],"mappings":";;;;;;AAAA,8CAAoB;AACpB,iDAAuD;AAEvD;;;;GAIG;AAEH;;GAEG;AACU,QAAA,0BAA0B,GAAG,aAAC,CAAC,MAAM,CAAC;IACjD,IAAI,EAAE,aAAC,CAAC,OAAO,CAAC,aAAa,CAAC;IAC9B,WAAW,EAAE,aAAC,CAAC,MAAM,CAAC;QACpB,IAAI,EAAE,aAAC,CAAC,MAAM,EAAE;QAChB,WAAW,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAClC,MAAM,EAAE,gCAAmB;KAC5B,CAAC;CACH,CAAC,CAAC"}

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

@@ -0,0 +1,95 @@
+import z from "zod";
+/**
+ * The schema for an OpenAI tool call, this is what a message that calls a tool looks like
+ *
+ * Note: The nested passThrough's are used to allow for extra keys in JSON schema, however, they do not actually
+ * allow for extra keys when the zod schema is used for parsing. This is to allow more flexibility for users
+ * to define their own tool calls according
+ */
+export declare const openAIToolCallSchema: z.ZodObject<{
+    type: z.ZodEffects<z.ZodOptional<z.ZodLiteral<"function">>, "function", "function" | undefined>;
+    id: z.ZodString;
+    function: z.ZodObject<{
+        name: z.ZodString;
+        arguments: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        name: z.ZodString;
+        arguments: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        name: z.ZodString;
+        arguments: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+}, "strip", z.ZodTypeAny, {
+    function: {
+        name: string;
+        arguments: string;
+    } & {
+        [k: string]: unknown;
+    };
+    type: "function";
+    id: string;
+}, {
+    function: {
+        name: string;
+        arguments: string;
+    } & {
+        [k: string]: unknown;
+    };
+    id: string;
+    type?: "function" | undefined;
+}>;
+/**
+ * The type of an OpenAI tool call
+ *
+ * @example
+ * ```typescript
+ *  {
+ *   id: "1",
+ *   function: {
+ *     name: "getCurrentWeather",
+ *     arguments: { "city": "San Francisco" }
+ *   }
+ * }
+ * ```
+ */
+export type OpenAIToolCall = z.infer<typeof openAIToolCallSchema>;
+/**
+ * The zod schema for multiple OpenAI Tool Calls
+ */
+export declare const openAIToolCallsSchema: z.ZodArray<z.ZodObject<{
+    type: z.ZodEffects<z.ZodOptional<z.ZodLiteral<"function">>, "function", "function" | undefined>;
+    id: z.ZodString;
+    function: z.ZodObject<{
+        name: z.ZodString;
+        arguments: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        name: z.ZodString;
+        arguments: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        name: z.ZodString;
+        arguments: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+}, "strip", z.ZodTypeAny, {
+    function: {
+        name: string;
+        arguments: string;
+    } & {
+        [k: string]: unknown;
+    };
+    type: "function";
+    id: string;
+}, {
+    function: {
+        name: string;
+        arguments: string;
+    } & {
+        [k: string]: unknown;
+    };
+    id: string;
+    type?: "function" | undefined;
+}>, "many">;
+/**
+ * Creates an empty OpenAI tool call with fields but no values filled in
+ */
+export declare function createOpenAIToolCall(): OpenAIToolCall;
+//# sourceMappingURL=toolCallSchemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolCallSchemas.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/llm/openai/toolCallSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa/B,CAAC;AAEH;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAAgC,CAAC;AAEnE;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,cAAc,CASrD"}

package/dist/src/schemas/llm/openai/toolCallSchemas.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openAIToolCallsSchema = exports.openAIToolCallSchema = void 0;
+exports.createOpenAIToolCall = createOpenAIToolCall;
+const zod_1 = __importDefault(require("zod"));
+/**
+ * The schema for an OpenAI tool call, this is what a message that calls a tool looks like
+ *
+ * Note: The nested passThrough's are used to allow for extra keys in JSON schema, however, they do not actually
+ * allow for extra keys when the zod schema is used for parsing. This is to allow more flexibility for users
+ * to define their own tool calls according
+ */
+exports.openAIToolCallSchema = zod_1.default.object({
+    type: zod_1.default
+        .literal("function")
+        .optional()
+        .transform(() => "function"),
+    id: zod_1.default.string().describe("The ID of the tool call"),
+    function: zod_1.default
+        .object({
+        name: zod_1.default.string().describe("The name of the function"),
+        arguments: zod_1.default.string().describe("The arguments for the function"),
+    })
+        .describe("The function that is being called")
+        .passthrough(),
+});
+/**
+ * The zod schema for multiple OpenAI Tool Calls
+ */
+exports.openAIToolCallsSchema = zod_1.default.array(exports.openAIToolCallSchema);
+/**
+ * Creates an empty OpenAI tool call with fields but no values filled in
+ */
+function createOpenAIToolCall() {
+    return {
+        type: "function",
+        id: "",
+        function: {
+            name: "",
+            arguments: "{}",
+        },
+    };
+}
+//# sourceMappingURL=toolCallSchemas.js.map

package/dist/src/schemas/llm/openai/toolCallSchemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolCallSchemas.js","sourceRoot":"","sources":["../../../../../src/schemas/llm/openai/toolCallSchemas.ts"],"names":[],"mappings":";;;;;;AAgDA,oDASC;AAzDD,8CAAoB;AAEpB;;;;;;GAMG;AACU,QAAA,oBAAoB,GAAG,aAAC,CAAC,MAAM,CAAC;IAC3C,IAAI,EAAE,aAAC;SACJ,OAAO,CAAC,UAAU,CAAC;SACnB,QAAQ,EAAE;SACV,SAAS,CAAC,GAAG,EAAE,CAAC,UAAmB,CAAC;IACvC,EAAE,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,yBAAyB,CAAC;IAClD,QAAQ,EAAE,aAAC;SACR,MAAM,CAAC;QACN,IAAI,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,0BAA0B,CAAC;QACrD,SAAS,EAAE,aAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,gCAAgC,CAAC;KACjE,CAAC;SACD,QAAQ,CAAC,mCAAmC,CAAC;SAC7C,WAAW,EAAE;CACjB,CAAC,CAAC;AAkBH;;GAEG;AACU,QAAA,qBAAqB,GAAG,aAAC,CAAC,KAAK,CAAC,4BAAoB,CAAC,CAAC;AAEnE;;GAEG;AACH,SAAgB,oBAAoB;IAClC,OAAO;QACL,IAAI,EAAE,UAAU;QAChB,EAAE,EAAE,EAAE;QACN,QAAQ,EAAE;YACR,IAAI,EAAE,EAAE;YACR,SAAS,EAAE,IAAI;SAChB;KACF,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,28 @@
+import z from "zod";
+/**
+ * OpenAI's tool choice schema
+ *
+ * @see https://platform.openAI.com/docs/api-reference/chat/create#chat-create-tool_choice
+ */
+export declare const openAIToolChoiceSchema: z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodLiteral<"required">, z.ZodObject<{
+    type: z.ZodLiteral<"function">;
+    function: z.ZodObject<{
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+    }, {
+        name: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    function: {
+        name: string;
+    };
+    type: "function";
+}, {
+    function: {
+        name: string;
+    };
+    type: "function";
+}>]>;
+export type OpenaiToolChoice = z.infer<typeof openAIToolChoiceSchema>;
+//# sourceMappingURL=toolChoiceSchemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolChoiceSchemas.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/llm/openai/toolChoiceSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;IAQjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/src/schemas/llm/openai/toolChoiceSchemas.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openAIToolChoiceSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+/**
+ * OpenAI's tool choice schema
+ *
+ * @see https://platform.openAI.com/docs/api-reference/chat/create#chat-create-tool_choice
+ */
+exports.openAIToolChoiceSchema = zod_1.default.union([
+    zod_1.default.literal("auto"),
+    zod_1.default.literal("none"),
+    zod_1.default.literal("required"),
+    zod_1.default.object({
+        type: zod_1.default.literal("function"),
+        function: zod_1.default.object({ name: zod_1.default.string() }),
+    }),
+]);
+//# sourceMappingURL=toolChoiceSchemas.js.map

package/dist/src/schemas/llm/openai/toolChoiceSchemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolChoiceSchemas.js","sourceRoot":"","sources":["../../../../../src/schemas/llm/openai/toolChoiceSchemas.ts"],"names":[],"mappings":";;;;;;AAAA,8CAAoB;AAEpB;;;;GAIG;AACU,QAAA,sBAAsB,GAAG,aAAC,CAAC,KAAK,CAAC;IAC5C,aAAC,CAAC,OAAO,CAAC,MAAM,CAAC;IACjB,aAAC,CAAC,OAAO,CAAC,MAAM,CAAC;IACjB,aAAC,CAAC,OAAO,CAAC,UAAU,CAAC;IACrB,aAAC,CAAC,MAAM,CAAC;QACP,IAAI,EAAE,aAAC,CAAC,OAAO,CAAC,UAAU,CAAC;QAC3B,QAAQ,EAAE,aAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,aAAC,CAAC,MAAM,EAAE,EAAE,CAAC;KACzC,CAAC;CACH,CAAC,CAAC"}