@oh-my-pi/pi-coding-agent 15.1.1 → 15.1.3

package/dist/types/tools/gh.d.ts

@@ -0,0 +1,356 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import * as z from "zod/v4";
+import type { Settings } from "../config/settings";
+import type { ToolSession } from ".";
+import { type CacheStatus } from "./github-cache";
+import type { OutputMeta } from "./output-meta";
+declare const githubSchema: z.ZodObject<{
+    op: z.ZodEnum<{
+        pr_checkout: "pr_checkout";
+        pr_create: "pr_create";
+        pr_push: "pr_push";
+        repo_view: "repo_view";
+        run_watch: "run_watch";
+        search_code: "search_code";
+        search_commits: "search_commits";
+        search_issues: "search_issues";
+        search_prs: "search_prs";
+        search_repos: "search_repos";
+    }>;
+    repo: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+    pr: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    force: z.ZodOptional<z.ZodBoolean>;
+    forceWithLease: z.ZodOptional<z.ZodBoolean>;
+    title: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodString>;
+    base: z.ZodOptional<z.ZodString>;
+    head: z.ZodOptional<z.ZodString>;
+    draft: z.ZodOptional<z.ZodBoolean>;
+    fill: z.ZodOptional<z.ZodBoolean>;
+    reviewer: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    assignee: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    label: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    query: z.ZodOptional<z.ZodString>;
+    since: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+    dateField: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+        created: "created";
+        updated: "updated";
+    }>>>;
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    run: z.ZodOptional<z.ZodString>;
+    tail: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, z.core.$strict>;
+type GithubInput = z.infer<typeof githubSchema>;
+export interface GhToolDetails {
+    meta?: OutputMeta;
+    artifactId?: string;
+    repo?: string;
+    branch?: string;
+    worktreePath?: string;
+    remote?: string;
+    remoteBranch?: string;
+    headSha?: string;
+    runId?: number;
+    runIds?: number[];
+    status?: string;
+    conclusion?: string;
+    failedJobs?: string[];
+    watch?: GhRunWatchViewDetails;
+    checkouts?: GhPrCheckoutSummary[];
+}
+export interface GhPrCheckoutSummary {
+    prNumber?: number;
+    url?: string;
+    branch: string;
+    worktreePath: string;
+    remote: string;
+    remoteBranch: string;
+    reused: boolean;
+}
+export interface GhRunWatchJobDetails {
+    id: number;
+    name: string;
+    status?: string;
+    conclusion?: string;
+    durationSeconds?: number;
+    url?: string;
+}
+export interface GhRunWatchRunDetails {
+    id: number;
+    workflowName?: string;
+    displayTitle?: string;
+    status?: string;
+    conclusion?: string;
+    branch?: string;
+    headSha?: string;
+    url?: string;
+    jobs: GhRunWatchJobDetails[];
+}
+export interface GhRunWatchFailedLogDetails {
+    runId: number;
+    workflowName?: string;
+    jobName: string;
+    conclusion?: string;
+    tail?: string;
+    available: boolean;
+}
+export interface GhRunWatchViewDetails {
+    mode: "run" | "commit";
+    state: "watching" | "completed";
+    repo: string;
+    branch?: string;
+    headSha?: string;
+    pollCount?: number;
+    note?: string;
+    run?: GhRunWatchRunDetails;
+    runs?: GhRunWatchRunDetails[];
+    failedLogs?: GhRunWatchFailedLogDetails[];
+}
+interface GhUser {
+    login?: string;
+    name?: string | null;
+}
+interface GhLabel {
+    name?: string;
+}
+interface GhComment {
+    author?: GhUser | null;
+    body?: string;
+    createdAt?: string;
+    url?: string;
+    isMinimized?: boolean;
+    minimizedReason?: string | null;
+}
+interface GhRepoTopic {
+    name?: string;
+    topic?: {
+        name?: string;
+    };
+}
+interface GhRepoLanguage {
+    name?: string;
+}
+interface GhRepoBranch {
+    name?: string;
+}
+interface GhRepoViewData {
+    nameWithOwner?: string;
+    description?: string | null;
+    url?: string;
+    sshUrl?: string;
+    defaultBranchRef?: GhRepoBranch | null;
+    homepageUrl?: string | null;
+    forkCount?: number;
+    isArchived?: boolean;
+    isFork?: boolean;
+    primaryLanguage?: GhRepoLanguage | null;
+    repositoryTopics?: GhRepoTopic[];
+    stargazerCount?: number;
+    updatedAt?: string;
+    viewerPermission?: string | null;
+    visibility?: string | null;
+}
+interface GhIssueViewData {
+    author?: GhUser | null;
+    body?: string | null;
+    comments?: GhComment[];
+    createdAt?: string;
+    labels?: GhLabel[];
+    number?: number;
+    state?: string;
+    stateReason?: string | null;
+    title?: string;
+    updatedAt?: string;
+    url?: string;
+}
+interface GhPrFile {
+    path?: string;
+    additions?: number;
+    deletions?: number;
+    changeType?: string;
+}
+interface GhPrViewData extends GhIssueViewData {
+    baseRefName?: string;
+    files?: GhPrFile[];
+    headRefName?: string;
+    headRefOid?: string;
+    headRepository?: GhRepoViewData | null;
+    headRepositoryOwner?: GhUser | null;
+    isCrossRepository?: boolean;
+    isDraft?: boolean;
+    maintainerCanModify?: boolean;
+    mergeStateStatus?: string;
+    reviewComments?: GhPrReviewComment[];
+    reviews?: GhPrReview[];
+    reviewDecision?: string;
+}
+interface GhPrReviewCommit {
+    oid?: string | null;
+}
+interface GhPrReview {
+    author?: GhUser | null;
+    body?: string | null;
+    commit?: GhPrReviewCommit | null;
+    state?: string | null;
+    submittedAt?: string | null;
+}
+interface GhPrReviewComment {
+    author?: GhUser | null;
+    body?: string | null;
+    createdAt?: string;
+    id: number;
+    inReplyToId?: number;
+    line?: number;
+    originalLine?: number;
+    path?: string;
+    side?: string;
+    url?: string;
+}
+/**
+ * Resolve a search date bound to a GitHub-search-compatible literal. Returns
+ * either a `YYYY-MM-DD` date (relative durations and date-only inputs) or a
+ * full ISO 8601 datetime string (datetime inputs), so the caller can drop it
+ * straight into a qualifier like `created:>=<value>`.
+ */
+export declare function parseSearchDateBound(raw: string, now?: Date): string;
+/**
+ * Build the GitHub-search qualifier (e.g. `created:>=2026-05-09`) for the
+ * provided bounds, or `undefined` if neither bound is set.
+ */
+export declare function buildSearchDateQualifier(field: string, since: string | undefined, until: string | undefined, now?: Date): string | undefined;
+/**
+ * Parse a digit-only decimal positive integer or return undefined. Rejects
+ * `1e2`, `0x10`, `12.0`, leading +/-, or any other shape `Number()` would
+ * accept — those would otherwise key the cache against the wrong row.
+ */
+export declare function parsePositiveDecimalInt(value: string | undefined): number | undefined;
+export declare function resolveDefaultRepoMemoized(cwd: string, signal?: AbortSignal): Promise<string>;
+export declare class GithubTool implements AgentTool<typeof githubSchema, GhToolDetails> {
+    private readonly session;
+    readonly name = "github";
+    readonly summary = "Interact with GitHub issues, pull requests, and repositories";
+    readonly loadMode = "discoverable";
+    readonly label = "GitHub";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        op: z.ZodEnum<{
+            pr_checkout: "pr_checkout";
+            pr_create: "pr_create";
+            pr_push: "pr_push";
+            repo_view: "repo_view";
+            run_watch: "run_watch";
+            search_code: "search_code";
+            search_commits: "search_commits";
+            search_issues: "search_issues";
+            search_prs: "search_prs";
+            search_repos: "search_repos";
+        }>;
+        repo: z.ZodOptional<z.ZodString>;
+        branch: z.ZodOptional<z.ZodString>;
+        pr: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        force: z.ZodOptional<z.ZodBoolean>;
+        forceWithLease: z.ZodOptional<z.ZodBoolean>;
+        title: z.ZodOptional<z.ZodString>;
+        body: z.ZodOptional<z.ZodString>;
+        base: z.ZodOptional<z.ZodString>;
+        head: z.ZodOptional<z.ZodString>;
+        draft: z.ZodOptional<z.ZodBoolean>;
+        fill: z.ZodOptional<z.ZodBoolean>;
+        reviewer: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        assignee: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        label: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        query: z.ZodOptional<z.ZodString>;
+        since: z.ZodOptional<z.ZodString>;
+        until: z.ZodOptional<z.ZodString>;
+        dateField: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            created: "created";
+            updated: "updated";
+        }>>>;
+        limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        run: z.ZodOptional<z.ZodString>;
+        tail: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    }, z.core.$strict>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): GithubTool | null;
+    execute(_toolCallId: string, params: GithubInput, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<GhToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<GhToolDetails>>;
+}
+export interface IssueViewLookupOptions {
+    cwd: string;
+    repo?: string;
+    /** Issue number or GitHub issue URL. */
+    issue: string;
+    includeComments?: boolean;
+    signal?: AbortSignal;
+    settings?: Settings;
+    cacheAuthKey?: string | null;
+}
+export interface PrViewLookupOptions {
+    cwd: string;
+    repo: string;
+    number: number;
+    includeComments?: boolean;
+    signal?: AbortSignal;
+    settings?: Settings;
+    cacheAuthKey?: string | null;
+}
+export interface ViewLookupResult<T> {
+    rendered: string;
+    sourceUrl: string | undefined;
+    payload: T;
+    status: CacheStatus;
+    fetchedAt: number;
+}
+/**
+ * Cache-aware issue/view fetcher. Used by both the `github` tool op and the
+ * `issue://` protocol handler so a single shared row services both surfaces.
+ */
+export declare function getOrFetchIssue(options: IssueViewLookupOptions): Promise<ViewLookupResult<GhIssueViewData>>;
+/**
+ * Cache-aware PR view fetcher. Caller must supply a numeric PR number;
+ * branch-name / current-branch lookups bypass the cache entirely upstream
+ * (see `executePrView`).
+ */
+export declare function getOrFetchPr(options: PrViewLookupOptions): Promise<ViewLookupResult<GhPrViewData>>;
+export interface PrDiffFile {
+    /** Display path. Prefers the post-image (`b/<path>`) when present. */
+    path: string;
+    additions: number;
+    deletions: number;
+    changeType: "modified" | "added" | "deleted" | "renamed" | "binary";
+    /** Pre-image path for renames/deletes; same as `path` otherwise. */
+    oldPath?: string;
+    /** Byte offset of the section's `diff --git` line in the unified diff. */
+    startOffset: number;
+    /** Byte offset of the next section (or end-of-text). */
+    endOffset: number;
+}
+export interface PrDiffPayload {
+    /** Full unified diff text as returned by `gh pr diff --color never`. */
+    unified: string;
+    files: PrDiffFile[];
+}
+export interface PrDiffLookupOptions {
+    cwd: string;
+    repo: string;
+    number: number;
+    signal?: AbortSignal;
+    settings?: Settings;
+    cacheAuthKey?: string | null;
+}
+/**
+ * Split `gh pr diff` output on `^diff --git ` boundaries and parse per-file
+ * metadata. The unified diff is preserved verbatim so callers can slice it by
+ * byte offsets without re-running gh.
+ */
+export declare function parsePrUnifiedDiff(text: string): PrDiffPayload;
+/**
+ * Cache-aware PR diff fetcher. Stores the full unified diff plus a parsed
+ * file index in a single `pr-diff` cache row so the listing, full-diff, and
+ * per-file slice variants of `pr://<n>/diff` share one `gh pr diff`
+ * invocation.
+ */
+export declare function getOrFetchPrDiff(options: PrDiffLookupOptions): Promise<ViewLookupResult<PrDiffPayload>>;
+export {};

