@alpic80/rivet-core 1.19.1-aidon.1

package/dist/types/model/nodes/UserInputNode.d.ts

@@ -0,0 +1,21 @@
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import type { ChartNode, NodeInputDefinition, NodeOutputDefinition } from '../NodeBase.js';
+import type { ArrayDataValue, StringDataValue } from '../DataValue.js';
+import { type Outputs, type Inputs, type EditorDefinition, type NodeBodySpec } from '../../index.js';
+export type UserInputNode = ChartNode<'userInput', UserInputNodeData>;
+export type UserInputNodeData = {
+    prompt: string;
+    useInput: boolean;
+    renderingFormat?: 'preformatted' | 'markdown';
+};
+export declare class UserInputNodeImpl extends NodeImpl<UserInputNode> {
+    static create(): UserInputNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<UserInputNode>[];
+    getBody(): string | NodeBodySpec | undefined;
+    static getUIData(): NodeUIData;
+    process(): Promise<Outputs>;
+    getOutputValuesFromUserInput(questions: Inputs, answers: ArrayDataValue<StringDataValue>): Outputs;
+}
+export declare const userInputNode: import("../NodeDefinition.js").NodeDefinition<UserInputNode>;

package/dist/types/model/nodes/VectorNearestNeighborsNode.d.ts

