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

package/dist/providers/anthropic/index.d.ts

@@ -0,0 +1,5 @@
+import type { ProviderRegistration } from '../../registry.js';
+import { createAnthropicTools } from './tools.js';
+export declare const anthropicProvider: ProviderRegistration;
+export { createAnthropicTools };
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/anthropic/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/anthropic/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAElD,eAAO,MAAM,iBAAiB,EAAE,oBAI/B,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/providers/anthropic/tools/cancel-message-batch.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const cancelMessageBatchInputSchema: z.ZodObject<{
+    message_batch_id: z.ZodString;
+}, z.core.$strip>;
+export declare const cancelMessageBatchOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    archived_at: z.ZodOptional<z.ZodString>;
+    cancel_initiated_at: z.ZodOptional<z.ZodString>;
+    created_at: z.ZodString;
+    ended_at: z.ZodOptional<z.ZodString>;
+    expires_at: z.ZodString;
+    processing_status: z.ZodEnum<{
+        canceling: "canceling";
+        ended: "ended";
+        in_progress: "in_progress";
+    }>;
+    request_counts: z.ZodObject<{
+        canceled: z.ZodNumber;
+        errored: z.ZodNumber;
+        expired: z.ZodNumber;
+        processing: z.ZodNumber;
+        succeeded: z.ZodNumber;
+    }, z.core.$strip>;
+    results_url: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"message_batch">;
+}, z.core.$strip>;
+export declare function cancelMessageBatchTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    message_batch_id: string;
+}, {
+    id: string;
+    archived_at?: string | undefined;
+    cancel_initiated_at?: string | undefined;
+    created_at: string;
+    ended_at?: string | undefined;
+    expires_at: string;
+    processing_status: "canceling" | "ended" | "in_progress";
+    request_counts: {
+        canceled: number;
+        errored: number;
+        expired: number;
+        processing: number;
+        succeeded: number;
+    };
+    results_url?: string | undefined;
+    type: "message_batch";
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "anthropic_cancel_message_batch", unknown>;
+//# sourceMappingURL=cancel-message-batch.d.ts.map

package/dist/providers/anthropic/tools/cancel-message-batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cancel-message-batch.d.ts","sourceRoot":"","sources":["../../../../src/providers/anthropic/tools/cancel-message-batch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,6BAA6B;;iBAIxC,CAAC;AAuBH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;iBAiBzC,CAAC;AAEH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;8IAsC1D"}

package/dist/providers/anthropic/tools/count-message-tokens.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const countMessageTokensInputSchema: z.ZodObject<{
+    model: z.ZodString;
+    messages: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<{
+            assistant: "assistant";
+            user: "user";
+        }>;
+        content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>;
+    }, z.core.$strip>>;
+    system: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>>;
+    thinking: z.ZodOptional<z.ZodUnknown>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    tool_choice: z.ZodOptional<z.ZodUnknown>;
+    cache_control: z.ZodOptional<z.ZodUnknown>;
+    output_config: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const countMessageTokensOutputSchema: z.ZodObject<{
+    input_tokens: z.ZodNumber;
+}, z.core.$strip>;
+export declare function countMessageTokensTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    model: string;
+    messages: {
+        role: "assistant" | "user";
+        content: string | Record<string, unknown>[];
+    }[];
+    system?: string | Record<string, unknown>[] | undefined;
+    thinking?: unknown;
+    tools?: unknown[] | undefined;
+    tool_choice?: unknown;
+    cache_control?: unknown;
+    output_config?: unknown;
+}, {
+    input_tokens: number;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "anthropic_count_message_tokens", unknown>;
+//# sourceMappingURL=count-message-tokens.d.ts.map

package/dist/providers/anthropic/tools/count-message-tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"count-message-tokens.d.ts","sourceRoot":"","sources":["../../../../src/providers/anthropic/tools/count-message-tokens.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAOxE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;iBAYxC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;iBAIzC,CAAC;AAEH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;8IA+B1D"}

package/dist/providers/anthropic/tools/create-message-batch.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createMessageBatchInputSchema: z.ZodObject<{
+    requests: z.ZodArray<z.ZodObject<{
+        custom_id: z.ZodString;
+        params: z.ZodObject<{}, z.core.$loose>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const createMessageBatchOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    processing_status: z.ZodString;
+    request_counts: z.ZodObject<{
+        processing: z.ZodNumber;
+        succeeded: z.ZodNumber;
+        errored: z.ZodNumber;
+        canceled: z.ZodNumber;
+        expired: z.ZodNumber;
+    }, z.core.$strip>;
+    created_at: z.ZodString;
+    expires_at: z.ZodString;
+    ended_at: z.ZodOptional<z.ZodString>;
+    cancel_initiated_at: z.ZodOptional<z.ZodString>;
+    results_url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function createMessageBatchTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    requests: {
+        custom_id: string;
+        params: {
+            [x: string]: unknown;
+        };
+    }[];
+}, {
+    id: string;
+    type: string;
+    processing_status: string;
+    request_counts: {
+        processing: number;
+        succeeded: number;
+        errored: number;
+        canceled: number;
+        expired: number;
+    };
+    created_at: string;
+    expires_at: string;
+    ended_at?: string | undefined;
+    cancel_initiated_at?: string | undefined;
+    results_url?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "anthropic_create_message_batch", unknown>;
+//# sourceMappingURL=create-message-batch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-message-batch.d.ts","sourceRoot":"","sources":["../../../../src/providers/anthropic/tools/create-message-batch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,6BAA6B;;;;;iBAgBxC,CAAC;AAsBH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;iBAUzC,CAAC;AAEH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;8IAgC1D"}

package/dist/providers/anthropic/tools/create-message.d.ts

@@ -0,0 +1,193 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const createMessageInputSchema: z.ZodObject<{
+    model: z.ZodString;
+    max_tokens: z.ZodNumber;
+    messages: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<{
+            assistant: "assistant";
+            user: "user";
+        }>;
+        content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            source: z.ZodObject<{
+                type: z.ZodString;
+                media_type: z.ZodString;
+                data: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_use">;
+            id: z.ZodString;
+            name: z.ZodString;
+            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_result">;
+            tool_use_id: z.ZodString;
+            content: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                source: z.ZodObject<{
+                    type: z.ZodString;
+                    media_type: z.ZodString;
+                    data: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>]>>]>>;
+            is_error: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>]>>]>;
+    }, z.core.$strip>>;
+    system: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>>]>>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        input_schema: z.ZodObject<{
+            type: z.ZodLiteral<"object">;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            required: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    tool_choice: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    thinking: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        budget_tokens: z.ZodNumber;
+    }, z.core.$strip>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    top_k: z.ZodOptional<z.ZodNumber>;
+    top_p: z.ZodOptional<z.ZodNumber>;
+    stop_sequences: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export declare const createMessageOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"message">;
+    role: z.ZodLiteral<"assistant">;
+    content: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_use">;
+        id: z.ZodString;
+        name: z.ZodString;
+        input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"thinking">;
+        thinking: z.ZodString;
+        signature: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"redacted_thinking">;
+        data: z.ZodString;
+    }, z.core.$strip>]>>;
+    model: z.ZodString;
+    stop_reason: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+    stop_sequence: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+        cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+        cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare function createMessageTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    model: string;
+    max_tokens: number;
+    messages: {
+        role: "assistant" | "user";
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "image";
+            source: {
+                type: string;
+                media_type: string;
+                data: string;
+            };
+        } | {
+            type: "tool_use";
+            id: string;
+            name: string;
+            input: Record<string, unknown>;
+        } | {
+            type: "tool_result";
+            tool_use_id: string;
+            content?: string | ({
+                type: "text";
+                text: string;
+            } | {
+                type: "image";
+                source: {
+                    type: string;
+                    media_type: string;
+                    data: string;
+                };
+            })[] | undefined;
+            is_error?: boolean | undefined;
+        })[];
+    }[];
+    system?: string | {
+        type: "text";
+        text: string;
+    }[] | undefined;
+    tools?: {
+        name: string;
+        description: string;
+        input_schema: {
+            type: "object";
+            properties?: Record<string, unknown> | undefined;
+            required?: string[] | undefined;
+        };
+    }[] | undefined;
+    tool_choice?: {
+        type: string;
+        name?: string | undefined;
+    } | undefined;
+    thinking?: {
+        type: string;
+        budget_tokens: number;
+    } | undefined;
+    temperature?: number | undefined;
+    top_k?: number | undefined;
+    top_p?: number | undefined;
+    stop_sequences?: string[] | undefined;
+    metadata?: Record<string, string> | undefined;
+}, {
+    id: string;
+    type: "message";
+    role: "assistant";
+    content: ({
+        type: "text";
+        text: string;
+    } | {
+        type: "tool_use";
+        id: string;
+        name: string;
+        input: Record<string, unknown>;
+    } | {
+        type: "thinking";
+        thinking: string;
+        signature?: string | undefined;
+    } | {
+        type: "redacted_thinking";
+        data: string;
+    })[];
+    model: string;
+    stop_reason?: string | null | undefined;
+    stop_sequence?: string | null | undefined;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+        cache_creation_input_tokens?: number | undefined;
+        cache_read_input_tokens?: number | undefined;
+    };
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "anthropic_create_message", unknown>;
+//# sourceMappingURL=create-message.d.ts.map

