@mastra/claude 1.0.0 → 1.0.2

package/dist/packages/claude/src/client/schemas.gen.d.ts

@@ -0,0 +1,212 @@
+export declare const ErrorSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly type: {
+            readonly type: "string";
+            readonly nullable: false;
+        };
+        readonly message: {
+            readonly type: "string";
+            readonly nullable: false;
+        };
+    };
+    readonly required: readonly ["type", "message"];
+};
+export declare const ErrorResponseSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly error: {
+            readonly $ref: "#/components/schemas/Error";
+        };
+    };
+    readonly required: readonly ["error"];
+};
+export declare const CreateCompletionRequestSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly model: {
+            readonly description: "The model that will complete your prompt.\nAs we improve Claude, we develop new versions of it that you can query.\nThis parameter controls which version of Claude answers your request.\nRight now we are offering two model families: Claude, and Claude Instant.\nYou can use them by setting model to \"claude-2\" or \"claude-instant-1\", respectively.\nSee models for additional details.\n";
+            readonly oneOf: readonly [{
+                readonly type: "string";
+            }, {
+                readonly type: "string";
+                readonly enum: readonly ["claude-2", "claude-2.0", "claude-instant-1", "claude-instant-1.1"];
+            }];
+            readonly 'x-oaiTypeLabel': "string";
+        };
+        readonly prompt: {
+            readonly description: "The prompt that you want Claude to complete.\n\nFor proper response generation you will need to format your prompt as follows:\n\n\nHuman: ${userQuestion}\n\nAssistant:\nSee our comments on prompts for more context.\n";
+            readonly default: "<|endoftext|>";
+            readonly nullable: true;
+            readonly oneOf: readonly [{
+                readonly type: "string";
+                readonly default: "";
+                readonly example: "This is a test.";
+            }, {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                    readonly default: "";
+                    readonly example: "This is a test.";
+                };
+            }, {
+                readonly type: "array";
+                readonly minItems: 1;
+                readonly items: {
+                    readonly type: "integer";
+                };
+                readonly example: "[1212, 318, 257, 1332, 13]";
+            }, {
+                readonly type: "array";
+                readonly minItems: 1;
+                readonly items: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly items: {
+                        readonly type: "integer";
+                    };
+                };
+                readonly example: "[[1212, 318, 257, 1332, 13]]";
+            }];
+        };
+        readonly max_tokens_to_sample: {
+            readonly type: "integer";
+            readonly minimum: 1;
+            readonly default: 256;
+            readonly example: 256;
+            readonly nullable: true;
+            readonly description: "The maximum number of tokens to generate before stopping.\n\nNote that our models may stop before reaching this maximum. This parameter only specifies the absolute maximum number of tokens to generate.\n";
+        };
+        readonly temperature: {
+            readonly type: "number";
+            readonly minimum: 0;
+            readonly maximum: 1;
+            readonly default: 1;
+            readonly example: 1;
+            readonly nullable: true;
+            readonly description: "Amount of randomness injected into the response.\n\nDefaults to 1. Ranges from 0 to 1. Use temp closer to 0 for analytical / multiple choice, and closer to 1 for creative and generative tasks.\n";
+        };
+        readonly top_p: {
+            readonly type: "number";
+            readonly minimum: 0;
+            readonly maximum: 1;
+            readonly default: 1;
+            readonly example: 1;
+            readonly nullable: true;
+            readonly description: "Use nucleus sampling.\n\nIn nucleus sampling, we compute the cumulative distribution over all the options \nfor each subsequent token in decreasing probability order and cut it off once \nit reaches a particular probability specified by top_p. You should either alter temperature or top_p, but not both.\n";
+        };
+        readonly top_k: {
+            readonly type: "number";
+            readonly minimum: 0;
+            readonly default: 5;
+            readonly example: 5;
+            readonly nullable: true;
+            readonly description: "Only sample from the top K options for each subsequent token.\n\nUsed to remove \"long tail\" low probability responses. Learn more technical details here.\n";
+        };
+        readonly stream: {
+            readonly description: "Whether to incrementally stream the response using server-sent events.\nSee this guide to SSE events for details.type: boolean\n";
+            readonly nullable: true;
+            readonly default: false;
+        };
+        readonly stop_sequences: {
+            readonly description: "Sequences that will cause the model to stop generating completion text.\nOur models stop on \"\n\nHuman:\", and may include additional built-in stop sequences in the future. By providing the stop_sequences parameter, you may include additional strings that will cause the model to stop generating.\n";
+            readonly default: null;
+            readonly nullable: true;
+            readonly oneOf: readonly [{
+                readonly type: "string";
+                readonly default: "<|endoftext|>";
+                readonly example: "\n";
+                readonly nullable: true;
+            }, {
+                readonly type: "array";
+                readonly minItems: 1;
+                readonly maxItems: 4;
+                readonly items: {
+                    readonly type: "string";
+                    readonly example: "[\"\\n\"]";
+                };
+            }];
+        };
+        readonly metadata: {
+            readonly type: "object";
+            readonly properties: {
+                readonly user_id: {
+                    readonly type: "string";
+                    readonly example: "13803d75-b4b5-4c3e-b2a2-6f21399b021b";
+                    readonly description: "An external identifier for the user who is associated with the request.\n\nThis should be a uuid, hash value, or other opaque identifier. Anthropic may use this id to help detect abuse. \nDo not include any identifying information such as name, email address, or phone number.\n";
+                };
+            };
+            readonly description: "An object describing metadata about the request.\n";
+        };
+    };
+    readonly required: readonly ["model", "prompt", "max_tokens_to_sample"];
+};
+export declare const CreateCompletionResponseSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly stop_reason: {
+            readonly type: "string";
+            readonly enum: readonly ["stop_sequence", "max_tokens"];
+            readonly description: "The reason that we stopped sampling.\n\nThis may be one the following values:\n\n\"stop_sequence\": we reached a stop sequence — either provided by you via the stop_sequences parameter, or a stop sequence built into the model\n\"max_tokens\": we exceeded max_tokens_to_sample or the model's maximum\n";
+        };
+        readonly model: {
+            readonly type: "string";
+            readonly description: "The model that performed the completion.\n";
+        };
+        readonly completion: {
+            readonly type: "string";
+            readonly description: "The resulting completion up to and excluding the stop sequences.\n";
+        };
+    };
+    readonly required: readonly ["completion", "stop_reason", "model"];
+};
+export declare const CreateCompletionStreamResponseSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly stop_reason: {
+            readonly type: "string";
+            readonly enum: readonly ["stop_sequence", "max_tokens"];
+            readonly description: "The reason that we stopped sampling.\n\nThis may be one the following values:\n\n\"stop_sequence\": we reached a stop sequence — either provided by you via the stop_sequences parameter, or a stop sequence built into the model\n\"max_tokens\": we exceeded max_tokens_to_sample or the model's maximum\n";
+        };
+        readonly model: {
+            readonly type: "string";
+            readonly description: "The model that performed the completion.\n";
+        };
+        readonly completion: {
+            readonly type: "string";
+            readonly description: "The resulting completion up to and excluding the stop sequences.\n";
+        };
+        readonly choices: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly delta: {
+                        readonly $ref: "#/components/schemas/CompletionStreamResponseDelta";
+                    };
+                };
+            };
+        };
+    };
+    readonly required: readonly ["completion", "stop_reason", "model"];
+};
+export declare const CompletionStreamResponseDeltaSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly completion: {
+            readonly type: "string";
+            readonly description: "The contents of the chunk message.";
+            readonly nullable: true;
+        };
+        readonly stop_reason: {
+            readonly type: "string";
+            readonly enum: readonly ["stop_sequence", "max_tokens"];
+            readonly description: "The reason that we stopped sampling.\n\nThis may be one the following values:\n\n\"stop_sequence\": we reached a stop sequence — either provided by you via the stop_sequences parameter, or a stop sequence built into the model\n\"max_tokens\": we exceeded max_tokens_to_sample or the model's maximum\n";
+            readonly nullable: true;
+        };
+        readonly model: {
+            readonly type: "string";
+            readonly description: "The model that performed the completion.\n";
+        };
+    };
+};

