@yudin-s/react-chrome-ai 0.1.0

package/dist/index.js

@@ -0,0 +1,868 @@
+// src/hooks.ts
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+
+// src/runtime.ts
+var ChromeAIError = class extends Error {
+  constructor(message, status = "error", cause) {
+    super(message);
+    this.name = "ChromeAIError";
+    this.status = status;
+    this.cause = cause;
+  }
+};
+var defaultExpectedOptions = {
+  expectedInputs: [{ type: "text", languages: ["en"] }],
+  expectedOutputs: [{ type: "text", languages: ["en"] }]
+};
+function getChromeLanguageModelAPI(runtime = globalThis) {
+  return runtime.LanguageModel ?? runtime.ai?.languageModel;
+}
+function isChromeLanguageModelSupported(runtime) {
+  return Boolean(getChromeLanguageModelAPI(runtime));
+}
+function defaultLanguageModelOptions() {
+  return {
+    expectedInputs: defaultExpectedOptions.expectedInputs?.map((item) => ({ ...item })),
+    expectedOutputs: defaultExpectedOptions.expectedOutputs?.map((item) => ({ ...item }))
+  };
+}
+function normalizeDownloadProgress(event) {
+  const loaded = typeof event?.loaded === "number" ? event.loaded : void 0;
+  const total = typeof event?.total === "number" ? event.total : void 0;
+  const progress = typeof loaded === "number" && typeof total === "number" && total > 0 ? Math.max(0, Math.min(1, loaded / total)) : typeof loaded === "number" && loaded >= 0 && loaded <= 1 ? loaded : void 0;
+  return {
+    loaded,
+    total,
+    progress,
+    percent: typeof progress === "number" ? Math.round(progress * 100) : void 0,
+    indeterminate: typeof progress !== "number",
+    completed: progress === 1
+  };
+}
+async function readChromeAIAvailability(options = defaultLanguageModelOptions(), runtime) {
+  const api = getChromeLanguageModelAPI(runtime);
+  if (!api) {
+    return "unavailable";
+  }
+  try {
+    return await api.availability(options);
+  } catch {
+    return api.availability();
+  }
+}
+async function readChromeAIParams(runtime) {
+  const api = getChromeLanguageModelAPI(runtime);
+  if (!api?.params) {
+    return void 0;
+  }
+  return api.params();
+}
+function withDownloadProgress(options = {}, onProgress) {
+  return {
+    ...options,
+    monitor(monitor) {
+      options.monitor?.(monitor);
+      monitor.addEventListener("downloadprogress", (event) => {
+        const raw = {
+          loaded: typeof event.loaded === "number" ? event.loaded : void 0,
+          total: typeof event.total === "number" ? event.total : void 0
+        };
+        onProgress?.(normalizeDownloadProgress(raw), raw);
+      });
+    }
+  };
+}
+async function createChromeAISession(options = defaultLanguageModelOptions(), runtime, onProgress) {
+  const api = getChromeLanguageModelAPI(runtime);
+  if (!api) {
+    throw new ChromeAIError("Chrome LanguageModel API is not exposed in this runtime.", "unsupported");
+  }
+  const availability = await readChromeAIAvailability(options, runtime);
+  if (availability === "unavailable") {
+    throw new ChromeAIError("Chrome LanguageModel is unavailable on this device, browser, origin, or profile.", "unavailable");
+  }
+  return api.create(withDownloadProgress(options, onProgress));
+}
+async function prepareChromeAIModel(options = defaultLanguageModelOptions(), runtime, onProgress) {
+  const supported = isChromeLanguageModelSupported(runtime);
+  if (!supported) {
+    return { status: "unsupported", supported: false };
+  }
+  const availability = await readChromeAIAvailability(options, runtime);
+  if (availability === "unavailable") {
+    return { status: "unavailable", supported, availability };
+  }
+  let session;
+  try {
+    session = await createChromeAISession(options, runtime, onProgress);
+    return {
+      status: "ready",
+      supported,
+      availability: "available",
+      contextUsage: session.contextUsage,
+      contextWindow: session.contextWindow
+    };
+  } catch (cause) {
+    const error = cause instanceof Error ? cause : new Error(String(cause));
+    return { status: "error", supported, availability, error };
+  } finally {
+    session?.destroy();
+  }
+}
+function getUserActivation() {
+  if (typeof navigator === "undefined") {
+    return void 0;
+  }
+  return navigator.userActivation?.isActive || navigator.userActivation?.hasBeenActive;
+}
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+
+// src/reflection.ts
+function safeParseJSON(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    const match = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    if (!match?.[1]) {
+      return void 0;
+    }
+    try {
+      return JSON.parse(match[1]);
+    } catch {
+      return void 0;
+    }
+  }
+}
+function createStructuredPrompt(input, options = {}) {
+  const suffix = [
+    options.instructions,
+    options.format === "json" ? "Return only valid JSON. Do not include Markdown fences or explanatory text." : void 0
+  ].filter(Boolean).join("\n");
+  if (!suffix) {
+    return input;
+  }
+  if (typeof input === "string") {
+    return `${input}
+
+${suffix}`;
+  }
+  return [
+    ...input,
+    {
+      role: "user",
+      content: suffix
+    }
+  ];
+}
+function defaultReflectionPrompt(draft) {
+  return [
+    {
+      role: "user",
+      content: "Review the previous answer for instruction-following, unsupported claims, and formatting errors. Return the corrected final answer only."
+    },
+    {
+      role: "assistant",
+      content: draft
+    }
+  ];
+}
+async function promptWithReflection(session, input, options = {}) {
+  const promptInput = createStructuredPrompt(input, options);
+  const promptOptions = {
+    signal: options.signal,
+    responseConstraint: options.schema
+  };
+  const draft = await session.prompt(promptInput, promptOptions);
+  const text = options.reflect ? await session.prompt((options.reflectionPrompt ?? defaultReflectionPrompt)(draft), promptOptions) : draft;
+  const data = options.parse ? options.parse(text) : options.format === "json" ? safeParseJSON(text) : void 0;
+  return { text, data, draft: options.reflect ? draft : void 0 };
+}
+
+// src/streams.ts
+async function* readableStreamToAsyncIterable(stream) {
+  const reader = stream.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        return;
+      }
+      yield value;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function toAsyncIterable(source) {
+  if (typeof source[Symbol.asyncIterator] === "function") {
+    return source;
+  }
+  return readableStreamToAsyncIterable(source);
+}
+async function collectAsyncIterable(source) {
+  const chunks = [];
+  for await (const chunk of toAsyncIterable(source)) {
+    chunks.push(chunk);
+  }
+  return chunks;
+}
+
+// src/task-apis.ts
+function getChromeAITaskAPI(apiName, runtime = globalThis) {
+  return runtime[apiName];
+}
+function isChromeAITaskSupported(apiName, runtime) {
+  return Boolean(getChromeAITaskAPI(apiName, runtime));
+}
+async function readChromeAITaskAvailability(apiName, options, runtime) {
+  const api = getChromeAITaskAPI(apiName, runtime);
+  if (!api) {
+    return "unavailable";
+  }
+  try {
+    return await api.availability(options);
+  } catch {
+    return api.availability();
+  }
+}
+function withTaskDownloadProgress(options = {}, onProgress) {
+  return {
+    ...options,
+    monitor(monitor) {
+      options.monitor?.(monitor);
+      monitor.addEventListener("downloadprogress", (event) => {
+        const raw = {
+          loaded: typeof event.loaded === "number" ? event.loaded : void 0,
+          total: typeof event.total === "number" ? event.total : void 0
+        };
+        onProgress?.(normalizeDownloadProgress(raw), raw);
+      });
+    }
+  };
+}
+async function createChromeAITaskSession(apiName, options = {}, runtime, onProgress) {
+  const api = getChromeAITaskAPI(apiName, runtime);
+  if (!api) {
+    throw new Error(`${apiName} API is not exposed in this browser.`);
+  }
+  const availability = await readChromeAITaskAvailability(apiName, options, runtime);
+  if (availability === "unavailable") {
+    throw new Error(`${apiName} API is unavailable for the requested options.`);
+  }
+  return api.create(withTaskDownloadProgress(options, onProgress));
+}
+async function destroyChromeAITaskSession(session) {
+  const destroy = session?.destroy;
+  if (typeof destroy === "function") {
+    destroy.call(session);
+  }
+}
+function assertTaskMethod(session, methodName) {
+  const method = session?.[methodName];
+  if (typeof method !== "function") {
+    throw new Error(`Task session does not expose ${methodName}().`);
+  }
+  return method.bind(session);
+}
+async function callChromeAITaskMethod(session, methodName, ...args) {
+  try {
+    return await assertTaskMethod(session, methodName)(...args);
+  } catch (cause) {
+    throw toError(cause);
+  }
+}
+
+// src/hooks.ts
+function useChromeAIAvailability({
+  options = defaultLanguageModelOptions(),
+  autoCheck = true
+} = {}) {
+  const [status, setStatus] = useState("idle");
+  const [availability, setAvailability] = useState();
+  const [error, setError] = useState();
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const refresh = useCallback(async () => {
+    setStatus("checking");
+    setError(void 0);
+    try {
+      const result = await readChromeAIAvailability(optionsRef.current);
+      setAvailability(result);
+      setStatus(result === "unavailable" ? "unavailable" : "ready");
+      return result;
+    } catch (cause) {
+      const nextError = toError(cause);
+      setError(nextError);
+      setStatus("error");
+      throw nextError;
+    }
+  }, []);
+  useEffect(() => {
+    if (!autoCheck) {
+      return;
+    }
+    void refresh();
+  }, [autoCheck, refresh]);
+  return {
+    supported: isChromeLanguageModelSupported(),
+    status,
+    availability,
+    userActivation: getUserActivation(),
+    error,
+    refresh
+  };
+}
+function useChromeAIParams(autoLoad = true) {
+  const [params, setParams] = useState();
+  const [error, setError] = useState();
+  const [status, setStatus] = useState("idle");
+  const refresh = useCallback(async () => {
+    setStatus("loading");
+    setError(void 0);
+    try {
+      const result = await readChromeAIParams();
+      setParams(result);
+      setStatus(result ? "ready" : "unsupported");
+      return result;
+    } catch (cause) {
+      const nextError = toError(cause);
+      setError(nextError);
+      setStatus("error");
+      throw nextError;
+    }
+  }, []);
+  useEffect(() => {
+    if (autoLoad) {
+      void refresh();
+    }
+  }, [autoLoad, refresh]);
+  return { params, status, error, refresh };
+}
+function useChromeAISession({
+  createOptions = defaultLanguageModelOptions(),
+  autoCreate = false,
+  destroyOnUnmount = true
+} = {}) {
+  const [state, setState] = useState({
+    status: "idle",
+    session: null
+  });
+  const sessionRef = useRef(null);
+  const createOptionsRef = useRef(createOptions);
+  createOptionsRef.current = createOptions;
+  const destroySession = useCallback(() => {
+    sessionRef.current?.destroy();
+    sessionRef.current = null;
+    setState((current) => ({ ...current, status: "idle", session: null }));
+  }, []);
+  const createSession = useCallback(async (overrideOptions) => {
+    setState((current) => ({ ...current, status: "checking", error: void 0 }));
+    const options = overrideOptions ?? createOptionsRef.current;
+    const availability = await readChromeAIAvailability(options);
+    const availabilityStatus = availability === "available" ? "ready" : availability;
+    setState((current) => ({ ...current, availability, status: availabilityStatus }));
+    try {
+      const session = await createChromeAISession(options, void 0, (progress) => {
+        setState((current) => ({
+          ...current,
+          status: progress.completed ? "preparing" : "downloading",
+          progress
+        }));
+      });
+      sessionRef.current?.destroy();
+      sessionRef.current = session;
+      setState({ status: "ready", availability: "available", session });
+      return session;
+    } catch (cause) {
+      const error = toError(cause);
+      setState({ status: error.name === "AbortError" ? "aborted" : "error", session: null, availability, error });
+      throw error;
+    }
+  }, []);
+  useEffect(() => {
+    if (autoCreate) {
+      void createSession();
+    }
+  }, [autoCreate, createSession]);
+  useEffect(() => {
+    if (!destroyOnUnmount) {
+      return;
+    }
+    return () => {
+      sessionRef.current?.destroy();
+      sessionRef.current = null;
+    };
+  }, [destroyOnUnmount]);
+  return {
+    ...state,
+    createSession,
+    destroySession
+  };
+}
+function useChromeAIPrompt({
+  reflection,
+  reuseSession = true,
+  ...sessionOptions
+} = {}) {
+  const { session, createSession, destroySession, progress } = useChromeAISession(sessionOptions);
+  const [state, setState] = useState({
+    status: "idle",
+    text: "",
+    chunks: []
+  });
+  const ensureSession = useCallback(async () => session ?? createSession(), [createSession, session]);
+  const reset = useCallback(() => {
+    setState({ status: "idle", text: "", chunks: [] });
+  }, []);
+  const prompt = useCallback(
+    async (input, options) => {
+      setState({ status: "prompting", input, text: "", chunks: [] });
+      const activeSession = await ensureSession();
+      try {
+        const text = await activeSession.prompt(input, options);
+        setState({ status: "ready", input, text, chunks: [text] });
+        if (!reuseSession) {
+          destroySession();
+        }
+        return text;
+      } catch (cause) {
+        const error = toError(cause);
+        setState({ status: error.name === "AbortError" ? "aborted" : "error", input, text: "", chunks: [], error });
+        throw error;
+      }
+    },
+    [destroySession, ensureSession, reuseSession]
+  );
+  const promptStructured = useCallback(
+    async (input, options) => {
+      setState({ status: "prompting", input, text: "", chunks: [] });
+      const activeSession = await ensureSession();
+      try {
+        const result = await promptWithReflection(activeSession, input, {
+          ...reflection,
+          ...options
+        });
+        setState({ status: "ready", input, text: result.text, data: result.data, chunks: [result.text] });
+        if (!reuseSession) {
+          destroySession();
+        }
+        return result;
+      } catch (cause) {
+        const error = toError(cause);
+        setState({ status: error.name === "AbortError" ? "aborted" : "error", input, text: "", chunks: [], error });
+        throw error;
+      }
+    },
+    [destroySession, ensureSession, reflection, reuseSession]
+  );
+  return {
+    ...state,
+    prompt,
+    promptStructured,
+    reset,
+    session,
+    progress
+  };
+}
+function useChromeAIStream(session) {
+  const [state, setState] = useState({
+    status: "idle",
+    text: "",
+    chunks: []
+  });
+  const reset = useCallback(() => {
+    setState({ status: "idle", text: "", chunks: [] });
+  }, []);
+  const streamPrompt = useCallback(
+    async (input, options) => {
+      if (!session) {
+        throw new Error("Chrome AI session is not ready.");
+      }
+      setState({ status: "streaming", text: "", chunks: [] });
+      try {
+        const chunks = [];
+        for await (const chunk of toAsyncIterable(session.promptStreaming(input, options))) {
+          chunks.push(chunk);
+          setState({ status: "streaming", text: chunks.join(""), chunks: [...chunks] });
+        }
+        const text = chunks.join("");
+        setState({ status: "ready", text, chunks });
+        return text;
+      } catch (cause) {
+        const error = toError(cause);
+        setState({ status: error.name === "AbortError" ? "aborted" : "error", text: "", chunks: [], error });
+        throw error;
+      }
+    },
+    [session]
+  );
+  return useMemo(() => ({ ...state, streamPrompt, reset }), [reset, state, streamPrompt]);
+}
+function useChromeAIAppend(session) {
+  const [state, setState] = useState({
+    status: "idle"
+  });
+  const reset = useCallback(() => {
+    setState({ status: "idle" });
+  }, []);
+  const append = useCallback(
+    async (messages, options) => {
+      if (!session?.append) {
+        const error = new Error("Chrome AI session.append() is not supported in this browser.");
+        setState({ status: "unsupported", error });
+        throw error;
+      }
+      setState({ status: "appending" });
+      try {
+        await session.append(messages, options);
+        setState({ status: "ready" });
+      } catch (cause) {
+        const error = toError(cause);
+        setState({ status: error.name === "AbortError" ? "aborted" : "error", error });
+        throw error;
+      }
+    },
+    [session]
+  );
+  return useMemo(() => ({ ...state, append, reset }), [append, reset, state]);
+}
+function useChromeAIClone(session) {
+  const cloneRef = useRef(null);
+  const [state, setState] = useState({
+    status: "idle",
+    clone: null
+  });
+  const destroyClone = useCallback(() => {
+    cloneRef.current?.destroy();
+    cloneRef.current = null;
+    setState({ status: "idle", clone: null });
+  }, []);
+  const cloneSession = useCallback(
+    async (options) => {
+      if (!session?.clone) {
+        const error = new Error("Chrome AI session.clone() is not supported in this browser.");
+        setState({ status: "unsupported", clone: null, error });
+        throw error;
+      }
+      setState((current) => ({ ...current, status: "cloning", error: void 0 }));
+      try {
+        const nextClone = await session.clone(options);
+        cloneRef.current?.destroy();
+        cloneRef.current = nextClone;
+        setState({ status: "ready", clone: nextClone });
+        return nextClone;
+      } catch (cause) {
+        const error = toError(cause);
+        setState({ status: error.name === "AbortError" ? "aborted" : "error", clone: null, error });
+        throw error;
+      }
+    },
+    [session]
+  );
+  useEffect(() => {
+    return () => {
+      cloneRef.current?.destroy();
+      cloneRef.current = null;
+    };
+  }, []);
+  return {
+    ...state,
+    cloneSession,
+    destroyClone
+  };
+}
+function useChromeAIContext(session, options = {}) {
+  const [contextUsage, setContextUsage] = useState(session?.contextUsage);
+  const [contextWindow, setContextWindow] = useState(session?.contextWindow);
+  const [overflowed, setOverflowed] = useState(false);
+  const refresh = useCallback(() => {
+    setContextUsage(session?.contextUsage);
+    setContextWindow(session?.contextWindow);
+  }, [session]);
+  const resetOverflow = useCallback(() => {
+    setOverflowed(false);
+  }, []);
+  useEffect(() => {
+    refresh();
+  }, [refresh]);
+  useEffect(() => {
+    if (!session) {
+      return;
+    }
+    const onOverflow = () => setOverflowed(true);
+    session.addEventListener("contextoverflow", onOverflow);
+    return () => session.removeEventListener("contextoverflow", onOverflow);
+  }, [session]);
+  useEffect(() => {
+    if (!session || !options.pollIntervalMs) {
+      return;
+    }
+    const id = window.setInterval(refresh, options.pollIntervalMs);
+    return () => window.clearInterval(id);
+  }, [options.pollIntervalMs, refresh, session]);
+  return {
+    contextUsage,
+    contextWindow,
+    overflowed,
+    refresh,
+    resetOverflow
+  };
+}
+function useChromeAITaskAvailability({
+  apiName,
+  options,
+  autoCheck = true
+}) {
+  const [status, setStatus] = useState("idle");
+  const [availability, setAvailability] = useState();
+  const [error, setError] = useState();
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const refresh = useCallback(async () => {
+    setStatus("checking");
+    setError(void 0);
+    try {
+      const result = await readChromeAITaskAvailability(apiName, optionsRef.current);
+      setAvailability(result);
+      setStatus(result === "unavailable" ? "unavailable" : "ready");
+      return result;
+    } catch (cause) {
+      const nextError = toError(cause);
+      setError(nextError);
+      setStatus("error");
+      throw nextError;
+    }
+  }, [apiName]);
+  useEffect(() => {
+    if (autoCheck) {
+      void refresh();
+    }
+  }, [autoCheck, refresh]);
+  return {
+    apiName,
+    supported: isChromeAITaskSupported(apiName),
+    status,
+    availability,
+    userActivation: getUserActivation(),
+    error,
+    refresh
+  };
+}
+function useChromeAITaskSession({
+  apiName,
+  createOptions = {},
+  autoCreate = false,
+  destroyOnUnmount = true,
+  onSession
+}) {
+  const [status, setStatus] = useState("idle");
+  const [session, setSession] = useState(null);
+  const [availability, setAvailability] = useState();
+  const [progress, setProgress] = useState();
+  const [error, setError] = useState();
+  const sessionRef = useRef(null);
+  const createOptionsRef = useRef(createOptions);
+  createOptionsRef.current = createOptions;
+  const destroySession = useCallback(() => {
+    void destroyChromeAITaskSession(sessionRef.current);
+    sessionRef.current = null;
+    setSession(null);
+    setStatus("idle");
+  }, []);
+  const createSession = useCallback(async (overrideOptions) => {
+    const options = overrideOptions ?? createOptionsRef.current;
+    setStatus("checking");
+    setError(void 0);
+    setProgress(void 0);
+    const nextAvailability = await readChromeAITaskAvailability(apiName, options);
+    setAvailability(nextAvailability);
+    setStatus(nextAvailability === "available" ? "ready" : nextAvailability);
+    try {
+      const nextSession = await createChromeAITaskSession(apiName, options, void 0, (nextProgress) => {
+        setProgress(nextProgress);
+        setStatus(nextProgress.completed ? "preparing" : "downloading");
+      });
+      await destroyChromeAITaskSession(sessionRef.current);
+      sessionRef.current = nextSession;
+      setSession(nextSession);
+      setStatus("ready");
+      setAvailability("available");
+      onSession?.(nextSession);
+      return nextSession;
+    } catch (cause) {
+      const nextError = toError(cause);
+      setError(nextError);
+      setStatus(nextError.name === "AbortError" ? "aborted" : "error");
+      throw nextError;
+    }
+  }, [apiName, onSession]);
+  useEffect(() => {
+    if (autoCreate) {
+      void createSession();
+    }
+  }, [autoCreate, createSession]);
+  useEffect(() => {
+    if (!destroyOnUnmount) {
+      return;
+    }
+    return () => {
+      void destroyChromeAITaskSession(sessionRef.current);
+      sessionRef.current = null;
+    };
+  }, [destroyOnUnmount]);
+  return {
+    apiName,
+    supported: isChromeAITaskSupported(apiName),
+    status,
+    session,
+    availability,
+    progress,
+    error,
+    createSession,
+    destroySession
+  };
+}
+function useChromeAITaskOperation({
+  methodName,
+  streaming = false,
+  reuseSession = true,
+  ...sessionOptions
+}) {
+  const task = useChromeAITaskSession(sessionOptions);
+  const [state, setState] = useState({
+    status: "idle",
+    text: "",
+    chunks: []
+  });
+  const run = useCallback(async (...args) => {
+    setState({ status: streaming ? "streaming" : "prompting", text: "", chunks: [] });
+    const activeSession = task.session ?? await task.createSession();
+    try {
+      const method = assertTaskMethod(activeSession, methodName);
+      const result = method(...args);
+      if (streaming) {
+        const chunks = [];
+        for await (const chunk of toAsyncIterable(await result)) {
+          chunks.push(chunk);
+          setState({ status: "streaming", text: chunks.join(""), chunks: [...chunks] });
+        }
+        const text2 = chunks.join("");
+        setState({ status: "ready", result: text2, text: text2, chunks });
+        if (!reuseSession) {
+          task.destroySession();
+        }
+        return text2;
+      }
+      const awaited = await result;
+      const text = typeof awaited === "string" ? awaited : "";
+      setState({ status: "ready", result: awaited, text, chunks: text ? [text] : [] });
+      if (!reuseSession) {
+        task.destroySession();
+      }
+      return awaited;
+    } catch (cause) {
+      const error = toError(cause);
+      setState({ status: error.name === "AbortError" ? "aborted" : "error", text: "", chunks: [], error });
+      throw error;
+    }
+  }, [methodName, reuseSession, streaming, task]);
+  const reset = useCallback(() => {
+    setState({ status: "idle", text: "", chunks: [] });
+  }, []);
+  return {
+    ...task,
+    ...state,
+    run,
+    reset
+  };
+}
+function useChromeAISummarizer(options = {}) {
+  return useChromeAITaskOperation({
+    ...options,
+    apiName: "Summarizer",
+    methodName: options.streaming ? "summarizeStreaming" : "summarize"
+  });
+}
+function useChromeAITranslator(options = {}) {
+  return useChromeAITaskOperation({
+    ...options,
+    apiName: "Translator",
+    methodName: options.streaming ? "translateStreaming" : "translate"
+  });
+}
+function useChromeAILanguageDetector(options = {}) {
+  return useChromeAITaskOperation({
+    ...options,
+    apiName: "LanguageDetector",
+    methodName: "detect"
+  });
+}
+function useChromeAIWriter(options = {}) {
+  return useChromeAITaskOperation({
+    ...options,
+    apiName: "Writer",
+    methodName: options.streaming ? "writeStreaming" : "write"
+  });
+}
+function useChromeAIRewriter(options = {}) {
+  return useChromeAITaskOperation({
+    ...options,
+    apiName: "Rewriter",
+    methodName: options.streaming ? "rewriteStreaming" : "rewrite"
+  });
+}
+function useChromeAIProofreader(options = {}) {
+  return useChromeAITaskOperation({
+    ...options,
+    apiName: "Proofreader",
+    methodName: "proofread"
+  });
+}
+export {
+  ChromeAIError,
+  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
+};