package/dist/types/tools/github-cache.d.ts

@@ -0,0 +1,103 @@
+/**
+ * SQLite-backed cache for rendered `github` issue/PR view output, plus a
+ * generic cache-aware wrapper that the tool ops and the `issue://`/`pr://`
+ * protocol handlers share.
+ *
+ * Storage:
+ *   One process-wide connection opens lazily on first hit and stays open. All
+ *   helpers swallow open/IO failures and degrade to "no cache" so a corrupt or
+ *   unreadable DB never blocks a `gh` call.
+ *
+ * TTL:
+ *   Soft TTL → return cached row directly.
+ *   Past soft TTL but within hard TTL → return cached row AND schedule a
+ *     background refresh (errors logged, never thrown).
+ *   Past hard TTL → treat as miss and fetch fresh.
+ */
+import { Database } from "bun:sqlite";
+import type { Settings } from "../config/settings";
+export type CacheKind = "issue" | "pr" | "pr-diff";
+export interface CachedView<T = unknown> {
+    authKey: string;
+    repo: string;
+    kind: CacheKind;
+    number: number;
+    includeComments: boolean;
+    fetchedAt: number;
+    payload: T;
+    rendered: string;
+    sourceUrl: string | undefined;
+}
+export declare function openDb(): Database | null;
+/**
+ * Best-effort local fingerprint for the active GitHub CLI credentials.
+ *
+ * Cache hits must not cross account/token boundaries, but doing a `gh api user`
+ * probe before every cached read would defeat the soft-TTL contract that cache
+ * hits avoid a gh round-trip. Instead, key rows by credential material that the
+ * GitHub CLI itself consumes: token environment variables and/or hosts.yml.
+ * The DB stores only a hash, never the token or hosts.yml contents. If no
+ * credential source is visible, callers should pass `null` to bypass caching.
+ */
+export declare function resolveGithubCacheAuthKey(host?: string): string | undefined;
+export declare function getCached<T = unknown>(repo: string, kind: CacheKind, number: number, includeComments: boolean, authKey?: string): CachedView<T> | null;
+export interface PutCachedInput<T = unknown> {
+    authKey?: string;
+    repo: string;
+    kind: CacheKind;
+    number: number;
+    includeComments: boolean;
+    payload: T;
+    rendered: string;
+    sourceUrl?: string;
+    fetchedAt?: number;
+}
+export declare function putCached<T = unknown>(input: PutCachedInput<T>): void;
+/** Drop a specific cache entry. */
+export declare function invalidate(repo: string, kind: CacheKind, number: number, includeComments?: boolean, authKey?: string): void;
+/** Drop every cached row. Test helper. */
+export declare function clearAll(): void;
+/**
+ * Test/maintenance helper. Closes and forgets the cached connection so the
+ * next access reopens against (possibly) a different DB path.
+ */
+export declare function resetForTests(): void;
+export interface FreshResult<T> {
+    rendered: string;
+    sourceUrl: string | undefined;
+    payload: T;
+}
+export interface CacheLookupOptions<T> {
+    repo: string;
+    kind: CacheKind;
+    number: number;
+    includeComments: boolean;
+    /**
+     * Auth/credential namespace for cache rows. Omit only in storage-layer
+     * tests; pass `null` when production code cannot determine an identity and
+     * must bypass persistent cache reads/writes.
+     */
+    authKey?: string | null;
+    fetchFresh: () => Promise<FreshResult<T>>;
+    settings?: Settings | undefined;
+    now?: number;
+}
+export type CacheStatus = "miss" | "fresh" | "stale" | "disabled";
+export interface CacheLookupResult<T> {
+    rendered: string;
+    sourceUrl: string | undefined;
+    payload: T;
+    status: CacheStatus;
+    fetchedAt: number;
+}
+export interface CacheTtl {
+    softMs: number;
+    hardMs: number;
+    enabled: boolean;
+}
+export declare function resolveCacheTtl(settings?: Settings): CacheTtl;
+export declare function getOrFetchView<T>(options: CacheLookupOptions<T>): Promise<CacheLookupResult<T>>;
+/**
+ * Human-friendly freshness note for protocol-handler `notes[]` rendering.
+ */
+export declare function formatFreshnessNote(status: CacheStatus, fetchedAtMs: number, now?: number): string;

