genkit

import * as _genkit_ai_ai from '@genkit-ai/ai'; import { GenkitPluginV2, GenerateMiddleware, GenkitAI, ModelArgument, ToolConfig, ToolAction, GenerateRequest, GenerateResponseData, ExecutablePrompt, PromptConfig, RetrieverInfo, RetrieverAction, Document, EmbedderInfo, BaseDataPointSchema } from '@genkit-ai/ai'; import { MultipartToolFn, MultipartToolAction, ToolFn } from '@genkit-ai/ai/tool'; import { ActionMetadata, ResolvableAction, ActionContext, Action, z, FlowConfig, FlowFn, DapConfig, DapFn, DynamicActionProviderAction, JSONSchema, ActionFnArg, StreamingCallback } from '@genkit-ai/core'; import { EmbedderFn, EmbedderAction } from '@genkit-ai/ai/embedder'; import { BaseEvalDataPointSchema, EvaluatorFn, EvaluatorAction, EvaluatorParams, EvalResponses } from '@genkit-ai/ai/evaluator'; import { ModelAction, DefineModelOptions, GenerateResponseChunkData, DefineBackgroundModelOptions, BackgroundModelAction } from '@genkit-ai/ai/model'; import { RerankerInfo, RerankerFn, RerankerParams, RankedDocument } from '@genkit-ai/ai/reranker'; import { RetrieverFn, SimpleRetrieverOptions, IndexerFn, IndexerAction, IndexerParams, RetrieverParams } from '@genkit-ai/ai/retriever'; import { ActionType, HasRegistry } from '@genkit-ai/core/registry'; /** * @license * * Copyright 2024 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * Plugin authoring utilities — factory functions (`model`, `embedder`, * `retriever`, etc.), plugin lifecycle types, and the v1/v2 plugin * interfaces for building Genkit plugins. * * ```ts * import { model, embedder, genkitPlugin } from 'genkit/plugin'; * ``` * * @module plugin */ /** A v1 plugin provider returned by a {@link GenkitPlugin} factory function. */ interface PluginProvider { name: string; initializer: () => void | Promise<void>; resolver?: (action: ActionType, target: string) => Promise<void>; listActions?: () => Promise<ActionMetadata[]>; } /** A v1 Genkit plugin factory function. Returns a {@link PluginProvider} when called with a Genkit instance. */ type GenkitPlugin = (genkit: Genkit) => PluginProvider; /** Initialization function called during plugin setup. */ type PluginInit = (genkit: Genkit) => void | Promise<void>; /** Optional resolver function for lazily-resolved plugin actions. */ type PluginActionResolver = (genkit: Genkit, action: ActionType, target: string) => Promise<void>; /** * Defines a Genkit plugin. */ declare function genkitPlugin<T extends PluginInit>(pluginName: string, initFn: T, resolveFn?: PluginActionResolver, listActionsFn?: () => Promise<ActionMetadata[]>): GenkitPlugin; /** * Concrete implementation of a v2 plugin that wraps a {@link GenkitPluginV2} definition * and provides default implementations for all optional hooks. */ declare class GenkitPluginV2Instance implements Required<GenkitPluginV2> { readonly version = "v2"; readonly name: string; private plugin; constructor(plugin: Omit<GenkitPluginV2, 'version' | 'model'>); init(): ResolvableAction[] | Promise<ResolvableAction[]>; list(): ActionMetadata[] | Promise<ActionMetadata[]>; middleware(): GenerateMiddleware<any, any>[]; resolve(actionType: ActionType, name: string): ResolvableAction | undefined | Promise<ResolvableAction | undefined>; model(name: string): Promise<ModelAction>; } /** * Creates a new v2 plugin instance from the provided options. */ declare function genkitPluginV2(options: Omit<GenkitPluginV2, 'version' | 'model'>): GenkitPluginV2Instance; /** Checks whether the given plugin conforms to the v2 plugin interface. */ declare function isPluginV2(plugin: unknown): plugin is GenkitPluginV2; /** * @deprecated use `ai.definePrompt({messages: fn})` */ type PromptFn = (input: z.infer) => Promise<GenerateRequest<CustomOptionsSchema>>; /** * Options for initializing Genkit. */ interface GenkitOptions { /** List of plugins to load. */ plugins?: (GenkitPlugin | GenkitPluginV2)[]; /** Directory where dotprompts are stored. Set to `null` to disable automatic prompt loading. */ promptDir?: string | null; /** Default model to use if no model is specified. */ model?: ModelArgument<any>; /** Additional runtime context data for flows and tools. */ context?: ActionContext; /** Display name that will be shown in developer tooling. */ name?: string; /** Additional attribution information to include in the x-goog-api-client header. */ clientHeader?: string; } /** * `Genkit` encapsulates a single Genkit instance including the {@link Registry}, {@link ReflectionServer}, {@link FlowServer}, and configuration. * * Do not instantiate this class directly. Use {@link genkit}. * * Registry keeps track of actions, flows, tools, and many other components. Reflection server exposes an API to inspect the registry and trigger executions of actions in the registry. Flow server exposes flows as HTTP endpoints for production use. * * There may be multiple Genkit instances in a single codebase. */ declare class Genkit extends GenkitAI implements HasRegistry { /** Developer-configured options. */ readonly options: GenkitOptions; /** Reflection server for this registry. May be null if not started. */ private reflectionServer; /** List of flows that have been registered in this instance. */ readonly flows: Action<any, any, any>[]; get apiStability(): "stable" | "beta"; constructor(options?: GenkitOptions); /** * Defines and registers a flow function. */ defineFlow(config: FlowConfig<I, O, S, Init> | string, fn: FlowFn<I, O, S>): Action<I, O, S, any, Init>; /** * Defines and registers a tool that can return multiple parts of content. * * Tools can be passed to models by name or value during `generate` calls to be called automatically based on the prompt and situation. */ defineTool(config: { multipart: true; } & ToolConfig<I, O>, fn: MultipartToolFn<I, O>): MultipartToolAction<I, O>; /** * Defines and registers a tool. * * Tools can be passed to models by name or value during `generate` calls to be called automatically based on the prompt and situation. */ defineTool(config: ToolConfig<I, O>, fn: ToolFn<I, O>): ToolAction<I, O>; /** * Defines a dynamic tool. Dynamic tools are just like regular tools ({@link Genkit.defineTool}) but will not be registered in the * Genkit registry and can be defined dynamically at runtime. */ dynamicTool(config: ToolConfig<I, O>, fn?: ToolFn<I, O>): ToolAction<I, O>; /** * Defines and registers a dynamic action provider (e.g. mcp host) */ defineDynamicActionProvider(config: DapConfig | string, fn: DapFn): DynamicActionProviderAction; /** * Defines and registers a schema from a Zod schema. * * Defined schemas can be referenced by `name` in prompts in place of inline schemas. */ defineSchema<T extends z.ZodTypeAny>(name: string, schema: T): T; /** * Defines and registers a schema from a JSON schema. * * Defined schemas can be referenced by `name` in prompts in place of inline schemas. */ defineJsonSchema(name: string, jsonSchema: JSONSchema): any; /** * Defines a new model and adds it to the registry. */ defineModel<CustomOptionsSchema extends z.ZodTypeAny = z.ZodTypeAny>(options: { apiVersion: 'v2'; } & DefineModelOptions<CustomOptionsSchema>, runner: (request: GenerateRequest<CustomOptionsSchema>, options: ActionFnArg<GenerateResponseChunkData>) => Promise<GenerateResponseData>): ModelAction<CustomOptionsSchema>; /** * Defines a new model and adds it to the registry. */ defineModel<CustomOptionsSchema extends z.ZodTypeAny = z.ZodTypeAny>(options: DefineModelOptions<CustomOptionsSchema>, runner: (request: GenerateRequest<CustomOptionsSchema>, streamingCallback?: StreamingCallback<GenerateResponseChunkData>) => Promise<GenerateResponseData>): ModelAction<CustomOptionsSchema>; /** * Defines a new background model and adds it to the registry. */ defineBackgroundModel<CustomOptionsSchema extends z.ZodTypeAny = z.ZodTypeAny>(options: DefineBackgroundModelOptions<CustomOptionsSchema>): BackgroundModelAction<CustomOptionsSchema>; /** * Looks up a prompt by `name` (and optionally `variant`). Can be used to lookup * .prompt files or prompts previously defined with {@link Genkit.definePrompt} */ prompt(name: string, options?: { variant?: string; }): ExecutablePrompt<z.infer, O, CustomOptions>; private wrapExecutablePromptPromise; /** * Defines and registers a prompt based on a function. * * This is an alternative to defining and importing a .prompt file, providing * the most advanced control over how the final request to the model is made. * * @param options - Prompt metadata including model, model params, * input/output schemas, etc * @param fn - A function that returns a {@link GenerateRequest}. Any config * parameters specified by the {@link GenerateRequest} will take precedence * over any parameters specified by `options`. * * ```ts * const hi = ai.definePrompt( * { * name: 'hi', * input: { * schema: z.object({ * name: z.string(), * }), * }, * config: { * temperature: 1, * }, * }, * async (input) => { * return { * messages: [ { role: 'user', content: [{ text: `hi ${input.name}` }] } ], * }; * } * ); * const { text } = await hi({ name: 'Genkit' }); * ``` */ definePrompt(options: PromptConfig<I, O, CustomOptions>, /** @deprecated use `options.messages` with a template string instead. */ templateOrFn?: string | PromptFn): ExecutablePrompt<z.infer, O, CustomOptions>; /** * Creates a retriever action for the provided {@link RetrieverFn} implementation. */ defineRetriever<OptionsType extends z.ZodTypeAny = z.ZodTypeAny>(options: { name: string; configSchema?: OptionsType; info?: RetrieverInfo; }, runner: RetrieverFn<OptionsType>): RetrieverAction<OptionsType>; /** * defineSimpleRetriever makes it easy to map existing data into documents that * can be used for prompt augmentation. * * @param options Configuration options for the retriever. * @param handler A function that queries a datastore and returns items from which to extract documents. * @returns A Genkit retriever. */ defineSimpleRetriever<C extends z.ZodTypeAny = z.ZodTypeAny, R = any>(options: SimpleRetrieverOptions<C, R>, handler: (query: Document, config: z.infer<C>) => Promise<R[]>): RetrieverAction<C>; /** * Creates an indexer action for the provided {@link IndexerFn} implementation. */ defineIndexer<IndexerOptions extends z.ZodTypeAny>(options: { name: string; embedderInfo?: EmbedderInfo; configSchema?: IndexerOptions; }, runner: IndexerFn<IndexerOptions>): IndexerAction<IndexerOptions>; /** * Creates evaluator action for the provided {@link EvaluatorFn} implementation. */ defineEvaluator<DataPoint extends typeof BaseDataPointSchema = typeof BaseDataPointSchema, EvalDataPoint extends typeof BaseEvalDataPointSchema = typeof BaseEvalDataPointSchema, EvaluatorOptions extends z.ZodTypeAny = z.ZodTypeAny>(options: { name: string; displayName: string; definition: string; dataPointType?: DataPoint; configSchema?: EvaluatorOptions; isBilled?: boolean; }, runner: EvaluatorFn<EvalDataPoint, EvaluatorOptions>): EvaluatorAction; /** * Creates embedder model for the provided {@link EmbedderFn} model implementation. */ defineEmbedder<ConfigSchema extends z.ZodTypeAny = z.ZodTypeAny>(options: { name: string; configSchema?: ConfigSchema; info?: EmbedderInfo; }, runner: EmbedderFn<ConfigSchema>): EmbedderAction<ConfigSchema>; /** * create a handlebars helper (https://handlebarsjs.com/guide/block-helpers.html) to be used in dotprompt templates. */ defineHelper(name: string, fn: Handlebars.HelperDelegate): void; /** * Creates a handlebars partial (https://handlebarsjs.com/guide/partials.html) to be used in dotprompt templates. */ definePartial(name: string, source: string): void; /** * Creates a reranker action for the provided {@link RerankerFn} implementation. */ defineReranker<OptionsType extends z.ZodTypeAny = z.ZodTypeAny>(options: { name: string; configSchema?: OptionsType; info?: RerankerInfo; }, runner: RerankerFn<OptionsType>): _genkit_ai_ai.RerankerAction<OptionsType>; /** * Evaluates the given `dataset` using the specified `evaluator`. */ evaluate<DataPoint extends typeof BaseDataPointSchema = typeof BaseDataPointSchema, CustomOptions extends z.ZodTypeAny = z.ZodTypeAny>(params: EvaluatorParams<DataPoint, CustomOptions>): Promise<EvalResponses>; /** * Reranks documents from a {@link RerankerArgument} based on the provided query. */ rerank<CustomOptions extends z.ZodTypeAny>(params: RerankerParams<CustomOptions>): Promise<Array<RankedDocument>>; /** * Indexes `documents` using the provided `indexer`. */ index<CustomOptions extends z.ZodTypeAny>(params: IndexerParams<CustomOptions>): Promise<void>; /** * Retrieves documents from the `retriever` based on the provided `query`. */ retrieve<CustomOptions extends z.ZodTypeAny>(params: RetrieverParams<CustomOptions>): Promise<Array<Document>>; /** * Configures the Genkit instance. */ private configure; /** * Stops all servers. */ stopServers(): Promise<void>; } /** * Initializes Genkit with a set of options. * * This will create a new Genkit registry, register the provided plugins, stores, and other configuration. This * should be called before any flows are registered. */ declare function genkit(options: GenkitOptions): Genkit; declare function __disableReflectionApi(): void; export { type GenkitOptions as G, type PluginActionResolver as P, __disableReflectionApi as _, Genkit as a, type GenkitPlugin as b, GenkitPluginV2Instance as c, type PluginInit as d, type PluginProvider as e, genkitPluginV2 as f, genkitPlugin as g, type PromptFn as h, isPluginV2 as i, genkit as j };