package/dist/providers/anthropic/tools/create-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-message.d.ts","sourceRoot":"","sources":["../../../../src/providers/anthropic/tools/create-message.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAyDxE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgBnC,CAAC;AAuBH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASpC,CAAC;AAEH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wIA2FrD"}

package/dist/providers/anthropic/tools/delete-file.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const deleteFileInputSchema: z.ZodObject<{
+    file_id: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteFileOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodOptional<z.ZodLiteral<"file_deleted">>;
+}, z.core.$strip>;
+export declare function deleteFileTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    file_id: string;
+}, {
+    id: string;
+    type?: "file_deleted" | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "anthropic_delete_file", unknown>;
+//# sourceMappingURL=delete-file.d.ts.map

package/dist/providers/anthropic/tools/delete-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-file.d.ts","sourceRoot":"","sources":["../../../../src/providers/anthropic/tools/delete-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,qBAAqB;;iBAEhC,CAAC;AAOH,eAAO,MAAM,sBAAsB;;;iBAGjC,CAAC;AAEH,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa;;;;;qIAyBlD"}

package/dist/providers/anthropic/tools/get-file.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getFileInputSchema: z.ZodObject<{
+    file_id: z.ZodString;
+}, z.core.$strip>;
+export declare const getFileOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    created_at: z.ZodString;
+    filename: z.ZodString;
+    mime_type: z.ZodString;
+    size_bytes: z.ZodNumber;
+    type: z.ZodLiteral<"file">;
+    downloadable: z.ZodOptional<z.ZodBoolean>;
+    scope: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"session">;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare function getFileTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    file_id: string;
+}, {
+    id: string;
+    created_at: string;
+    filename: string;
+    mime_type: string;
+    size_bytes: number;
+    type: "file";
+    downloadable?: boolean | undefined;
+    scope?: {
+        id: string;
+        type: "session";
+    } | null | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "anthropic_get_file", unknown>;
+//# sourceMappingURL=get-file.d.ts.map

package/dist/providers/anthropic/tools/get-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-file.d.ts","sourceRoot":"","sources":["../../../../src/providers/anthropic/tools/get-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,kBAAkB;;iBAE7B,CAAC;AAOH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;iBAS9B,CAAC;AAEH,wBAAgB,WAAW,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;kIAsB/C"}

package/dist/providers/anthropic/tools/get-message-batch.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getMessageBatchInputSchema: z.ZodObject<{
+    message_batch_id: z.ZodString;
+}, z.core.$strip>;
+export declare const getMessageBatchOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    archived_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    cancel_initiated_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    created_at: z.ZodString;
+    ended_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    expires_at: z.ZodString;
+    processing_status: z.ZodEnum<{
+        canceling: "canceling";
+        ended: "ended";
+        in_progress: "in_progress";
+    }>;
+    request_counts: z.ZodObject<{
+        canceled: z.ZodNumber;
+        errored: z.ZodNumber;
+        expired: z.ZodNumber;
+        processing: z.ZodNumber;
+        succeeded: z.ZodNumber;
+    }, z.core.$strip>;
+    results_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    type: z.ZodLiteral<"message_batch">;
+}, z.core.$strip>;
+export declare function getMessageBatchTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    message_batch_id: string;
+}, {
+    id: string;
+    archived_at?: string | null | undefined;
+    cancel_initiated_at?: string | null | undefined;
+    created_at: string;
+    ended_at?: string | null | undefined;
+    expires_at: string;
+    processing_status: "canceling" | "ended" | "in_progress";
+    request_counts: {
+        canceled: number;
+        errored: number;
+        expired: number;
+        processing: number;
+        succeeded: number;
+    };
+    results_url?: string | null | undefined;
+    type: "message_batch";
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "anthropic_get_message_batch", unknown>;
+//# sourceMappingURL=get-message-batch.d.ts.map

package/dist/providers/anthropic/tools/get-message-batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-message-batch.d.ts","sourceRoot":"","sources":["../../../../src/providers/anthropic/tools/get-message-batch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAExE,eAAO,MAAM,0BAA0B;;iBAIrC,CAAC;AAUH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;iBAWtC,CAAC;AAEH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;2IAkBvD"}

package/dist/providers/anthropic/tools/get-model.d.ts

@@ -0,0 +1,146 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const getModelInputSchema: z.ZodObject<{
+    model_id: z.ZodString;
+}, z.core.$strip>;
+export declare const getModelOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    capabilities: z.ZodObject<{
+        batch: z.ZodObject<{
+            supported: z.ZodBoolean;
+        }, z.core.$strip>;
+        citations: z.ZodObject<{
+            supported: z.ZodBoolean;
+        }, z.core.$strip>;
+        code_execution: z.ZodObject<{
+            supported: z.ZodBoolean;
+        }, z.core.$strip>;
+        context_management: z.ZodObject<{
+            clear_thinking_20251015: z.ZodObject<{
+                supported: z.ZodBoolean;
+            }, z.core.$strip>;
+            clear_tool_uses_20250919: z.ZodObject<{
+                supported: z.ZodBoolean;
+            }, z.core.$strip>;
+            compact_20260112: z.ZodObject<{
+                supported: z.ZodBoolean;
+            }, z.core.$strip>;
+            supported: z.ZodBoolean;
+        }, z.core.$strip>;
+        effort: z.ZodObject<{
+            high: z.ZodObject<{
+                supported: z.ZodBoolean;
+            }, z.core.$strip>;
+            low: z.ZodObject<{
+                supported: z.ZodBoolean;
+            }, z.core.$strip>;
+            max: z.ZodObject<{
+                supported: z.ZodBoolean;
+            }, z.core.$strip>;
+            medium: z.ZodObject<{
+                supported: z.ZodBoolean;
+            }, z.core.$strip>;
+            supported: z.ZodBoolean;
+            xhigh: z.ZodOptional<z.ZodObject<{
+                supported: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        image_input: z.ZodObject<{
+            supported: z.ZodBoolean;
+        }, z.core.$strip>;
+        pdf_input: z.ZodObject<{
+            supported: z.ZodBoolean;
+        }, z.core.$strip>;
+        structured_outputs: z.ZodObject<{
+            supported: z.ZodBoolean;
+        }, z.core.$strip>;
+        thinking: z.ZodObject<{
+            supported: z.ZodBoolean;
+            types: z.ZodObject<{
+                adaptive: z.ZodObject<{
+                    supported: z.ZodBoolean;
+                }, z.core.$strip>;
+                enabled: z.ZodObject<{
+                    supported: z.ZodBoolean;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    created_at: z.ZodString;
+    display_name: z.ZodString;
+    max_input_tokens: z.ZodNumber;
+    max_tokens: z.ZodNumber;
+    type: z.ZodString;
+}, z.core.$strip>;
+export declare function getModelTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    model_id: string;
+}, {
+    id: string;
+    capabilities: {
+        batch: {
+            supported: boolean;
+        };
+        citations: {
+            supported: boolean;
+        };
+        code_execution: {
+            supported: boolean;
+        };
+        context_management: {
+            clear_thinking_20251015: {
+                supported: boolean;
+            };
+            clear_tool_uses_20250919: {
+                supported: boolean;
+            };
+            compact_20260112: {
+                supported: boolean;
+            };
+            supported: boolean;
+        };
+        effort: {
+            high: {
+                supported: boolean;
+            };
+            low: {
+                supported: boolean;
+            };
+            max: {
+                supported: boolean;
+            };
+            medium: {
+                supported: boolean;
+            };
+            supported: boolean;
+            xhigh?: {
+                supported: boolean;
+            } | undefined;
+        };
+        image_input: {
+            supported: boolean;
+        };
+        pdf_input: {
+            supported: boolean;
+        };
+        structured_outputs: {
+            supported: boolean;
+        };
+        thinking: {
+            supported: boolean;
+            types: {
+                adaptive: {
+                    supported: boolean;
+                };
+                enabled: {
+                    supported: boolean;
+                };
+            };
+        };
+    };
+    created_at: string;
+    display_name: string;
+    max_input_tokens: number;
+    max_tokens: number;
+    type: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "anthropic_get_model", unknown>;
+//# sourceMappingURL=get-model.d.ts.map

package/dist/providers/anthropic/tools/get-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-model.d.ts","sourceRoot":"","sources":["../../../../src/providers/anthropic/tools/get-model.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAsDxE,eAAO,MAAM,mBAAmB;;iBAE9B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAc,CAAC;AAEhD,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mIA0BhD"}

package/dist/providers/anthropic/tools/list-files.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import type { PlatformProxy } from '../../../runtime/platform-proxy.js';
+export declare const listFilesInputSchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    scope_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const listFilesOutputSchema: z.ZodObject<{
+    files: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        created_at: z.ZodString;
+        filename: z.ZodString;
+        mime_type: z.ZodString;
+        size_bytes: z.ZodNumber;
+        type: z.ZodString;
+        downloadable: z.ZodOptional<z.ZodBoolean>;
+        scope: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    next_cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function listFilesTool(proxy: PlatformProxy): import("@mastra/core/tools").Tool<{
+    cursor?: string | undefined;
+    limit?: number | undefined;
+    scope_id?: string | undefined;
+}, {
+    files: {
+        id: string;
+        created_at: string;
+        filename: string;
+        mime_type: string;
+        size_bytes: number;
+        type: string;
+        downloadable?: boolean | undefined;
+        scope?: {
+            id: string;
+            type: string;
+        } | null | undefined;
+    }[];
+    next_cursor?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "anthropic_list_files", unknown>;
+//# sourceMappingURL=list-files.d.ts.map

package/dist/providers/anthropic/tools/list-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-files.d.ts","sourceRoot":"","sources":["../../../../src/providers/anthropic/tools/list-files.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,oCAAoC,CAAC;AAE9F,eAAO,MAAM,oBAAoB;;;;iBAa/B,CAAC;AAkBH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;iBAGhC,CAAC;AASH,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa;;;;;;;;;;;;;;;;;;;oIAkDjD"}