import { ReadableStream } from 'node:stream/web';
import type { ReadableStreamDefaultController } from 'node:stream/web';
import type { AgentExecutionOptionsBase, MastraLanguageModel, PublicStructuredOutputOptions } from '@mastra/core/agent';
import type { MessageListInput } from '@mastra/core/agent/message-list';
import type { Mastra } from '@mastra/core/mastra';
import type { CostContext } from '@mastra/core/observability';
import type { RequestContext } from '@mastra/core/request-context';
import type { ChunkType, FullOutput, LanguageModelUsage, ProviderMetadata } from '@mastra/core/stream';
import { MastraModelOutput } from '@mastra/core/stream';
type MastraModelOutputOptions<OUTPUT = undefined> = ConstructorParameters<typeof MastraModelOutput<OUTPUT>>[0]['options'];
export type SDKAgentRunOptions<OUTPUT = unknown> = AgentExecutionOptionsBase<OUTPUT> & {
    signal?: AbortSignal;
    structuredOutput?: OUTPUT extends {} ? PublicStructuredOutputOptions<OUTPUT> : never;
    [key: string]: unknown;
};
export type V3Usage = {
    inputTokens: {
        total: number | undefined;
        noCache?: number;
        cacheRead?: number;
        cacheWrite?: number;
    };
    outputTokens: {
        total: number | undefined;
        text?: number;
        reasoning?: number;
    };
};
export type SDKModelGenerateResult = {
    content: Array<{
        type: 'text';
        text: string;
    }>;
    finishReason: {
        unified: 'stop';
        raw: 'stop';
    };
    usage: V3Usage;
    response: {
        id?: string;
        modelId: string;
        timestamp: Date;
    };
    providerMetadata?: ProviderMetadata;
    costContext?: CostContext;
    object?: unknown;
};
export declare function createNoopModel({ modelId, provider }: {
    modelId: string;
    provider: string;
}): MastraLanguageModel;
export declare function createCompletedMastraStream({ runId, prompt, text, responseId, modelId, usage, providerMetadata, costContext, object, }: {
    runId: string;
    prompt: string;
    text: string;
    responseId?: string;
    modelId: string;
    usage: LanguageModelUsage;
    providerMetadata?: ProviderMetadata;
    costContext?: CostContext;
    object?: unknown;
}): ReadableStream<ChunkType>;
export declare function createMastraOutput<OUTPUT>({ messages, runId, modelId, provider, stream, options, }: {
    messages: MessageListInput;
    runId: string;
    modelId: string;
    provider: string;
    stream: ReadableStream<ChunkType>;
    options?: Partial<MastraModelOutputOptions<OUTPUT>>;
}): MastraModelOutput<OUTPUT>;
export declare function toFullOutput<OUTPUT>({ messages, runId, provider, result, options, }: {
    messages: MessageListInput;
    runId: string;
    provider: string;
    result: SDKModelGenerateResult;
    options?: Partial<MastraModelOutputOptions<OUTPUT>>;
}): Promise<FullOutput<OUTPUT>>;
export type SDKAgentTelemetryOptions<OUTPUT = unknown> = {
    agentId: string;
    agentName: string;
    provider: string;
    modelId: string;
    messages: MessageListInput;
    prompt: string;
    runId: string;
    streaming: boolean;
    method: 'generate' | 'stream';
    requestContext: RequestContext;
    instructions?: string;
    maxSteps?: SDKAgentRunOptions<OUTPUT>['maxSteps'];
    tracingOptions?: SDKAgentRunOptions<OUTPUT>['tracingOptions'];
    tracingContext?: SDKAgentRunOptions<OUTPUT>['tracingContext'];
    onFinish?: SDKAgentRunOptions<OUTPUT>['onFinish'];
    onStepFinish?: SDKAgentRunOptions<OUTPUT>['onStepFinish'];
    mastra?: Mastra;
};
export type SDKAgentTelemetry<OUTPUT = unknown> = {
    execute<T>(fn: () => Promise<T>): Promise<T>;
    endGenerate(result: SDKModelGenerateResult): void;
    fail(error: unknown): void;
    startToolCall(input: SDKAgentToolCallInput): void;
    endToolCall(output: SDKAgentToolCallOutput): void;
    wrapStream(stream: ReadableStream<ChunkType>): ReadableStream<ChunkType>;
    outputOptions(): Partial<MastraModelOutputOptions<OUTPUT>>;
};
export type SDKAgentToolCallInput = {
    toolCallId: string;
    toolName: string;
    input?: unknown;
};
export type SDKAgentToolCallOutput = {
    toolCallId: string;
    output?: unknown;
    isError?: boolean;
};
export declare function createSDKAgentTelemetry<OUTPUT>({ agentId, agentName, provider, modelId, messages, prompt, runId, streaming, method, requestContext, instructions, maxSteps, tracingOptions, tracingContext, onFinish, onStepFinish, mastra, }: SDKAgentTelemetryOptions<OUTPUT>): SDKAgentTelemetry<OUTPUT>;
export declare function enqueueStartChunks(controller: ReadableStreamDefaultController<ChunkType>, { runId, prompt, textId, responseId, modelId, providerMetadata, }: {
    runId: string;
    prompt: string;
    textId: string;
    responseId?: string;
    modelId: string;
    providerMetadata?: ProviderMetadata;
}): void;
export declare function enqueueTextDelta(controller: ReadableStreamDefaultController<ChunkType>, runId: string, textId: string, text: string): void;
export declare function enqueueFinishChunks(controller: ReadableStreamDefaultController<ChunkType>, { runId, prompt, textId, text, responseId, modelId, usage, providerMetadata, costContext, object, }: {
    runId: string;
    prompt: string;
    textId: string;
    text: string;
    responseId?: string;
    modelId: string;
    usage: LanguageModelUsage;
    providerMetadata?: ProviderMetadata;
    costContext?: CostContext;
    object?: unknown;
}): void;
export declare function toLanguageModelUsage(usage: V3Usage): LanguageModelUsage;
export declare function createProviderMetadata(provider: string, metadata: Record<string, unknown>): ProviderMetadata;
export declare function promptToText(prompt: unknown): string;
export declare function withStructuredOutputPrompt<OUTPUT>(prompt: string, structuredOutput?: PublicStructuredOutputOptions<OUTPUT>): string;
export declare function getStructuredOutputSchema<OUTPUT>(structuredOutput?: PublicStructuredOutputOptions<OUTPUT>): Record<string, unknown> | undefined;
export declare function getStructuredOutput<OUTPUT>(text: string, structuredOutput?: PublicStructuredOutputOptions<OUTPUT>): Promise<OUTPUT | undefined>;
export declare function getStructuredOutputFromValue<OUTPUT>(value: unknown, structuredOutput?: PublicStructuredOutputOptions<OUTPUT>): Promise<OUTPUT | undefined>;
export declare function sumDefined(...values: Array<number | undefined>): number | undefined;
export {};
//# sourceMappingURL=utils.d.ts.map