@@ -0,0 +1,24 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+import { type InternalProcessContext } from '../ProcessContext.js';
+import { type EditorDefinition } from '../../index.js';
+export type VectorNearestNeighborsNode = ChartNode<'vectorNearestNeighbors', VectorNearestNeighborsNodeData>;
+export type VectorNearestNeighborsNodeData = {
+    integration: string;
+    useIntegrationInput?: boolean;
+    k: number;
+    useKInput?: boolean;
+    collectionId: string;
+    useCollectionIdInput?: boolean;
+};
+export declare class VectorNearestNeighborsNodeImpl extends NodeImpl<VectorNearestNeighborsNode> {
+    static create(): VectorNearestNeighborsNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<VectorNearestNeighborsNode>[];
+    getBody(): string | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const vectorNearestNeighborsNode: import("../NodeDefinition.js").NodeDefinition<VectorNearestNeighborsNode>;

package/dist/types/model/nodes/VectorStoreNode.d.ts

@@ -0,0 +1,22 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+import { type InternalProcessContext } from '../ProcessContext.js';
+import { type EditorDefinition } from '../../index.js';
+export type VectorStoreNode = ChartNode<'vectorStore', VectorStoreNodeData>;
+export type VectorStoreNodeData = {
+    integration: string;
+    useIntegrationInput?: boolean;
+    collectionId: string;
+    useCollectionIdInput?: boolean;
+};
+export declare class VectorStoreNodeImpl extends NodeImpl<VectorStoreNode> {
+    static create(): VectorStoreNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<VectorStoreNode>[];
+    getBody(): string | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const vectorStoreNode: import("../NodeDefinition.js").NodeDefinition<VectorStoreNode>;

package/dist/types/model/nodes/WaitForEventNode.d.ts

@@ -0,0 +1,21 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+import { type InternalProcessContext } from '../ProcessContext.js';
+import { type EditorDefinition } from '../EditorDefinition.js';
+import { type NodeBodySpec } from '../NodeBodySpec.js';
+export type WaitForEventNode = ChartNode<'waitForEvent', WaitForEventNodeData>;
+export type WaitForEventNodeData = {
+    eventName: string;
+    useEventNameInput: boolean;
+};
+export declare class WaitForEventNodeImpl extends NodeImpl<WaitForEventNode> {
+    static create(): WaitForEventNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<WaitForEventNode>[];
+    getBody(): string | NodeBodySpec | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const waitForEventNode: import("../NodeDefinition.js").NodeDefinition<WaitForEventNode>;

package/dist/types/native/BaseDir.d.ts

@@ -0,0 +1,29 @@
+export declare const baseDirs: {
+    readonly app: "app";
+    readonly appCache: "appCache";
+    readonly appConfig: "appConfig";
+    readonly appData: "appData";
+    readonly appLocalData: "appLocalData";
+    readonly appLog: "appLog";
+    readonly audio: "audio";
+    readonly cache: "cache";
+    readonly config: "config";
+    readonly data: "data";
+    readonly desktop: "desktop";
+    readonly document: "document";
+    readonly download: "download";
+    readonly executable: "executable";
+    readonly font: "font";
+    readonly home: "home";
+    readonly localData: "localData";
+    readonly log: "log";
+    readonly picture: "picture";
+    readonly public: "public";
+    readonly resource: "resource";
+    readonly runtime: "runtime";
+    readonly temp: "temp";
+    readonly template: "template";
+    readonly video: "video";
+};
+export type BaseDir = (typeof baseDirs)[keyof typeof baseDirs];
+export declare function assertBaseDir(baseDir: string): asserts baseDir is BaseDir;

package/dist/types/native/BrowserNativeApi.d.ts

@@ -0,0 +1,11 @@
+import { type BaseDir } from './BaseDir.js';
+import { type NativeApi } from './NativeApi.js';
+export declare class BrowserNativeApi implements NativeApi {
+    readdir(_path: string, _baseDir: BaseDir): Promise<string[]>;
+    readTextFile(_path: string, _baseDir: BaseDir): Promise<string>;
+    readBinaryFile(_path: string, _baseDir: BaseDir): Promise<Blob>;
+    writeTextFile(_path: string, _data: string, _baseDir?: BaseDir): Promise<void>;
+    exec(command: string, args: string[], options?: {
+        cwd?: string | undefined;
+    } | undefined): Promise<void>;
+}

package/dist/types/native/NativeApi.d.ts

@@ -0,0 +1,17 @@
+import { type BaseDir } from './BaseDir.js';
+export type ReadDirOptions = {
+    recursive?: boolean;
+    includeDirectories?: boolean;
+    filterGlobs?: string[];
+    relative?: boolean;
+    ignores?: string[];
+};
+export interface NativeApi {
+    readdir(path: string, baseDir?: BaseDir, options?: ReadDirOptions): Promise<string[]>;
+    readTextFile(path: string, baseDir?: BaseDir): Promise<string>;
+    readBinaryFile(path: string, baseDir?: BaseDir): Promise<Blob>;
+    writeTextFile(path: string, data: string, baseDir?: BaseDir): Promise<void>;
+    exec(command: string, args: string[], options?: {
+        cwd?: string;
+    }): Promise<void>;
+}

package/dist/types/plugins/aidon/index.d.ts

@@ -0,0 +1,2 @@
+import { aidonPlugin } from './plugin.js';
+export default aidonPlugin;

package/dist/types/plugins/aidon/nodes/ChatAidonNode.d.ts

@@ -0,0 +1,3 @@
+import { type ChartNode, type ChatNodeData } from '../../../index.js';
+export type ChatAidonNode = ChartNode<'chatAidon', ChatNodeData>;
+export declare function chatAidonNode(): import("../../../index.js").PluginNodeDefinition<ChatAidonNode>;

package/dist/types/plugins/aidon/plugin.d.ts

@@ -0,0 +1,2 @@
+import { type RivetPlugin } from '../../index.js';
+export declare const aidonPlugin: RivetPlugin;

package/dist/types/plugins/anthropic/anthropic.d.ts

@@ -0,0 +1,216 @@
+export type AnthropicModel = {
+    maxTokens: number;
+    cost: {
+        prompt: number;
+        completion: number;
+    };
+    displayName: string;
+};
+export declare const anthropicModels: {
+    'claude-instant-1': {
+        maxTokens: number;
+        cost: {
+            prompt: number;
+            completion: number;
+        };
+        displayName: string;
+    };
+    'claude-instant-1.2': {
+        maxTokens: number;
+        cost: {
+            prompt: number;
+            completion: number;
+        };
+        displayName: string;
+    };
+    'claude-2': {
+        maxTokens: number;
+        cost: {
+            prompt: number;
+            completion: number;
+        };
+        displayName: string;
+    };
+    'claude-2.1': {
+        maxTokens: number;
+        cost: {
+            prompt: number;
+            completion: number;
+        };
+        displayName: string;
+    };
+    'claude-3-haiku-20240307': {
+        maxTokens: number;
+        cost: {
+            prompt: number;
+            completion: number;
+        };
+        displayName: string;
+    };
+    'claude-3-sonnet-20240229': {
+        maxTokens: number;
+        cost: {
+            prompt: number;
+            completion: number;
+        };
+        displayName: string;
+    };
+    'claude-3-opus-20240229': {
+        maxTokens: number;
+        cost: {
+            prompt: number;
+            completion: number;
+        };
+        displayName: string;
+    };
+    'claude-3-5-sonnet-20240620': {
+        maxTokens: number;
+        cost: {
+            prompt: number;
+            completion: number;
+        };
+        displayName: string;
+    };
+};
+export type AnthropicModels = keyof typeof anthropicModels;
+export declare const anthropicModelOptions: {
+    value: string;
+    label: string;
+}[];
+export type Claude3ChatMessage = {
+    role: 'user' | 'assistant';
+    content: string | Claude3ChatMessageContentPart[];
+};
+export type Claude3ChatMessageTextContentPart = {
+    type: 'text';
+    text: string;
+};
+export type Claude3ChatMessageImageContentPart = {
+    type: 'image';
+    source: {
+        type: 'base64';
+        media_type: string;
+        data: string;
+    };
+};
+export type Claude3ChatMessageToolResultContentPart = {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string | {
+        type: 'text';
+        text: string;
+    }[];
+};
+export type Claude3ChatMessageToolUseContentPart = {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: object;
+};
+export type Claude3ChatMessageContentPart = Claude3ChatMessageTextContentPart | Claude3ChatMessageImageContentPart | Claude3ChatMessageToolResultContentPart | Claude3ChatMessageToolUseContentPart;
+export type ChatMessageOptions = {
+    apiKey: string;
+    model: AnthropicModels;
+    messages: Claude3ChatMessage[];
+    system?: string;
+    max_tokens: number;
+    stop_sequences?: string[];
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+    signal?: AbortSignal;
+    stream?: boolean;
+    tools?: {
+        name: string;
+        description: string;
+        input_schema: object;
+    }[];
+};
+export type ChatCompletionOptions = {
+    apiKey: string;
+    model: AnthropicModels;
+    prompt: string;
+    max_tokens_to_sample: number;
+    stop_sequences?: string[];
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+    signal?: AbortSignal;
+    stream?: boolean;
+};
+export type ChatCompletionChunk = {
+    completion: string;
+    stop_reason: 'stop_sequence' | null;
+    model: string;
+};
+export type ChatMessageChunk = {
+    type: 'message_start';
+    message: {
+        id: string;
+        type: string;
+        role: string;
+        content: {
+            type: 'text';
+            text: string;
+        }[];
+        model: AnthropicModels;
+        stop_reason: string | null;
+        stop_sequence: string | null;
+        usage: {
+            input_tokens: number;
+            output_tokens: number;
+        };
+    };
+} | {
+    type: 'content_block_start';
+    index: number;
+    content_block: {
+        type: 'text';
+        text: string;
+    };
+} | {
+    type: 'ping';
+} | {
+    type: 'content_block_delta';
+    index: number;
+    delta: {
+        type: 'text_delta';
+        text: string;
+    };
+} | {
+    type: 'message_delta';
+    delta: {
+        stop_reason: string | null;
+        stop_sequence: string | null;
+        usage: {
+            output_tokens: number;
+        };
+    };
+} | {
+    type: 'message_stop';
+};
+export type ChatMessageResponse = {
+    id: string;
+    content: ({
+        text: string;
+    } | {
+        id: string;
+        name: string;
+        input: object;
+    })[];
+    model: string;
+    stop_reason: 'end_turn';
+    stop_sequence: string;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+};
+export declare function streamChatCompletions({ apiKey, signal, ...rest }: ChatCompletionOptions): AsyncGenerator<ChatCompletionChunk>;
+export declare function callMessageApi({ apiKey, signal, tools, ...rest }: ChatMessageOptions): Promise<ChatMessageResponse>;
+export declare function streamMessageApi({ apiKey, signal, ...rest }: ChatMessageOptions): AsyncGenerator<ChatMessageChunk>;
+export declare class AnthropicError extends Error {
+    readonly response: Response;
+    readonly responseJson: unknown;
+    constructor(message: string, response: Response, responseJson: unknown);
+}

package/dist/types/plugins/anthropic/fetchEventSource.d.ts

@@ -0,0 +1,11 @@
+export declare class EventSourceResponse extends Response {
+    name: string;
+    readonly streams: {
+        eventStream: ReadableStream<string>;
+        textStream: ReadableStream<string>;
+    } | null;
+    constructor(body: ReadableStream<Uint8Array> | null, init?: ResponseInit);
+    events(): AsyncGenerator<string>;
+    private raceWithTimeout;
+}
+export default function fetchEventSource(url: string, init?: RequestInit): Promise<EventSourceResponse>;

package/dist/types/plugins/anthropic/index.d.ts

@@ -0,0 +1,2 @@
+import { anthropicPlugin } from './plugin.js';
+export default anthropicPlugin;

package/dist/types/plugins/anthropic/nodes/ChatAnthropicNode.d.ts

@@ -0,0 +1,30 @@
+import { type ChartNode, type ChatMessage, type Inputs, type PluginNodeImpl } from '../../../index.js';
+import { type AnthropicModels, type Claude3ChatMessage } from '../anthropic.js';
+export type ChatAnthropicNode = ChartNode<'chatAnthropic', ChatAnthropicNodeData>;
+export type ChatAnthropicNodeConfigData = {
+    model: AnthropicModels;
+    temperature: number;
+    useTopP: boolean;
+    top_p?: number;
+    top_k?: number;
+    maxTokens: number;
+    stop?: string;
+    enableToolUse?: boolean;
+};
+export type ChatAnthropicNodeData = ChatAnthropicNodeConfigData & {
+    useModelInput: boolean;
+    useTemperatureInput: boolean;
+    useTopPInput: boolean;
+    useTopKInput: boolean;
+    useUseTopPInput: boolean;
+    useMaxTokensInput: boolean;
+    useStop: boolean;
+    useStopInput: boolean;
+    /** Given the same set of inputs, return the same output without hitting GPT */
+    cache: boolean;
+    useAsGraphPartialOutput?: boolean;
+};
+export declare const ChatAnthropicNodeImpl: PluginNodeImpl<ChatAnthropicNode>;
+export declare const chatAnthropicNode: import("../../../index.js").PluginNodeDefinition<ChatAnthropicNode>;
+export declare function getSystemPrompt(inputs: Inputs): string | undefined;
+export declare function chatMessagesToClaude3ChatMessages(chatMessages: ChatMessage[]): Promise<Claude3ChatMessage[]>;

package/dist/types/plugins/anthropic/plugin.d.ts

@@ -0,0 +1,2 @@
+import { type RivetPlugin } from '../../index.js';
+export declare const anthropicPlugin: RivetPlugin;

package/dist/types/plugins/assemblyAi/LemurActionItemsNode.d.ts

@@ -0,0 +1,6 @@
+import { type ChartNode, type PluginNodeImpl } from '../../index.js';
+import { type LemurNodeData } from './lemurHelpers.js';
+export type LemurActionItemsNode = ChartNode<'assemblyAiLemurActionItems', LemurActionItemsNodeData>;
+export type LemurActionItemsNodeData = LemurNodeData;
+export declare const LemurActionItemsNodeImpl: PluginNodeImpl<LemurActionItemsNode>;
+export declare const lemurActionItemsNode: import("../../index.js").PluginNodeDefinition<LemurActionItemsNode>;

package/dist/types/plugins/assemblyAi/LemurQaNode.d.ts

@@ -0,0 +1,22 @@
+import { type ChartNode, type EditorDefinition, type Inputs, type InternalProcessContext, type NodeInputDefinition, type NodeOutputDefinition, type NodeUIData, type Outputs } from '../../index.js';
+import { type LemurNodeData } from './lemurHelpers.js';
+export type LemurQaNode = ChartNode<'assemblyAiLemurQa', LemurQaNodeData>;
+export type LemurQaNodeData = LemurNodeData & {
+    questions_answer_format?: string;
+    questions_context?: string;
+    questions_answer_options?: string;
+};
+export declare const LemurQaNodeImpl: {
+    create(): LemurQaNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<LemurQaNode>[];
+    getBody(): string | undefined;
+    getUIData(): NodeUIData;
+    process(data: LemurNodeData & {
+        questions_answer_format?: string;
+        questions_context?: string;
+        questions_answer_options?: string;
+    }, inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+};
+export declare const lemurQaNode: import("../../index.js").PluginNodeDefinition<LemurQaNode>;

package/dist/types/plugins/assemblyAi/LemurSummaryNode.d.ts

@@ -0,0 +1,8 @@
+import { type ChartNode, type PluginNodeImpl } from '../../index.js';
+import { type LemurNodeData } from './lemurHelpers.js';
+export type LemurSummaryNode = ChartNode<'assemblyAiLemurSummary', LemurSummaryNodeData>;
+export type LemurSummaryNodeData = LemurNodeData & {
+    answer_format?: string;
+};
+export declare const LemurSummaryNodeImpl: PluginNodeImpl<LemurSummaryNode>;
+export declare const lemurSummaryNode: import("../../index.js").PluginNodeDefinition<LemurSummaryNode>;

package/dist/types/plugins/assemblyAi/LemurTaskNode.d.ts

@@ -0,0 +1,8 @@
+import { type ChartNode, type PluginNodeImpl } from '../../index.js';
+import { type LemurNodeData } from './lemurHelpers.js';
+export type LemurTaskNode = ChartNode<'assemblyAiLemurTask', LemurTaskNodeData>;
+export type LemurTaskNodeData = LemurNodeData & {
+    prompt?: string;
+};
+export declare const LemurTaskNodeImpl: PluginNodeImpl<LemurTaskNode>;
+export declare const lemurTaskNode: import("../../index.js").PluginNodeDefinition<LemurTaskNode>;

package/dist/types/plugins/assemblyAi/TranscribeAudioNode.d.ts

@@ -0,0 +1,7 @@
+import { type ChartNode, type PluginNodeImpl } from '../../index.js';
+export type TranscribeAudioNode = ChartNode<'assemblyAiTranscribeAudio', TranscribeAudioNodeData>;
+export type TranscribeAudioNodeData = {
+    transcriptParameters?: string;
+};
+export declare const TranscribeAudioNodeImpl: PluginNodeImpl<TranscribeAudioNode>;
+export declare const transcribeAudioNode: import("../../index.js").PluginNodeDefinition<TranscribeAudioNode>;

package/dist/types/plugins/assemblyAi/index.d.ts

@@ -0,0 +1,2 @@
+import { assemblyAiPlugin } from './plugin.js';
+export default assemblyAiPlugin;

package/dist/types/plugins/assemblyAi/lemurHelpers.d.ts

@@ -0,0 +1,67 @@
+import { AssemblyAI } from 'assemblyai';
+import type { LemurBaseParams } from 'assemblyai';
+import { type Inputs, type InternalProcessContext, type PortId } from '../../index.js';
+export declare function getClient(context: InternalProcessContext): AssemblyAI;
+export declare function getLemurParams(inputs: Inputs, editorData: LemurNodeData): LemurBaseParams;
+export declare const lemurInputDefinitions: readonly [{
+    readonly id: PortId;
+    readonly dataType: readonly ["string", "string[]", "any", "any[]"];
+    readonly title: "Transcript IDs";
+}, {
+    readonly id: PortId;
+    readonly dataType: readonly ["string"];
+    readonly title: "Input Text";
+}];
+export declare const lemurEditorDefinitions: readonly [{
+    readonly type: "dropdown";
+    readonly label: "Final Model";
+    readonly dataKey: "final_model";
+    readonly options: readonly [{
+        readonly value: "anthropic/claude-3-5-sonnet";
+        readonly label: "Claude 3.5 Sonnet (on Anthropic)";
+    }, {
+        readonly value: "anthropic/claude-3-opus";
+        readonly label: "Claude 3 Opus (on Anthropic)";
+    }, {
+        readonly value: "anthropic/claude-3-haiku";
+        readonly label: "Claude 3 Haiku (on Anthropic)";
+    }, {
+        readonly value: "anthropic/claude-3-sonnet";
+        readonly label: "Claude 3 Sonnet (on Anthropic)";
+    }, {
+        readonly value: "anthropic/claude-2-1";
+        readonly label: "Claude 2.1 (on Anthropic)";
+    }, {
+        readonly value: "anthropic/claude-2";
+        readonly label: "Claude 2.1 (on Anthropic)";
+    }, {
+        readonly value: "default";
+        readonly label: "Default";
+    }, {
+        readonly value: "anthropic/claude-instant-1-2";
+        readonly label: "Claude Instant 1.2 (on Anthropic)";
+    }, {
+        readonly value: "basic";
+        readonly label: "Basic";
+    }, {
+        readonly value: "assemblyai/mistral-7b";
+        readonly label: "Mistral 7B (hosted by AssemblyAI)";
+    }];
+}, {
+    readonly type: "number";
+    readonly label: "Maximum Output Size";
+    readonly dataKey: "max_output_size";
+}, {
+    readonly type: "number";
+    readonly label: "Temperature";
+    readonly dataKey: "temperature";
+    readonly min: 0;
+    readonly max: 1;
+}];
+export type FinalModel = 'anthropic/claude-3-5-sonnet' | 'anthropic/claude-3-opus' | 'anthropic/claude-3-haiku' | 'anthropic/claude-3-sonnet' | 'anthropic/claude-2-1' | 'anthropic/claude-2' | 'default' | 'anthropic/claude-instant-1-2' | 'basic' | 'assemblyai/mistral-7b';
+export type LemurNodeData = {
+    context?: string;
+    final_model?: FinalModel;
+    max_output_size?: number;
+    temperature?: number;
+};

package/dist/types/plugins/assemblyAi/plugin.d.ts

@@ -0,0 +1,2 @@
+import { type RivetPlugin } from '../../index.js';
+export declare const assemblyAiPlugin: RivetPlugin;

package/dist/types/plugins/autoevals/AutoEvalsNode.d.ts

@@ -0,0 +1,8 @@
+import { type templates } from 'autoevals';
+import type { ChartNode, PluginNodeImpl } from '../../index.js';
+export type AutoEvalsNode = ChartNode<'autoevals', AutoEvalsNodeData>;
+export type AutoEvalsNodeData = {
+    evaluatorName?: keyof typeof templates;
+};
+export declare const AutoEvalsNodeImpl: PluginNodeImpl<AutoEvalsNode>;
+export declare const autoEvalsNode: import("../../index.js").PluginNodeDefinition<AutoEvalsNode>;

package/dist/types/plugins/autoevals/index.d.ts

@@ -0,0 +1,2 @@
+import { autoevalsPlugin } from './plugin.js';
+export default autoevalsPlugin;

package/dist/types/plugins/autoevals/plugin.d.ts

@@ -0,0 +1,2 @@
+import type { RivetPlugin } from '../../index.js';
+export declare const autoevalsPlugin: RivetPlugin;

package/dist/types/plugins/gentrace/index.d.ts

@@ -0,0 +1,2 @@
+import { gentracePlugin } from './plugin.js';
+export default gentracePlugin;

package/dist/types/plugins/gentrace/plugin.d.ts

@@ -0,0 +1,5 @@
+import { type NativeApi, type NodeGraph, type Project, type Recording, type RivetPlugin, type Settings } from '../../index.js';
+export declare const runGentraceTests: (gentracePipelineSlug: string, settings: Settings, project: Omit<Project, "data">, graph: NodeGraph, nativeApi: NativeApi) => Promise<import("@gentrace/core").TestResultPost200Response>;
+export declare const runRemoteGentraceTests: (gentracePipelineSlug: string, settings: Settings, project: Omit<Project, "data">, graph: NodeGraph, runAndRecord: (testCase: Record<string, any>) => Promise<Recording>) => Promise<import("@gentrace/core").TestResultPost200Response>;
+export declare const getGentracePipelines: (gentraceApiKey: string) => Promise<import("@gentrace/core/dist/models/v1-pipelines-get200-response-pipelines-inner.js").V1PipelinesGet200ResponsePipelinesInner[]>;
+export declare const gentracePlugin: RivetPlugin;

package/dist/types/plugins/google/google.d.ts

@@ -0,0 +1,60 @@
+export type GoogleModel = {
+    maxTokens: number;
+    cost: {
+        prompt: number;
+        completion: number;
+    };
+    displayName: string;
+};
+export declare const googleModels: {
+    'gemini-pro': {
+        maxTokens: number;
+        cost: {
+            prompt: number;
+            completion: number;
+        };
+        displayName: string;
+    };
+    'gemini-pro-vision': {
+        maxTokens: number;
+        cost: {
+            prompt: number;
+            completion: number;
+        };
+        displayName: string;
+    };
+};
+export type GoogleModels = keyof typeof googleModels;
+export declare const googleModelOptions: {
+    value: string;
+    label: string;
+}[];
+export interface GoogleChatMessage {
+    role: 'user' | 'assistant';
+    parts: ({
+        text: string;
+    } | {
+        inline_data: {
+            mime_type: string;
+            data: string;
+        };
+    })[];
+}
+export type ChatCompletionOptions = {
+    project: string;
+    location: string;
+    applicationCredentials: string;
+    model: GoogleModels;
+    prompt: GoogleChatMessage[];
+    max_output_tokens: number;
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+    signal?: AbortSignal;
+};
+export type ChatCompletionChunk = {
+    completion: string;
+    finish_reason: 'FINISH_REASON_UNSPECIFIED' | 'FINISH_REASON_STOP' | 'FINISH_REASON_MAX_TOKENS' | 'FINISH_REASON_SAFETY' | 'FINISH_REASON_RECITATION' | 'FINISH_REASON_OTHER' | undefined;
+    model: string;
+};
+export declare function streamChatCompletions({ project, location, applicationCredentials, model, signal, max_output_tokens, temperature, top_p, top_k, prompt, }: ChatCompletionOptions): AsyncGenerator<ChatCompletionChunk>;