package/dist/types/tools/grouped-file-output.d.ts

@@ -0,0 +1,36 @@
+/**
+ * One file's contribution to a grouped file output. The header itself is generated
+ * by `formatGroupedFiles` (single `#` for root files, `##` for files inside a dir);
+ * use `headerSuffix` to tack on extras like ` (1 replacement)`.
+ */
+export interface GroupedFileSection {
+    /** Optional suffix appended to the file header. */
+    headerSuffix?: string;
+    /** Body lines emitted into the textual model output. */
+    modelLines: string[];
+    /** Body lines emitted into the display output. Defaults to `modelLines`. */
+    displayLines?: string[];
+    /** When true, the file (and its header) is omitted entirely. */
+    skip?: boolean;
+}
+export interface GroupedFilesOutput {
+    model: string[];
+    display: string[];
+}
+/**
+ * Render a list of files as directory-grouped sections shared by grep, ast-grep,
+ * ast-edit, and the LSP diagnostic formatter.
+ *
+ * Layout:
+ *   # dir/
+ *   ## file.ts
+ *   …body…
+ *
+ *   # otherdir/
+ *   ## other.ts
+ *   …body…
+ *
+ * Files in the project root (directory `.`) become single-`#` headers without a
+ * `## file` line, matching the existing convention.
+ */
+export declare function formatGroupedFiles(files: string[], renderFile: (filePath: string) => GroupedFileSection): GroupedFilesOutput;

