@mastra/connect 0.1.0-alpha.0 → 0.2.0-alpha.1

package/dist/providers/openai/tools/cancel-fine-tuning-job.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const cancelFineTuningJobInputSchema: z.ZodObject<{
+    fine_tuning_job_id: z.ZodString;
+}, z.core.$strip>;
+export declare const cancelFineTuningJobOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodString;
+    created_at: z.ZodNumber;
+    finished_at: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    model: z.ZodString;
+    fine_tuned_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    organization_id: z.ZodString;
+    result_files: z.ZodArray<z.ZodString>;
+    status: z.ZodString;
+    validation_file: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    training_file: z.ZodString;
+    hyperparameters: z.ZodObject<{
+        n_epochs: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        batch_size: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        learning_rate_multiplier: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    }, z.core.$loose>;
+    trained_tokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        code: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+        param: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export declare function cancelFineTuningJobTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    fine_tuning_job_id: string;
+}, {
+    [x: string]: unknown;
+    id: string;
+    object: string;
+    created_at: number;
+    finished_at?: number | null | undefined;
+    model: string;
+    fine_tuned_model?: string | null | undefined;
+    organization_id: string;
+    result_files: string[];
+    status: string;
+    validation_file?: string | null | undefined;
+    training_file: string;
+    hyperparameters: {
+        [x: string]: unknown;
+        n_epochs?: string | number | undefined;
+        batch_size?: string | number | undefined;
+        learning_rate_multiplier?: string | number | undefined;
+    };
+    trained_tokens?: number | null | undefined;
+    error?: {
+        [x: string]: unknown;
+        code?: string | undefined;
+        message?: string | undefined;
+        param?: string | null | undefined;
+        line?: number | null | undefined;
+    } | null | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "openai_cancel_fine_tuning_job", unknown>;
+//# sourceMappingURL=cancel-fine-tuning-job.d.ts.map

package/dist/providers/openai/tools/cancel-fine-tuning-job.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cancel-fine-tuning-job.d.ts","sourceRoot":"","sources":["../../../../src/providers/openai/tools/cancel-fine-tuning-job.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,8BAA8B;;iBAEzC,CAAC;AAqBH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;iBAiBlC,CAAC;AAEX,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6IAiD3D"}

package/dist/providers/openai/tools/create-batch.d.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createBatchInputSchema: z.ZodObject<{
+    input_file_id: z.ZodString;
+    endpoint: z.ZodEnum<{
+        "/v1/chat/completions": "/v1/chat/completions";
+        "/v1/completions": "/v1/completions";
+        "/v1/embeddings": "/v1/embeddings";
+        "/v1/images/edits": "/v1/images/edits";
+        "/v1/images/generations": "/v1/images/generations";
+        "/v1/moderations": "/v1/moderations";
+        "/v1/responses": "/v1/responses";
+        "/v1/videos": "/v1/videos";
+    }>;
+    completion_window: z.ZodLiteral<"24h">;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    output_expires_after: z.ZodOptional<z.ZodObject<{
+        anchor: z.ZodLiteral<"created_at">;
+        seconds: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const createBatchOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodString;
+    endpoint: z.ZodString;
+    input_file_id: z.ZodString;
+    completion_window: z.ZodString;
+    status: z.ZodString;
+    output_file_id: z.ZodOptional<z.ZodString>;
+    error_file_id: z.ZodOptional<z.ZodString>;
+    created_at: z.ZodNumber;
+    in_progress_at: z.ZodOptional<z.ZodNumber>;
+    expires_at: z.ZodOptional<z.ZodNumber>;
+    finalizing_at: z.ZodOptional<z.ZodNumber>;
+    completed_at: z.ZodOptional<z.ZodNumber>;
+    failed_at: z.ZodOptional<z.ZodNumber>;
+    expired_at: z.ZodOptional<z.ZodNumber>;
+    cancelling_at: z.ZodOptional<z.ZodNumber>;
+    cancelled_at: z.ZodOptional<z.ZodNumber>;
+    request_counts: z.ZodOptional<z.ZodObject<{
+        total: z.ZodNumber;
+        completed: z.ZodNumber;
+        failed: z.ZodNumber;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export declare function createBatchTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    input_file_id: string;
+    endpoint: "/v1/chat/completions" | "/v1/completions" | "/v1/embeddings" | "/v1/images/edits" | "/v1/images/generations" | "/v1/moderations" | "/v1/responses" | "/v1/videos";
+    completion_window: "24h";
+    metadata?: Record<string, string> | undefined;
+    output_expires_after?: {
+        anchor: "created_at";
+        seconds: number;
+    } | undefined;
+}, {
+    id: string;
+    object: string;
+    endpoint: string;
+    input_file_id: string;
+    completion_window: string;
+    status: string;
+    output_file_id?: string | undefined;
+    error_file_id?: string | undefined;
+    created_at: number;
+    in_progress_at?: number | undefined;
+    expires_at?: number | undefined;
+    finalizing_at?: number | undefined;
+    completed_at?: number | undefined;
+    failed_at?: number | undefined;
+    expired_at?: number | undefined;
+    cancelling_at?: number | undefined;
+    cancelled_at?: number | undefined;
+    request_counts?: {
+        total: number;
+        completed: number;
+        failed: number;
+    } | undefined;
+    metadata?: Record<string, string> | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "openai_create_batch", unknown>;
+//# sourceMappingURL=create-batch.d.ts.map

package/dist/providers/openai/tools/create-batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-batch.d.ts","sourceRoot":"","sources":["../../../../src/providers/openai/tools/create-batch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;iBA8BjC,CAAC;AAiDH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;iBA0BlC,CAAC;AAEH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mIA8CnD"}

package/dist/providers/openai/tools/create-chat-completion.d.ts

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createChatCompletionInputSchema: z.ZodObject<{
+    model: z.ZodString;
+    messages: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<{
+            assistant: "assistant";
+            system: "system";
+            tool: "tool";
+            user: "user";
+        }>;
+        content: z.ZodString;
+    }, z.core.$strip>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    max_completion_tokens: z.ZodOptional<z.ZodNumber>;
+    max_tokens: z.ZodOptional<z.ZodNumber>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    tool_choice: z.ZodOptional<z.ZodUnknown>;
+    response_format: z.ZodOptional<z.ZodUnknown>;
+    stream: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const createChatCompletionOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodString;
+    created: z.ZodNumber;
+    model: z.ZodString;
+    choices: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        message: z.ZodObject<{
+            role: z.ZodString;
+            content: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>;
+        finish_reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    usage: z.ZodOptional<z.ZodObject<{
+        prompt_tokens: z.ZodNumber;
+        completion_tokens: z.ZodNumber;
+        total_tokens: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function createChatCompletionTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    model: string;
+    messages: {
+        role: "assistant" | "system" | "tool" | "user";
+        content: string;
+    }[];
+    temperature?: number | undefined;
+    max_completion_tokens?: number | undefined;
+    max_tokens?: number | undefined;
+    tools?: unknown[] | undefined;
+    tool_choice?: unknown;
+    response_format?: unknown;
+    stream?: boolean | undefined;
+}, {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: {
+        index: number;
+        message: {
+            role: string;
+            content?: string | null | undefined;
+        };
+        finish_reason?: string | null | undefined;
+    }[];
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    } | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "openai_create_chat_completion", unknown>;
+//# sourceMappingURL=create-chat-completion.d.ts.map

package/dist/providers/openai/tools/create-chat-completion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-chat-completion.d.ts","sourceRoot":"","sources":["../../../../src/providers/openai/tools/create-chat-completion.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAOxE,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;iBAoB1C,CAAC;AA0BH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;iBAO3C,CAAC;AAEH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6IAwC5D"}

package/dist/providers/openai/tools/create-embedding.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createEmbeddingInputSchema: z.ZodObject<{
+    model: z.ZodString;
+    input: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    encodingFormat: z.ZodOptional<z.ZodEnum<{
+        base64: "base64";
+        float: "float";
+    }>>;
+    dimensions: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const createEmbeddingOutputSchema: z.ZodObject<{
+    object: z.ZodString;
+    data: z.ZodArray<z.ZodObject<{
+        object: z.ZodString;
+        embedding: z.ZodArray<z.ZodNumber>;
+        index: z.ZodNumber;
+    }, z.core.$strip>>;
+    model: z.ZodString;
+    usage: z.ZodObject<{
+        promptTokens: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare function createEmbeddingTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    model: string;
+    input: string | string[];
+    encodingFormat?: "base64" | "float" | undefined;
+    dimensions?: number | undefined;
+}, {
+    object: string;
+    data: {
+        object: string;
+        embedding: number[];
+        index: number;
+    }[];
+    model: string;
+    usage: {
+        promptTokens: number;
+        totalTokens: number;
+    };
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "openai_create_embedding", unknown>;
+//# sourceMappingURL=create-embedding.d.ts.map

package/dist/providers/openai/tools/create-embedding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-embedding.d.ts","sourceRoot":"","sources":["../../../../src/providers/openai/tools/create-embedding.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,0BAA0B;;;;;;;;iBAerC,CAAC;AAoBH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;iBActC,CAAC;AAEH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;uIA4CvD"}

package/dist/providers/openai/tools/create-image.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createImageInputSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    n: z.ZodOptional<z.ZodNumber>;
+    size: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodString]>>;
+    quality: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        high: "high";
+        low: "low";
+        max: "max";
+        medium: "medium";
+        xhigh: "xhigh";
+    }>>;
+    background: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        opaque: "opaque";
+        transparent: "transparent";
+    }>>;
+    moderation: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        low: "low";
+    }>>;
+    output_compression: z.ZodOptional<z.ZodNumber>;
+    output_format: z.ZodOptional<z.ZodEnum<{
+        jpeg: "jpeg";
+        png: "png";
+        webp: "webp";
+    }>>;
+    user: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const createImageOutputSchema: z.ZodObject<{
+    created: z.ZodOptional<z.ZodNumber>;
+    data: z.ZodArray<z.ZodObject<{
+        url: z.ZodOptional<z.ZodString>;
+        b64_json: z.ZodOptional<z.ZodString>;
+        revised_prompt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function createImageTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    prompt: string;
+    model?: string | undefined;
+    n?: number | undefined;
+    size?: string | undefined;
+    quality?: "auto" | "high" | "low" | "max" | "medium" | "xhigh" | undefined;
+    background?: "auto" | "opaque" | "transparent" | undefined;
+    moderation?: "auto" | "low" | undefined;
+    output_compression?: number | undefined;
+    output_format?: "jpeg" | "png" | "webp" | undefined;
+    user?: string | undefined;
+}, {
+    created?: number | undefined;
+    data: {
+        url?: string | undefined;
+        b64_json?: string | undefined;
+        revised_prompt?: string | undefined;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "openai_create_image", unknown>;
+//# sourceMappingURL=create-image.d.ts.map

package/dist/providers/openai/tools/create-image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-image.d.ts","sourceRoot":"","sources":["../../../../src/providers/openai/tools/create-image.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCjC,CAAC;AAaH,eAAO,MAAM,uBAAuB;;;;;;;iBASlC,CAAC;AAEH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;mIAuCnD"}

package/dist/providers/openai/tools/create-moderation.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createModerationInputSchema: z.ZodObject<{
+    input: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"image_url">;
+        image_url: z.ZodObject<{
+            url: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "type">>]>;
+    model: z.ZodOptional<z.ZodEnum<{
+        "omni-moderation-2024-09-26": "omni-moderation-2024-09-26";
+        "omni-moderation-latest": "omni-moderation-latest";
+        "text-moderation-latest": "text-moderation-latest";
+        "text-moderation-stable": "text-moderation-stable";
+    }>>;
+}, z.core.$strip>;
+export declare const createModerationOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    model: z.ZodString;
+    results: z.ZodArray<z.ZodObject<{
+        flagged: z.ZodBoolean;
+        categories: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodBoolean>>;
+        category_scores: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function createModerationTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    input: string | string[] | ({
+        type: "text";
+        text: string;
+    } | {
+        type: "image_url";
+        image_url: {
+            url: string;
+        };
+    })[];
+    model?: "omni-moderation-2024-09-26" | "omni-moderation-latest" | "text-moderation-latest" | "text-moderation-stable" | undefined;
+}, {
+    id: string;
+    model: string;
+    results: {
+        flagged: boolean;
+        categories: Record<string, boolean | null>;
+        category_scores: Record<string, number | null>;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "openai_create_moderation", unknown>;
+//# sourceMappingURL=create-moderation.d.ts.map

package/dist/providers/openai/tools/create-moderation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-moderation.d.ts","sourceRoot":"","sources":["../../../../src/providers/openai/tools/create-moderation.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AA2DxE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;iBAQtC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;iBAUvC,CAAC;AAEH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;wIA+BxD"}

package/dist/providers/openai/tools/create-response.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createResponseInputSchema: z.ZodObject<{
+    model: z.ZodString;
+    input: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>;
+    instructions: z.ZodOptional<z.ZodString>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    tool_choice: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    max_output_tokens: z.ZodOptional<z.ZodNumber>;
+    store: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const createResponseOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    output: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    usage: z.ZodOptional<z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+        total_tokens: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function createResponseTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    model: string;
+    input: string | Record<string, unknown>[];
+    instructions?: string | undefined;
+    tools?: Record<string, unknown>[] | undefined;
+    tool_choice?: string | Record<string, unknown> | undefined;
+    temperature?: number | undefined;
+    max_output_tokens?: number | undefined;
+    store?: boolean | undefined;
+}, {
+    id: string;
+    output: Record<string, unknown>[];
+    usage?: {
+        input_tokens: number;
+        output_tokens: number;
+        total_tokens: number;
+    } | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "openai_create_response", unknown>;
+//# sourceMappingURL=create-response.d.ts.map

package/dist/providers/openai/tools/create-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-response.d.ts","sourceRoot":"","sources":["../../../../src/providers/openai/tools/create-response.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,yBAAyB;;;;;;;;;iBASpC,CAAC;AAoBH,eAAO,MAAM,0BAA0B;;;;;;;;iBAUrC,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;sIA+DtD"}

package/dist/providers/openai/tools/create-vector-store.d.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createVectorStoreInputSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    file_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    expires_after: z.ZodOptional<z.ZodObject<{
+        anchor: z.ZodLiteral<"last_active_at">;
+        days: z.ZodNumber;
+    }, z.core.$strip>>;
+    chunking_strategy: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"auto">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"static">;
+        static: z.ZodObject<{
+            max_chunk_size_tokens: z.ZodNumber;
+            chunk_overlap_tokens: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>>;
+    metadata: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+}, z.core.$strip>;
+export declare const createVectorStoreOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    status: z.ZodUnion<readonly [z.ZodLiteral<"completed">, z.ZodLiteral<"in_progress">, z.ZodLiteral<"expired">]>;
+    file_counts: z.ZodObject<{
+        in_progress: z.ZodNumber;
+        completed: z.ZodNumber;
+        failed: z.ZodNumber;
+        cancelled: z.ZodNumber;
+        total: z.ZodNumber;
+    }, z.core.$strip>;
+    usage_bytes: z.ZodNumber;
+    created_at: z.ZodNumber;
+    last_active_at: z.ZodOptional<z.ZodNumber>;
+    expires_after: z.ZodOptional<z.ZodObject<{
+        anchor: z.ZodLiteral<"last_active_at">;
+        days: z.ZodNumber;
+    }, z.core.$strip>>;
+    chunking_strategy: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"auto">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"static">;
+        static: z.ZodObject<{
+            max_chunk_size_tokens: z.ZodNumber;
+            chunk_overlap_tokens: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>>;
+    metadata: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+}, z.core.$strip>;
+export declare function createVectorStoreTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    name?: string | undefined;
+    file_ids?: string[] | undefined;
+    expires_after?: {
+        anchor: "last_active_at";
+        days: number;
+    } | undefined;
+    chunking_strategy?: {
+        type: "auto";
+    } | {
+        type: "static";
+        static: {
+            max_chunk_size_tokens: number;
+            chunk_overlap_tokens: number;
+        };
+    } | undefined;
+    metadata?: {
+        [x: string]: unknown;
+    } | undefined;
+}, {
+    id: string;
+    name?: string | undefined;
+    status: "completed" | "expired" | "in_progress";
+    file_counts: {
+        in_progress: number;
+        completed: number;
+        failed: number;
+        cancelled: number;
+        total: number;
+    };
+    usage_bytes: number;
+    created_at: number;
+    last_active_at?: number | undefined;
+    expires_after?: {
+        anchor: "last_active_at";
+        days: number;
+    } | undefined;
+    chunking_strategy?: {
+        type: "auto";
+    } | {
+        type: "static";
+        static: {
+            max_chunk_size_tokens: number;
+            chunk_overlap_tokens: number;
+        };
+    } | undefined;
+    metadata?: {
+        [x: string]: unknown;
+    } | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "openai_create_vector_store", unknown>;
+//# sourceMappingURL=create-vector-store.d.ts.map

package/dist/providers/openai/tools/create-vector-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-vector-store.d.ts","sourceRoot":"","sources":["../../../../src/providers/openai/tools/create-vector-store.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAsBxE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;iBAMvC,CAAC;AAwBH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAWxC,CAAC;AAEH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0IAsDzD"}

package/dist/providers/openai/tools/delete-response.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const deleteResponseInputSchema: z.ZodObject<{
+    response_id: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteResponseOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    deleted: z.ZodBoolean;
+}, z.core.$strip>;
+export declare function deleteResponseTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    response_id: string;
+}, {
+    id: string;
+    deleted: boolean;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "openai_delete_response", unknown>;
+//# sourceMappingURL=delete-response.d.ts.map

package/dist/providers/openai/tools/delete-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-response.d.ts","sourceRoot":"","sources":["../../../../src/providers/openai/tools/delete-response.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,yBAAyB;;iBAEpC,CAAC;AAQH,eAAO,MAAM,0BAA0B;;;iBAGrC,CAAC;AAEH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa;;;;;sIAsBtD"}

package/dist/providers/openai/tools/delete-vector-store-file.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const deleteVectorStoreFileInputSchema: z.ZodObject<{
+    vector_store_id: z.ZodString;
+    file_id: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteVectorStoreFileOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodLiteral<"vector_store.file.deleted">;
+    deleted: z.ZodBoolean;
+}, z.core.$strip>;
+export declare function deleteVectorStoreFileTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    vector_store_id: string;
+    file_id: string;
+}, {
+    id: string;
+    object: "vector_store.file.deleted";
+    deleted: boolean;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "openai_delete_vector_store_file", unknown>;
+//# sourceMappingURL=delete-vector-store-file.d.ts.map

package/dist/providers/openai/tools/delete-vector-store-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-vector-store-file.d.ts","sourceRoot":"","sources":["../../../../src/providers/openai/tools/delete-vector-store-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,gCAAgC;;;iBAG3C,CAAC;AAQH,eAAO,MAAM,iCAAiC;;;;iBAI5C,CAAC;AAEH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,aAAa;;;;;;;+IAgC7D"}

package/dist/providers/openai/tools/delete-vector-store.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const deleteVectorStoreInputSchema: z.ZodObject<{
+    vector_store_id: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteVectorStoreOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodLiteral<"vector_store.deleted">;
+    deleted: z.ZodBoolean;
+}, z.core.$strip>;
+export declare function deleteVectorStoreTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    vector_store_id: string;
+}, {
+    id: string;
+    object: "vector_store.deleted";
+    deleted: boolean;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "openai_delete_vector_store", unknown>;
+//# sourceMappingURL=delete-vector-store.d.ts.map

package/dist/providers/openai/tools/delete-vector-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-vector-store.d.ts","sourceRoot":"","sources":["../../../../src/providers/openai/tools/delete-vector-store.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,4BAA4B;;iBAEvC,CAAC;AAQH,eAAO,MAAM,6BAA6B;;;;iBAIxC,CAAC;AAEH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa;;;;;;0IA+BzD"}