package/dist/packages/claude/src/client/service-comments.d.ts

@@ -0,0 +1,6 @@
+export declare const comments: {
+    complete: {
+        comment: string;
+        doc: string;
+    };
+};

package/dist/packages/claude/src/client/services.gen.d.ts

@@ -0,0 +1,9 @@
+import { type Options } from '@hey-api/client-fetch';
+import type { CompleteData } from './types.gen';
+export declare const client: import("@hey-api/client-fetch").Client<Request, Response, import("@hey-api/client-fetch").RequestOptionsBase<false> & import("@hey-api/client-fetch").Config<false> & {
+    headers: Headers;
+}>;
+/**
+ * Creates a completion for the provided prompt and parameters.
+ */
+export declare const complete: <ThrowOnError extends boolean = false>(options: Options<CompleteData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<import("./types.gen").CreateCompletionResponse, unknown, ThrowOnError>;

package/dist/packages/claude/src/client/types.gen.d.ts

@@ -0,0 +1,167 @@
+export type Error = {
+    type: string;
+    message: string;
+};
+export type ErrorResponse = {
+    error: Error;
+};
+export type CreateCompletionRequest = {
+    /**
+     * The model that will complete your prompt.
+     * As we improve Claude, we develop new versions of it that you can query.
+     * This parameter controls which version of Claude answers your request.
+     * Right now we are offering two model families: Claude, and Claude Instant.
+     * You can use them by setting model to "claude-2" or "claude-instant-1", respectively.
+     * See models for additional details.
+     *
+     */
+    model: (string | 'claude-2' | 'claude-2.0' | 'claude-instant-1' | 'claude-instant-1.1');
+    /**
+     * The prompt that you want Claude to complete.
+     *
+     * For proper response generation you will need to format your prompt as follows:
+     * \n\nHuman: ${userQuestion}\n\nAssistant:
+     * See our comments on prompts for more context.
+     *
+     */
+    prompt: ((string | Array<(string)> | Array<(number)> | Array<Array<(number)>>) | null);
+    /**
+     * The maximum number of tokens to generate before stopping.
+     *
+     * Note that our models may stop before reaching this maximum. This parameter only specifies the absolute maximum number of tokens to generate.
+     *
+     */
+    max_tokens_to_sample: (number) | null;
+    /**
+     * Amount of randomness injected into the response.
+     *
+     * Defaults to 1. Ranges from 0 to 1. Use temp closer to 0 for analytical / multiple choice, and closer to 1 for creative and generative tasks.
+     *
+     */
+    temperature?: (number) | null;
+    /**
+     * Use nucleus sampling.
+     *
+     * In nucleus sampling, we compute the cumulative distribution over all the options
+     * for each subsequent token in decreasing probability order and cut it off once
+     * it reaches a particular probability specified by top_p. You should either alter temperature or top_p, but not both.
+     *
+     */
+    top_p?: (number) | null;
+    /**
+     * Only sample from the top K options for each subsequent token.
+     *
+     * Used to remove "long tail" low probability responses. Learn more technical details here.
+     *
+     */
+    top_k?: (number) | null;
+    /**
+     * Whether to incrementally stream the response using server-sent events.
+     * See this guide to SSE events for details.type: boolean
+     *
+     */
+    stream?: unknown;
+    /**
+     * Sequences that will cause the model to stop generating completion text.
+     * Our models stop on "\n\nHuman:", and may include additional built-in stop sequences in the future. By providing the stop_sequences parameter, you may include additional strings that will cause the model to stop generating.
+     *
+     */
+    stop_sequences?: ((string) | null | Array<(string)>);
+    /**
+     * An object describing metadata about the request.
+     *
+     */
+    metadata?: {
+        /**
+         * An external identifier for the user who is associated with the request.
+         *
+         * This should be a uuid, hash value, or other opaque identifier. Anthropic may use this id to help detect abuse.
+         * Do not include any identifying information such as name, email address, or phone number.
+         *
+         */
+        user_id?: string;
+    };
+};
+export type CreateCompletionResponse = {
+    /**
+     * The reason that we stopped sampling.
+     *
+     * This may be one the following values:
+     *
+     * "stop_sequence": we reached a stop sequence — either provided by you via the stop_sequences parameter, or a stop sequence built into the model
+     * "max_tokens": we exceeded max_tokens_to_sample or the model's maximum
+     *
+     */
+    stop_reason: 'stop_sequence' | 'max_tokens';
+    /**
+     * The model that performed the completion.
+     *
+     */
+    model: string;
+    /**
+     * The resulting completion up to and excluding the stop sequences.
+     *
+     */
+    completion: string;
+};
+/**
+ * The reason that we stopped sampling.
+ *
+ * This may be one the following values:
+ *
+ * "stop_sequence": we reached a stop sequence — either provided by you via the stop_sequences parameter, or a stop sequence built into the model
+ * "max_tokens": we exceeded max_tokens_to_sample or the model's maximum
+ *
+ */
+export type stop_reason = 'stop_sequence' | 'max_tokens';
+export type CreateCompletionStreamResponse = {
+    /**
+     * The reason that we stopped sampling.
+     *
+     * This may be one the following values:
+     *
+     * "stop_sequence": we reached a stop sequence — either provided by you via the stop_sequences parameter, or a stop sequence built into the model
+     * "max_tokens": we exceeded max_tokens_to_sample or the model's maximum
+     *
+     */
+    stop_reason: 'stop_sequence' | 'max_tokens';
+    /**
+     * The model that performed the completion.
+     *
+     */
+    model: string;
+    /**
+     * The resulting completion up to and excluding the stop sequences.
+     *
+     */
+    completion: string;
+    choices?: Array<{
+        delta?: CompletionStreamResponseDelta;
+    }>;
+};
+export type CompletionStreamResponseDelta = {
+    /**
+     * The contents of the chunk message.
+     */
+    completion?: (string) | null;
+    /**
+     * The reason that we stopped sampling.
+     *
+     * This may be one the following values:
+     *
+     * "stop_sequence": we reached a stop sequence — either provided by you via the stop_sequences parameter, or a stop sequence built into the model
+     * "max_tokens": we exceeded max_tokens_to_sample or the model's maximum
+     *
+     */
+    stop_reason?: ('stop_sequence' | 'max_tokens') | null;
+    /**
+     * The model that performed the completion.
+     *
+     */
+    model?: string;
+};
+export type CompleteData = {
+    body: CreateCompletionRequest;
+};
+export type CompleteResponse = (CreateCompletionResponse);
+export type CompleteError = unknown;

package/dist/packages/claude/src/client/zodSchema.d.ts

@@ -0,0 +1,240 @@
+import { z } from 'zod';
+export declare const errorSchema: z.ZodObject<{
+    type: z.ZodString;
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    message: string;
+}, {
+    type: string;
+    message: string;
+}>;
+export declare const errorResponseSchema: z.ZodObject<{
+    error: z.ZodObject<{
+        type: z.ZodString;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        message: string;
+    }, {
+        type: string;
+        message: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    error: {
+        type: string;
+        message: string;
+    };
+}, {
+    error: {
+        type: string;
+        message: string;
+    };
+}>;
+export declare const createCompletionRequestSchema: z.ZodObject<{
+    model: z.ZodUnion<[z.ZodString, z.ZodLiteral<"claude-2">, z.ZodLiteral<"claude-2.0">, z.ZodLiteral<"claude-instant-1">, z.ZodLiteral<"claude-instant-1.1">]>;
+    prompt: z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">, z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">]>>;
+    max_tokens_to_sample: z.ZodNullable<z.ZodNumber>;
+    temperature: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    top_p: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    top_k: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    stream: z.ZodOptional<z.ZodUnknown>;
+    stop_sequences: z.ZodNullable<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        user_id: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        user_id?: string | undefined;
+    }, {
+        user_id?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    model: string;
+    prompt: string | string[] | number[] | number[][] | null;
+    max_tokens_to_sample: number | null;
+    temperature?: number | null | undefined;
+    top_p?: number | null | undefined;
+    top_k?: number | null | undefined;
+    stream?: unknown;
+    stop_sequences?: string | string[] | null | undefined;
+    metadata?: {
+        user_id?: string | undefined;
+    } | undefined;
+}, {
+    model: string;
+    prompt: string | string[] | number[] | number[][] | null;
+    max_tokens_to_sample: number | null;
+    temperature?: number | null | undefined;
+    top_p?: number | null | undefined;
+    top_k?: number | null | undefined;
+    stream?: unknown;
+    stop_sequences?: string | string[] | null | undefined;
+    metadata?: {
+        user_id?: string | undefined;
+    } | undefined;
+}>;
+export declare const createCompletionResponseSchema: z.ZodObject<{
+    stop_reason: z.ZodUnion<[z.ZodLiteral<"stop_sequence">, z.ZodLiteral<"max_tokens">]>;
+    model: z.ZodString;
+    completion: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    model: string;
+    stop_reason: "stop_sequence" | "max_tokens";
+    completion: string;
+}, {
+    model: string;
+    stop_reason: "stop_sequence" | "max_tokens";
+    completion: string;
+}>;
+export declare const stopReasonSchema: z.ZodUnion<[z.ZodLiteral<"stop_sequence">, z.ZodLiteral<"max_tokens">]>;
+export declare const completionStreamResponseDeltaSchema: z.ZodObject<{
+    completion: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    stop_reason: z.ZodNullable<z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"stop_sequence">, z.ZodLiteral<"max_tokens">]>>>;
+    model: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    model?: string | undefined;
+    stop_reason?: "stop_sequence" | "max_tokens" | null | undefined;
+    completion?: string | null | undefined;
+}, {
+    model?: string | undefined;
+    stop_reason?: "stop_sequence" | "max_tokens" | null | undefined;
+    completion?: string | null | undefined;
+}>;
+export declare const completeDataSchema: z.ZodObject<{
+    body: z.ZodObject<{
+        model: z.ZodUnion<[z.ZodString, z.ZodLiteral<"claude-2">, z.ZodLiteral<"claude-2.0">, z.ZodLiteral<"claude-instant-1">, z.ZodLiteral<"claude-instant-1.1">]>;
+        prompt: z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">, z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">]>>;
+        max_tokens_to_sample: z.ZodNullable<z.ZodNumber>;
+        temperature: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        top_p: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        top_k: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+        stream: z.ZodOptional<z.ZodUnknown>;
+        stop_sequences: z.ZodNullable<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
+        metadata: z.ZodOptional<z.ZodObject<{
+            user_id: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            user_id?: string | undefined;
+        }, {
+            user_id?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        model: string;
+        prompt: string | string[] | number[] | number[][] | null;
+        max_tokens_to_sample: number | null;
+        temperature?: number | null | undefined;
+        top_p?: number | null | undefined;
+        top_k?: number | null | undefined;
+        stream?: unknown;
+        stop_sequences?: string | string[] | null | undefined;
+        metadata?: {
+            user_id?: string | undefined;
+        } | undefined;
+    }, {
+        model: string;
+        prompt: string | string[] | number[] | number[][] | null;
+        max_tokens_to_sample: number | null;
+        temperature?: number | null | undefined;
+        top_p?: number | null | undefined;
+        top_k?: number | null | undefined;
+        stream?: unknown;
+        stop_sequences?: string | string[] | null | undefined;
+        metadata?: {
+            user_id?: string | undefined;
+        } | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    body: {
+        model: string;
+        prompt: string | string[] | number[] | number[][] | null;
+        max_tokens_to_sample: number | null;
+        temperature?: number | null | undefined;
+        top_p?: number | null | undefined;
+        top_k?: number | null | undefined;
+        stream?: unknown;
+        stop_sequences?: string | string[] | null | undefined;
+        metadata?: {
+            user_id?: string | undefined;
+        } | undefined;
+    };
+}, {
+    body: {
+        model: string;
+        prompt: string | string[] | number[] | number[][] | null;
+        max_tokens_to_sample: number | null;
+        temperature?: number | null | undefined;
+        top_p?: number | null | undefined;
+        top_k?: number | null | undefined;
+        stream?: unknown;
+        stop_sequences?: string | string[] | null | undefined;
+        metadata?: {
+            user_id?: string | undefined;
+        } | undefined;
+    };
+}>;
+export declare const completeResponseSchema: z.ZodObject<{
+    stop_reason: z.ZodUnion<[z.ZodLiteral<"stop_sequence">, z.ZodLiteral<"max_tokens">]>;
+    model: z.ZodString;
+    completion: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    model: string;
+    stop_reason: "stop_sequence" | "max_tokens";
+    completion: string;
+}, {
+    model: string;
+    stop_reason: "stop_sequence" | "max_tokens";
+    completion: string;
+}>;
+export declare const completeErrorSchema: z.ZodUnknown;
+export declare const createCompletionStreamResponseSchema: z.ZodObject<{
+    stop_reason: z.ZodUnion<[z.ZodLiteral<"stop_sequence">, z.ZodLiteral<"max_tokens">]>;
+    model: z.ZodString;
+    completion: z.ZodString;
+    choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        delta: z.ZodOptional<z.ZodObject<{
+            completion: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+            stop_reason: z.ZodNullable<z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"stop_sequence">, z.ZodLiteral<"max_tokens">]>>>;
+            model: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            model?: string | undefined;
+            stop_reason?: "stop_sequence" | "max_tokens" | null | undefined;
+            completion?: string | null | undefined;
+        }, {
+            model?: string | undefined;
+            stop_reason?: "stop_sequence" | "max_tokens" | null | undefined;
+            completion?: string | null | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        delta?: {
+            model?: string | undefined;
+            stop_reason?: "stop_sequence" | "max_tokens" | null | undefined;
+            completion?: string | null | undefined;
+        } | undefined;
+    }, {
+        delta?: {
+            model?: string | undefined;
+            stop_reason?: "stop_sequence" | "max_tokens" | null | undefined;
+            completion?: string | null | undefined;
+        } | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    model: string;
+    stop_reason: "stop_sequence" | "max_tokens";
+    completion: string;
+    choices?: {
+        delta?: {
+            model?: string | undefined;
+            stop_reason?: "stop_sequence" | "max_tokens" | null | undefined;
+            completion?: string | null | undefined;
+        } | undefined;
+    }[] | undefined;
+}, {
+    model: string;
+    stop_reason: "stop_sequence" | "max_tokens";
+    completion: string;
+    choices?: {
+        delta?: {
+            model?: string | undefined;
+            stop_reason?: "stop_sequence" | "max_tokens" | null | undefined;
+            completion?: string | null | undefined;
+        } | undefined;
+    }[] | undefined;
+}>;

package/dist/packages/claude/src/index.d.ts

@@ -0,0 +1,21 @@
+import { Integration, IntegrationAuth } from '@mastra/core';
+import * as integrationClient from './client/services.gen';
+import * as zodSchema from './client/zodSchema';
+export declare class ClaudeIntegration extends Integration {
+    categories: string[];
+    description: string;
+    constructor();
+    getClientZodSchema(): typeof zodSchema;
+    getCommentsForClientApis(): {
+        complete: {
+            comment: string;
+            doc: string;
+        };
+    };
+    getBaseClient(): typeof integrationClient;
+    getApiClient: ({ connectionId }: {
+        connectionId: string;
+    }) => Promise<typeof integrationClient>;
+    registerEvents(): Record<string, import("@mastra/core").IntegrationEvent<any>>;
+    getAuthenticator(): IntegrationAuth;
+}