package/dist/types/tools/hindsight-recall.d.ts

@@ -0,0 +1,23 @@
+import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import * as z from "zod/v4";
+import type { ToolSession } from ".";
+declare const hindsightRecallSchema: z.ZodObject<{
+    query: z.ZodString;
+}, z.core.$strip>;
+export type HindsightRecallParams = z.infer<typeof hindsightRecallSchema>;
+export declare class HindsightRecallTool implements AgentTool<typeof hindsightRecallSchema> {
+    private readonly session;
+    readonly name = "recall";
+    readonly label = "Recall";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        query: z.ZodString;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    readonly summary = "Search hindsight memory for relevant prior context";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): HindsightRecallTool | null;
+    execute(_id: string, params: HindsightRecallParams, signal?: AbortSignal): Promise<AgentToolResult>;
+}
+export {};

package/dist/types/tools/hindsight-reflect.d.ts

@@ -0,0 +1,25 @@
+import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import * as z from "zod/v4";
+import type { ToolSession } from ".";
+declare const hindsightReflectSchema: z.ZodObject<{
+    query: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HindsightReflectParams = z.infer<typeof hindsightReflectSchema>;
+export declare class HindsightReflectTool implements AgentTool<typeof hindsightReflectSchema> {
+    private readonly session;
+    readonly name = "reflect";
+    readonly label = "Reflect";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        query: z.ZodString;
+        context: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    readonly summary = "Reflect on recent work and write hindsight memory";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): HindsightReflectTool | null;
+    execute(_id: string, params: HindsightReflectParams, signal?: AbortSignal): Promise<AgentToolResult>;
+}
+export {};

