import { type FrontendToolManifestV1, type HostToolResultRequest, type SpotlightInitializeResponse, type SpotlightItem, type SpotlightSkill, type SpotlightSkillRegistration, type SpotlightThread, type SpotlightTurn, type SpotlightTurnEvent, type SpotlightTurnStartRequest } from "@inupedia/spotlight-protocol";
import { type SpotlightClientConfig } from "./http.js";
import { type ClientTool } from "./clientTool.js";
import type { SpotlightResourceProvider } from "./resourceProvider.js";
export interface SpotlightAppClientOptions extends SpotlightClientConfig {
    toolManifest?: FrontendToolManifestV1 | (() => FrontendToolManifestV1 | Promise<FrontendToolManifestV1>);
    /** Preferred: register Tools and let the SDK derive and snapshot the manifest. */
    tools?: readonly ClientTool[] | (() => readonly ClientTool[]);
    /** Resource providers generate search/get/action Tools and optional Skills. */
    resources?: readonly SpotlightResourceProvider[] | (() => readonly SpotlightResourceProvider[]);
    frontendBuildId?: string;
    skills?: Array<SpotlightSkill | SpotlightSkillRegistration> | (() => Array<SpotlightSkill | SpotlightSkillRegistration>);
    executeTool?: (request: {
        turnId: string;
        item: Extract<SpotlightItem, {
            type: "tool_call";
        }>;
    }) => Promise<{
        success: boolean;
        output?: unknown;
        error?: string;
        trace?: HostToolResultRequest["trace"];
        uiContext?: HostToolResultRequest["uiContext"];
    }>;
    approveTool?: (request: {
        turnId: string;
        item: Extract<SpotlightItem, {
            type: "tool_call";
        }>;
        reason?: string;
    }) => boolean | Promise<boolean>;
    clientInfo?: {
        name?: string;
        title?: string;
        version?: string;
    };
}
export interface SpotlightRunResult {
    thread: SpotlightThread;
    turn: SpotlightTurn;
    events: SpotlightTurnEvent[];
    items: SpotlightItem[];
    finalResponse: string;
    summary?: Extract<SpotlightTurnEvent, {
        type: "turn.completed";
    }>["summary"];
}
export interface SpotlightRunOptions extends Omit<SpotlightTurnStartRequest, "input"> {
    signal?: AbortSignal;
    threadId?: string;
}
export interface SpotlightThreadHandle {
    readonly id: string | undefined;
    run(input: string, options?: Omit<SpotlightRunOptions, "threadId">): Promise<SpotlightRunResult>;
}
export declare class SpotlightAppClient {
    private readonly options;
    private readonly http;
    private initialization;
    private initializedDigest;
    private capabilitySessionId;
    private toolRegistry;
    constructor(options: SpotlightAppClientOptions);
    private manifest;
    private resolveResources;
    private resolveTools;
    private resolveSkills;
    initialize(signal?: AbortSignal): Promise<SpotlightInitializeResponse>;
    startThread(threadId?: string, signal?: AbortSignal): Promise<SpotlightThread>;
    thread(threadId?: string): SpotlightThreadHandle;
    listThreads(signal?: AbortSignal): Promise<SpotlightThread[]>;
    forkThread(threadId: string, signal?: AbortSignal): Promise<SpotlightThread>;
    startTurn(threadId: string, request: SpotlightTurnStartRequest, signal?: AbortSignal): Promise<SpotlightTurn>;
    run(input: string, options?: SpotlightRunOptions): Promise<SpotlightRunResult>;
    streamTurn(turnId: string, signal?: AbortSignal): AsyncGenerator<SpotlightTurnEvent>;
    submitToolResult(turnId: string, result: HostToolResultRequest, signal?: AbortSignal): Promise<{
        ok: true;
    }>;
    cancelTurn(turnId: string): Promise<void>;
}
export declare function createSpotlightAppClient(options: SpotlightAppClientOptions): SpotlightAppClient;
//# sourceMappingURL=appClient.d.ts.map