genkit/lib/genkit-beta.mjs

Genkit AI framework

import {
  SessionRunner,
  defineAgent,
  defineCustomAgent,
  defineInterrupt,
  definePromptAgent,
  defineResource,
  generateOperation
} from "@genkit-ai/ai";
import { defineFormat } from "@genkit-ai/ai/formats";
import {
  FileSessionStore,
  InMemorySessionStore
} from "@genkit-ai/ai/session-stores";
import { applyPatch, diff } from "@genkit-ai/ai/json-patch";
import { Genkit } from "./genkit.mjs";
function genkit(options) {
  return new GenkitBeta(options);
}
class GenkitBeta extends Genkit {
  constructor(options) {
    super(options);
    this.registry.apiStability = "beta";
  }
  /**
   * Defines and registers a custom agent with a custom handler function.
   *
   * @beta
   */
  defineCustomAgent(config, fn) {
    return defineCustomAgent(this.registry, config, fn);
  }
  /**
   * Defines and registers an agent from an existing Prompt template.
   *
   * @beta
   */
  definePromptAgent(config) {
    return definePromptAgent(this.registry, config);
  }
  /**
   * Defines and registers an agent by creating a prompt and wiring it into a
   * multi-turn agent in one step.
   *
   * This is a convenience shortcut that combines `definePrompt` and
   * `definePromptAgent` into a single call.
   *
   * ```ts
   * const myAgent = ai.defineAgent({
   *   name: 'myAgent',
   *   model: 'googleai/gemini-2.5-flash',
   *   system: 'Talk like a pirate.',
   *   tools: [weatherTool],
   *   store: new FileSessionStore('./.snapshots'),
   * });
   * ```
   *
   * @beta
   */
  defineAgent(config) {
    return defineAgent(this.registry, config);
  }
  /**
   * Defines and registers a custom model output formatter.
   *
   * Here's an example of a custom JSON output formatter:
   *
   * ```ts
   * import { extractJson } from 'genkit/extract';
   *
   * ai.defineFormat(
   *   { name: 'customJson' },
   *   (schema) => {
   *     let instructions: string | undefined;
   *     if (schema) {
   *       instructions = `Output should be in JSON format and conform to the following schema:
   * \`\`\`
   * ${JSON.stringify(schema)}
   * \`\`\`
   * `;
   *     }
   *     return {
   *       parseChunk: (chunk) => extractJson(chunk.accumulatedText),
   *       parseMessage: (message) => extractJson(message.text),
   *       instructions,
   *     };
   *   }
   * );
   *
   * const { output } = await ai.generate({
   *   prompt: 'Invent a menu item for a pirate themed restaurant.',
   *   output: { format: 'customJson', schema: MenuItemSchema },
   * });
   * ```
   *
   * @beta
   */
  defineFormat(options, handler) {
    return defineFormat(this.registry, options, handler);
  }
  /**
   * Defines and registers an interrupt.
   *
   * Interrupts are special tools that halt model processing and return control back to the caller. Interrupts make it simpler to implement
   * "human-in-the-loop" and out-of-band processing patterns that require waiting on external actions to complete.
   *
   * @beta
   */
  defineInterrupt(config) {
    return defineInterrupt(this.registry, config);
  }
  /**
   * Starts a generate operation for long running generation models, typically for
   * video and complex audio generation.
   *
   * See {@link GenerateOptions} for detailed information about available options.
   *
   * ```ts
   * const operation = await ai.generateOperation({
   *   model: googleAI.model('veo-2.0-generate-001'),
   *   prompt: 'A banana riding a bicycle.',
   * });
   * ```
   *
   * The status of the operation and final result can be obtained using {@link Genkit.checkOperation}.
   */
  generateOperation(opts) {
    return generateOperation(this.registry, opts);
  }
  /**
   * Defines a resource. Resources can then be accessed from a generate call.
   *
   * ```ts
   * ai.defineResource({
   *   uri: 'my://resource/{param}',
   *   description: 'provides my resource',
   * }, async ({param}) => {
   *   return [{ text: `resource ${param}` }]
   * });
   *
   * await ai.generate({
   *   prompt: [{ resource: 'my://resource/value' }]
   * })
   * ```
   */
  defineResource(opts, fn) {
    return defineResource(this.registry, opts, fn);
  }
}
export {
  FileSessionStore,
  GenkitBeta,
  InMemorySessionStore,
  SessionRunner,
  applyPatch,
  diff,
  genkit
};
//# sourceMappingURL=genkit-beta.mjs.map