package/dist/types/tools/hindsight-retain.d.ts

@@ -0,0 +1,29 @@
+import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import * as z from "zod/v4";
+import type { ToolSession } from ".";
+declare const hindsightRetainSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        content: z.ZodString;
+        context: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type HindsightRetainParams = z.infer<typeof hindsightRetainSchema>;
+export declare class HindsightRetainTool implements AgentTool<typeof hindsightRetainSchema> {
+    private readonly session;
+    readonly name = "retain";
+    readonly label = "Retain";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            content: z.ZodString;
+            context: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    readonly summary = "Store important facts in hindsight memory";
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): HindsightRetainTool | null;
+    execute(_id: string, params: HindsightRetainParams): Promise<AgentToolResult>;
+}
+export {};

package/dist/types/tools/image-gen.d.ts

@@ -0,0 +1,78 @@
+import { type Model } from "@oh-my-pi/pi-ai";
+import * as z from "zod/v4";
+import { type ModelRegistry } from "../config/model-registry";
+import type { CustomTool } from "../extensibility/custom-tools/types";
+type ImageProvider = "antigravity" | "gemini" | "openai" | "openai-codex" | "openrouter";
+declare const responseModalitySchema: z.ZodEnum<{
+    IMAGE: "IMAGE";
+    TEXT: "TEXT";
+}>;
+export declare const imageGenSchema: z.ZodObject<{
+    subject: z.ZodString;
+    action: z.ZodOptional<z.ZodString>;
+    scene: z.ZodOptional<z.ZodString>;
+    composition: z.ZodOptional<z.ZodString>;
+    lighting: z.ZodOptional<z.ZodString>;
+    style: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+    changes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    aspect_ratio: z.ZodOptional<z.ZodEnum<{
+        "16:9": "16:9";
+        "1:1": "1:1";
+        "3:4": "3:4";
+        "4:3": "4:3";
+        "9:16": "9:16";
+    }>>;
+    image_size: z.ZodOptional<z.ZodEnum<{
+        "1024x1024": "1024x1024";
+        "1024x1536": "1024x1536";
+        "1536x1024": "1536x1024";
+    }>>;
+    input: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodOptional<z.ZodString>;
+        data: z.ZodOptional<z.ZodString>;
+        mime_type: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type ImageGenParams = z.infer<typeof imageGenSchema>;
+export type GeminiResponseModality = z.infer<typeof responseModalitySchema>;
+interface GeminiSafetyRating {
+    category?: string;
+    probability?: string;
+}
+interface GeminiPromptFeedback {
+    blockReason?: string;
+    safetyRatings?: GeminiSafetyRating[];
+}
+interface GeminiUsageMetadata {
+    promptTokenCount?: number;
+    candidatesTokenCount?: number;
+    totalTokenCount?: number;
+}
+interface OpenAIResponsesUsage {
+    input_tokens?: number;
+    output_tokens?: number;
+    total_tokens?: number;
+}
+type ImageUsageMetadata = GeminiUsageMetadata | OpenAIResponsesUsage;
+interface ImageGenToolDetails {
+    provider: ImageProvider;
+    model: string;
+    imageCount: number;
+    imagePaths: string[];
+    images: InlineImageData[];
+    responseText?: string;
+    promptFeedback?: GeminiPromptFeedback;
+    revisedPrompt?: string;
+    usage?: ImageUsageMetadata;
+}
+interface InlineImageData {
+    data: string;
+    mimeType: string;
+}
+/** Set the preferred image provider from settings */
+export declare function setPreferredImageProvider(provider: ImageProvider | "auto"): void;
+export declare const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails>;
+export declare function getImageGenTools(modelRegistry?: ModelRegistry, activeModel?: Model): Promise<Array<CustomTool<typeof imageGenSchema, ImageGenToolDetails>>>;
+export declare function getImageGenToolsWithRegistry(modelRegistry: ModelRegistry, activeModel?: Model): Promise<Array<CustomTool<typeof imageGenSchema, ImageGenToolDetails>>>;
+export {};