@yudin-s/react-chrome-ai 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,431 @@
+type ChromeAIAvailability = "unavailable" | "downloadable" | "downloading" | "available";
+type ChromeAIModelStatus = "idle" | "checking" | "unsupported" | "unavailable" | "downloadable" | "downloading" | "preparing" | "ready" | "prompting" | "streaming" | "aborted" | "error";
+type ChromeAIMessageRole = "system" | "user" | "assistant";
+type ChromeAIModality = "text" | "image" | "audio";
+type ChromeAILanguage = "en" | "ja" | "es" | (string & {});
+type ChromeAIMediaValue = AudioBuffer | ArrayBuffer | ArrayBufferView | Blob | HTMLImageElement | SVGImageElement | HTMLVideoElement | HTMLCanvasElement | ImageBitmap | OffscreenCanvas | VideoFrame | ImageData;
+interface ChromeAIPromptPart {
+    type: ChromeAIModality;
+    value: string | ChromeAIMediaValue;
+}
+interface ChromeAIMessage {
+    role: ChromeAIMessageRole;
+    content: string | ChromeAIPromptPart[];
+    prefix?: boolean;
+}
+type ChromeAIPromptInput = string | ChromeAIMessage[];
+interface ChromeAIExpected {
+    type: ChromeAIModality;
+    languages?: ChromeAILanguage[];
+}
+interface ChromeAIParams {
+    defaultTopK: number;
+    maxTopK: number;
+    defaultTemperature: number;
+    maxTemperature: number;
+}
+interface ChromeAIDownloadEventLike {
+    loaded?: number;
+    total?: number;
+}
+interface ChromeAIDownloadProgress {
+    loaded?: number;
+    total?: number;
+    progress?: number;
+    percent?: number;
+    indeterminate: boolean;
+    completed: boolean;
+}
+interface ChromeAIMonitorEventTarget extends EventTarget {
+    addEventListener(type: "downloadprogress", listener: (event: Event & ChromeAIDownloadEventLike) => void, options?: boolean | AddEventListenerOptions): void;
+}
+interface ChromeAISessionPromptOptions {
+    signal?: AbortSignal;
+    responseConstraint?: unknown;
+    omitResponseConstraintInput?: boolean;
+}
+interface ChromeAISessionCloneOptions {
+    signal?: AbortSignal;
+}
+interface ChromeAIContextUsageOptions {
+    responseConstraint?: unknown;
+    omitResponseConstraintInput?: boolean;
+}
+interface ChromeAILanguageModelSession extends EventTarget {
+    readonly contextUsage?: number;
+    readonly contextWindow?: number;
+    prompt(input: ChromeAIPromptInput, options?: ChromeAISessionPromptOptions): Promise<string>;
+    promptStreaming(input: ChromeAIPromptInput, options?: ChromeAISessionPromptOptions): ReadableStream<string> | AsyncIterable<string>;
+    append?(input: ChromeAIMessage[], options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    clone?(options?: ChromeAISessionCloneOptions): Promise<ChromeAILanguageModelSession>;
+    destroy(): void;
+    measureContextUsage?(input?: ChromeAIPromptInput, options?: ChromeAIContextUsageOptions): Promise<number>;
+}
+interface ChromeAICreateOptions {
+    initialPrompts?: ChromeAIMessage[];
+    expectedInputs?: ChromeAIExpected[];
+    expectedOutputs?: ChromeAIExpected[];
+    topK?: number;
+    temperature?: number;
+    signal?: AbortSignal;
+    monitor?: (monitor: ChromeAIMonitorEventTarget) => void;
+}
+type ChromeAIAvailabilityOptions = Pick<ChromeAICreateOptions, "expectedInputs" | "expectedOutputs" | "topK" | "temperature" | "initialPrompts">;
+interface ChromeAILanguageModelAPI {
+    availability(options?: ChromeAIAvailabilityOptions): Promise<ChromeAIAvailability>;
+    create(options?: ChromeAICreateOptions): Promise<ChromeAILanguageModelSession>;
+    params?(): Promise<ChromeAIParams>;
+}
+interface ChromeAIRuntime {
+    LanguageModel?: ChromeAILanguageModelAPI;
+    ai?: {
+        languageModel?: ChromeAILanguageModelAPI;
+    };
+}
+interface ChromeAIDiagnostic {
+    status: ChromeAIModelStatus;
+    supported: boolean;
+    availability?: ChromeAIAvailability;
+    progress?: ChromeAIDownloadProgress;
+    userActivation?: boolean;
+    contextUsage?: number;
+    contextWindow?: number;
+    error?: Error;
+}
+interface ChromeAISessionState {
+    status: ChromeAIModelStatus;
+    session: ChromeAILanguageModelSession | null;
+    availability?: ChromeAIAvailability;
+    progress?: ChromeAIDownloadProgress;
+    error?: Error;
+}
+interface ChromeAIPromptState<TData = unknown> {
+    status: ChromeAIModelStatus;
+    input?: ChromeAIPromptInput;
+    text: string;
+    data?: TData;
+    chunks: string[];
+    error?: Error;
+}
+interface ChromeAIReflectionOptions<TData = unknown> {
+    schema?: unknown;
+    format?: "json" | "text";
+    instructions?: string;
+    reflect?: boolean;
+    reflectionPrompt?: (draft: string) => ChromeAIPromptInput;
+    parse?: (text: string) => TData;
+}
+type ChromeAITaskAPIName = "LanguageModel" | "Summarizer" | "Translator" | "LanguageDetector" | "Writer" | "Rewriter" | "Proofreader";
+interface ChromeAITaskAPI<TSession = unknown> {
+    availability(options?: Record<string, unknown>): Promise<ChromeAIAvailability>;
+    create(options?: Record<string, unknown>): Promise<TSession>;
+}
+interface ChromeAITaskSession {
+    destroy?: () => void;
+    [method: string]: unknown;
+}
+interface ChromeAITaskCreateOptions {
+    signal?: AbortSignal;
+    monitor?: (monitor: ChromeAIMonitorEventTarget) => void;
+    [key: string]: unknown;
+}
+interface ChromeAITaskOperationState<TResult = unknown> {
+    status: ChromeAIModelStatus;
+    result?: TResult;
+    text: string;
+    chunks: string[];
+    error?: Error;
+}
+
+interface UseChromeAIAvailabilityOptions {
+    options?: ChromeAIAvailabilityOptions;
+    autoCheck?: boolean;
+}
+interface UseChromeAIAvailabilityResult {
+    supported: boolean;
+    status: "idle" | "checking" | "ready" | "unavailable" | "error";
+    availability?: ChromeAIAvailability;
+    userActivation?: boolean;
+    error?: Error;
+    refresh: () => Promise<ChromeAIAvailability>;
+}
+declare function useChromeAIAvailability({ options, autoCheck, }?: UseChromeAIAvailabilityOptions): UseChromeAIAvailabilityResult;
+declare function useChromeAIParams(autoLoad?: boolean): {
+    params: ChromeAIParams | undefined;
+    status: "idle" | "unsupported" | "ready" | "error" | "loading";
+    error: Error | undefined;
+    refresh: () => Promise<ChromeAIParams | undefined>;
+};
+interface UseChromeAISessionOptions {
+    createOptions?: ChromeAICreateOptions;
+    autoCreate?: boolean;
+    destroyOnUnmount?: boolean;
+}
+interface UseChromeAISessionResult extends ChromeAISessionState {
+    createSession: (overrideOptions?: ChromeAICreateOptions) => Promise<ChromeAILanguageModelSession>;
+    destroySession: () => void;
+}
+declare function useChromeAISession({ createOptions, autoCreate, destroyOnUnmount, }?: UseChromeAISessionOptions): UseChromeAISessionResult;
+interface UseChromeAIPromptOptions<TData = unknown> extends UseChromeAISessionOptions {
+    reflection?: ChromeAIReflectionOptions<TData>;
+    reuseSession?: boolean;
+}
+interface UseChromeAIPromptResult<TData = unknown> extends ChromeAIPromptState<TData> {
+    prompt: (input: ChromeAIPromptInput, options?: {
+        signal?: AbortSignal;
+    }) => Promise<string>;
+    promptStructured: (input: ChromeAIPromptInput, options?: ChromeAIReflectionOptions<TData> & {
+        signal?: AbortSignal;
+    }) => Promise<{
+        text: string;
+        data?: TData;
+        draft?: string;
+    }>;
+    reset: () => void;
+    session: ChromeAILanguageModelSession | null;
+    progress?: ChromeAIDownloadProgress;
+}
+declare function useChromeAIPrompt<TData = unknown>({ reflection, reuseSession, ...sessionOptions }?: UseChromeAIPromptOptions<TData>): UseChromeAIPromptResult<TData>;
+interface UseChromeAIStreamResult {
+    status: "idle" | "streaming" | "ready" | "aborted" | "error";
+    text: string;
+    chunks: string[];
+    error?: Error;
+    streamPrompt: (input: ChromeAIPromptInput, options?: {
+        signal?: AbortSignal;
+    }) => Promise<string>;
+    reset: () => void;
+}
+declare function useChromeAIStream(session: ChromeAILanguageModelSession | null): UseChromeAIStreamResult;
+interface UseChromeAIAppendResult {
+    status: "idle" | "appending" | "ready" | "unsupported" | "aborted" | "error";
+    error?: Error;
+    append: (messages: ChromeAIMessage[], options?: {
+        signal?: AbortSignal;
+    }) => Promise<void>;
+    reset: () => void;
+}
+declare function useChromeAIAppend(session: ChromeAILanguageModelSession | null): UseChromeAIAppendResult;
+interface UseChromeAICloneResult {
+    status: "idle" | "cloning" | "ready" | "unsupported" | "aborted" | "error";
+    clone: ChromeAILanguageModelSession | null;
+    error?: Error;
+    cloneSession: (options?: {
+        signal?: AbortSignal;
+    }) => Promise<ChromeAILanguageModelSession>;
+    destroyClone: () => void;
+}
+declare function useChromeAIClone(session: ChromeAILanguageModelSession | null): UseChromeAICloneResult;
+interface UseChromeAIContextResult {
+    contextUsage?: number;
+    contextWindow?: number;
+    overflowed: boolean;
+    refresh: () => void;
+    resetOverflow: () => void;
+}
+declare function useChromeAIContext(session: ChromeAILanguageModelSession | null, options?: {
+    pollIntervalMs?: number;
+}): UseChromeAIContextResult;
+interface UseChromeAITaskAvailabilityOptions {
+    apiName: ChromeAITaskAPIName;
+    options?: Record<string, unknown>;
+    autoCheck?: boolean;
+}
+declare function useChromeAITaskAvailability({ apiName, options, autoCheck, }: UseChromeAITaskAvailabilityOptions): {
+    apiName: ChromeAITaskAPIName;
+    supported: boolean;
+    status: "unavailable" | "idle" | "checking" | "ready" | "error";
+    availability: ChromeAIAvailability | undefined;
+    userActivation: boolean | undefined;
+    error: Error | undefined;
+    refresh: () => Promise<ChromeAIAvailability>;
+};
+interface UseChromeAITaskSessionOptions<TSession = ChromeAITaskSession> {
+    apiName: ChromeAITaskAPIName;
+    createOptions?: ChromeAITaskCreateOptions;
+    autoCreate?: boolean;
+    destroyOnUnmount?: boolean;
+    onSession?: (session: TSession) => void;
+}
+declare function useChromeAITaskSession<TSession = ChromeAITaskSession>({ apiName, createOptions, autoCreate, destroyOnUnmount, onSession, }: UseChromeAITaskSessionOptions<TSession>): {
+    apiName: ChromeAITaskAPIName;
+    supported: boolean;
+    status: ChromeAIModelStatus;
+    session: TSession | null;
+    availability: ChromeAIAvailability | undefined;
+    progress: ChromeAIDownloadProgress | undefined;
+    error: Error | undefined;
+    createSession: (overrideOptions?: ChromeAITaskCreateOptions) => Promise<TSession>;
+    destroySession: () => void;
+};
+interface UseChromeAITaskOperationOptions<TSession = ChromeAITaskSession> extends UseChromeAITaskSessionOptions<TSession> {
+    methodName: string;
+    streaming?: boolean;
+    reuseSession?: boolean;
+}
+declare function useChromeAITaskOperation<TResult = unknown, TSession = ChromeAITaskSession>({ methodName, streaming, reuseSession, ...sessionOptions }: UseChromeAITaskOperationOptions<TSession>): {
+    run: (...args: unknown[]) => Promise<TResult>;
+    reset: () => void;
+    status: ChromeAIModelStatus;
+    result?: TResult | undefined;
+    text: string;
+    chunks: string[];
+    error: Error;
+    apiName: ChromeAITaskAPIName;
+    supported: boolean;
+    session: TSession | null;
+    availability: ChromeAIAvailability | undefined;
+    progress: ChromeAIDownloadProgress | undefined;
+    createSession: (overrideOptions?: ChromeAITaskCreateOptions) => Promise<TSession>;
+    destroySession: () => void;
+};
+declare function useChromeAISummarizer(options?: Omit<UseChromeAITaskOperationOptions, "apiName" | "methodName">): {
+    run: (...args: unknown[]) => Promise<string>;
+    reset: () => void;
+    status: ChromeAIModelStatus;
+    result?: string | undefined;
+    text: string;
+    chunks: string[];
+    error: Error;
+    apiName: ChromeAITaskAPIName;
+    supported: boolean;
+    session: ChromeAITaskSession | null;
+    availability: ChromeAIAvailability | undefined;
+    progress: ChromeAIDownloadProgress | undefined;
+    createSession: (overrideOptions?: ChromeAITaskCreateOptions) => Promise<ChromeAITaskSession>;
+    destroySession: () => void;
+};
+declare function useChromeAITranslator(options?: Omit<UseChromeAITaskOperationOptions, "apiName" | "methodName">): {
+    run: (...args: unknown[]) => Promise<string>;
+    reset: () => void;
+    status: ChromeAIModelStatus;
+    result?: string | undefined;
+    text: string;
+    chunks: string[];
+    error: Error;
+    apiName: ChromeAITaskAPIName;
+    supported: boolean;
+    session: ChromeAITaskSession | null;
+    availability: ChromeAIAvailability | undefined;
+    progress: ChromeAIDownloadProgress | undefined;
+    createSession: (overrideOptions?: ChromeAITaskCreateOptions) => Promise<ChromeAITaskSession>;
+    destroySession: () => void;
+};
+declare function useChromeAILanguageDetector(options?: Omit<UseChromeAITaskOperationOptions, "apiName" | "methodName" | "streaming">): {
+    run: (...args: unknown[]) => Promise<unknown>;
+    reset: () => void;
+    status: ChromeAIModelStatus;
+    result?: unknown;
+    text: string;
+    chunks: string[];
+    error: Error;
+    apiName: ChromeAITaskAPIName;
+    supported: boolean;
+    session: ChromeAITaskSession | null;
+    availability: ChromeAIAvailability | undefined;
+    progress: ChromeAIDownloadProgress | undefined;
+    createSession: (overrideOptions?: ChromeAITaskCreateOptions) => Promise<ChromeAITaskSession>;
+    destroySession: () => void;
+};
+declare function useChromeAIWriter(options?: Omit<UseChromeAITaskOperationOptions, "apiName" | "methodName">): {
+    run: (...args: unknown[]) => Promise<string>;
+    reset: () => void;
+    status: ChromeAIModelStatus;
+    result?: string | undefined;
+    text: string;
+    chunks: string[];
+    error: Error;
+    apiName: ChromeAITaskAPIName;
+    supported: boolean;
+    session: ChromeAITaskSession | null;
+    availability: ChromeAIAvailability | undefined;
+    progress: ChromeAIDownloadProgress | undefined;
+    createSession: (overrideOptions?: ChromeAITaskCreateOptions) => Promise<ChromeAITaskSession>;
+    destroySession: () => void;
+};
+declare function useChromeAIRewriter(options?: Omit<UseChromeAITaskOperationOptions, "apiName" | "methodName">): {
+    run: (...args: unknown[]) => Promise<string>;
+    reset: () => void;
+    status: ChromeAIModelStatus;
+    result?: string | undefined;
+    text: string;
+    chunks: string[];
+    error: Error;
+    apiName: ChromeAITaskAPIName;
+    supported: boolean;
+    session: ChromeAITaskSession | null;
+    availability: ChromeAIAvailability | undefined;
+    progress: ChromeAIDownloadProgress | undefined;
+    createSession: (overrideOptions?: ChromeAITaskCreateOptions) => Promise<ChromeAITaskSession>;
+    destroySession: () => void;
+};
+declare function useChromeAIProofreader(options?: Omit<UseChromeAITaskOperationOptions, "apiName" | "methodName" | "streaming">): {
+    run: (...args: unknown[]) => Promise<unknown>;
+    reset: () => void;
+    status: ChromeAIModelStatus;
+    result?: unknown;
+    text: string;
+    chunks: string[];
+    error: Error;
+    apiName: ChromeAITaskAPIName;
+    supported: boolean;
+    session: ChromeAITaskSession | null;
+    availability: ChromeAIAvailability | undefined;
+    progress: ChromeAIDownloadProgress | undefined;
+    createSession: (overrideOptions?: ChromeAITaskCreateOptions) => Promise<ChromeAITaskSession>;
+    destroySession: () => void;
+};
+
+declare function safeParseJSON<T = unknown>(text: string): T | undefined;
+declare function createStructuredPrompt(input: ChromeAIPromptInput, options?: Pick<ChromeAIReflectionOptions, "format" | "instructions">): ChromeAIPromptInput;
+declare function defaultReflectionPrompt(draft: string): ChromeAIPromptInput;
+declare function promptWithReflection<TData = unknown>(session: ChromeAILanguageModelSession, input: ChromeAIPromptInput, options?: ChromeAIReflectionOptions<TData> & {
+    signal?: AbortSignal;
+}): Promise<{
+    text: string;
+    data?: TData;
+    draft?: string;
+}>;
+
+declare class ChromeAIError extends Error {
+    readonly status: ChromeAIModelStatus;
+    readonly cause?: unknown;
+    constructor(message: string, status?: ChromeAIModelStatus, cause?: unknown);
+}
+declare function getChromeLanguageModelAPI(runtime?: ChromeAIRuntime): ChromeAILanguageModelAPI | undefined;
+declare function isChromeLanguageModelSupported(runtime?: ChromeAIRuntime): boolean;
+declare function defaultLanguageModelOptions(): ChromeAIAvailabilityOptions;
+declare function normalizeDownloadProgress(event?: ChromeAIDownloadEventLike): ChromeAIDownloadProgress;
+declare function readChromeAIAvailability(options?: ChromeAIAvailabilityOptions, runtime?: ChromeAIRuntime): Promise<ChromeAIAvailability>;
+declare function readChromeAIParams(runtime?: ChromeAIRuntime): Promise<ChromeAIParams | undefined>;
+declare function withDownloadProgress(options?: ChromeAICreateOptions, onProgress?: (progress: ChromeAIDownloadProgress, event: ChromeAIDownloadEventLike) => void): ChromeAICreateOptions;
+declare function createChromeAISession(options?: ChromeAICreateOptions, runtime?: ChromeAIRuntime, onProgress?: (progress: ChromeAIDownloadProgress, event: ChromeAIDownloadEventLike) => void): Promise<ChromeAILanguageModelSession>;
+declare function prepareChromeAIModel(options?: ChromeAICreateOptions, runtime?: ChromeAIRuntime, onProgress?: (progress: ChromeAIDownloadProgress, event: ChromeAIDownloadEventLike) => void): Promise<ChromeAIDiagnostic>;
+declare function getUserActivation(): boolean | undefined;
+declare function toError(value: unknown): Error;
+
+declare function readableStreamToAsyncIterable<T>(stream: ReadableStream<T>): AsyncIterable<T>;
+declare function toAsyncIterable<T>(source: ReadableStream<T> | AsyncIterable<T>): AsyncIterable<T>;
+declare function collectAsyncIterable<T>(source: ReadableStream<T> | AsyncIterable<T>): Promise<T[]>;
+
+interface ChromeAITaskRuntime {
+    LanguageModel?: ChromeAITaskAPI;
+    Summarizer?: ChromeAITaskAPI;
+    Translator?: ChromeAITaskAPI;
+    LanguageDetector?: ChromeAITaskAPI;
+    Writer?: ChromeAITaskAPI;
+    Rewriter?: ChromeAITaskAPI;
+    Proofreader?: ChromeAITaskAPI;
+}
+declare function getChromeAITaskAPI<TSession = ChromeAITaskSession>(apiName: ChromeAITaskAPIName, runtime?: ChromeAITaskRuntime): ChromeAITaskAPI<TSession> | undefined;
+declare function isChromeAITaskSupported(apiName: ChromeAITaskAPIName, runtime?: ChromeAITaskRuntime): boolean;
+declare function readChromeAITaskAvailability(apiName: ChromeAITaskAPIName, options?: Record<string, unknown>, runtime?: ChromeAITaskRuntime): Promise<ChromeAIAvailability>;
+declare function withTaskDownloadProgress(options?: ChromeAITaskCreateOptions, onProgress?: (progress: ChromeAIDownloadProgress, event: ChromeAIDownloadEventLike) => void): ChromeAITaskCreateOptions;
+declare function createChromeAITaskSession<TSession = ChromeAITaskSession>(apiName: ChromeAITaskAPIName, options?: ChromeAITaskCreateOptions, runtime?: ChromeAITaskRuntime, onProgress?: (progress: ChromeAIDownloadProgress, event: ChromeAIDownloadEventLike) => void): Promise<TSession>;
+declare function destroyChromeAITaskSession(session: unknown): Promise<void>;
+declare function assertTaskMethod<TArgs extends unknown[] = unknown[], TResult = unknown>(session: unknown, methodName: string): (...args: TArgs) => TResult;
+declare function callChromeAITaskMethod<TResult = unknown>(session: unknown, methodName: string, ...args: unknown[]): Promise<TResult>;
+
+export { type ChromeAIAvailability, type ChromeAIAvailabilityOptions, type ChromeAIContextUsageOptions, type ChromeAICreateOptions, type ChromeAIDiagnostic, type ChromeAIDownloadEventLike, type ChromeAIDownloadProgress, ChromeAIError, type ChromeAIExpected, type ChromeAILanguage, type ChromeAILanguageModelAPI, type ChromeAILanguageModelSession, type ChromeAIMediaValue, type ChromeAIMessage, type ChromeAIMessageRole, type ChromeAIModality, type ChromeAIModelStatus, type ChromeAIMonitorEventTarget, type ChromeAIParams, type ChromeAIPromptInput, type ChromeAIPromptPart, type ChromeAIPromptState, type ChromeAIReflectionOptions, type ChromeAIRuntime, type ChromeAISessionCloneOptions, type ChromeAISessionPromptOptions, type ChromeAISessionState, type ChromeAITaskAPI, type ChromeAITaskAPIName, type ChromeAITaskCreateOptions, type ChromeAITaskOperationState, type ChromeAITaskRuntime, type ChromeAITaskSession, type UseChromeAIAppendResult, type UseChromeAIAvailabilityOptions, type UseChromeAIAvailabilityResult, type UseChromeAICloneResult, type UseChromeAIContextResult, type UseChromeAIPromptOptions, type UseChromeAIPromptResult, type UseChromeAISessionOptions, type UseChromeAISessionResult, type UseChromeAIStreamResult, type UseChromeAITaskAvailabilityOptions, type UseChromeAITaskOperationOptions, type UseChromeAITaskSessionOptions, assertTaskMethod, callChromeAITaskMethod, collectAsyncIterable, createChromeAISession, createChromeAITaskSession, createStructuredPrompt, defaultLanguageModelOptions, defaultReflectionPrompt, destroyChromeAITaskSession, getChromeAITaskAPI, getChromeLanguageModelAPI, getUserActivation, isChromeAITaskSupported, isChromeLanguageModelSupported, normalizeDownloadProgress, prepareChromeAIModel, promptWithReflection, readChromeAIAvailability, readChromeAIParams, readChromeAITaskAvailability, readableStreamToAsyncIterable, safeParseJSON, toAsyncIterable, toError, useChromeAIAppend, useChromeAIAvailability, useChromeAIClone, useChromeAIContext, useChromeAILanguageDetector, useChromeAIParams, useChromeAIPrompt, useChromeAIProofreader, useChromeAIRewriter, useChromeAISession, useChromeAIStream, useChromeAISummarizer, useChromeAITaskAvailability, useChromeAITaskOperation, useChromeAITaskSession, useChromeAITranslator, useChromeAIWriter, withDownloadProgress, withTaskDownloadProgress };