@workglow/ai-provider 0.0.115 → 0.0.117

package/dist/web-browser/common/WebBrowser_ModelSchema.d.ts

@@ -0,0 +1,185 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FromSchema } from "@workglow/util";
+export declare const WebBrowserModelSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly provider: {
+            readonly const: "WEB_BROWSER";
+            readonly description: "Discriminator: Chrome Built-in AI (Gemini Nano).";
+        };
+        readonly provider_config: {
+            readonly type: "object";
+            readonly description: "Chrome Built-in AI configuration.";
+            readonly properties: {
+                readonly summary_type: {
+                    readonly type: "string";
+                    readonly enum: readonly ["tl;dr", "key-points", "teaser", "headline"];
+                    readonly description: "Summarization style (Summarizer API only).";
+                };
+                readonly summary_length: {
+                    readonly type: "string";
+                    readonly enum: readonly ["short", "medium", "long"];
+                    readonly description: "Desired summary length (Summarizer API only).";
+                };
+                readonly summary_format: {
+                    readonly type: "string";
+                    readonly enum: readonly ["plain-text", "markdown"];
+                    readonly description: "Output format for summaries (Summarizer API only).";
+                };
+                readonly rewriter_tone: {
+                    readonly type: "string";
+                    readonly enum: readonly ["as-is", "more-formal", "more-casual"];
+                    readonly description: "Tone for rewriting (Rewriter API only).";
+                };
+                readonly rewriter_length: {
+                    readonly type: "string";
+                    readonly enum: readonly ["as-is", "shorter", "longer"];
+                    readonly description: "Length adjustment for rewriting (Rewriter API only).";
+                };
+            };
+            readonly required: readonly [];
+            readonly additionalProperties: false;
+        };
+    };
+    readonly required: readonly ["provider", "provider_config"];
+    readonly additionalProperties: true;
+};
+export declare const WebBrowserModelRecordSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly provider: {
+            readonly const: "WEB_BROWSER";
+            readonly description: "Discriminator: Chrome Built-in AI (Gemini Nano).";
+        };
+        readonly provider_config: {
+            readonly type: "object";
+            readonly description: "Chrome Built-in AI configuration.";
+            readonly properties: {
+                readonly summary_type: {
+                    readonly type: "string";
+                    readonly enum: readonly ["tl;dr", "key-points", "teaser", "headline"];
+                    readonly description: "Summarization style (Summarizer API only).";
+                };
+                readonly summary_length: {
+                    readonly type: "string";
+                    readonly enum: readonly ["short", "medium", "long"];
+                    readonly description: "Desired summary length (Summarizer API only).";
+                };
+                readonly summary_format: {
+                    readonly type: "string";
+                    readonly enum: readonly ["plain-text", "markdown"];
+                    readonly description: "Output format for summaries (Summarizer API only).";
+                };
+                readonly rewriter_tone: {
+                    readonly type: "string";
+                    readonly enum: readonly ["as-is", "more-formal", "more-casual"];
+                    readonly description: "Tone for rewriting (Rewriter API only).";
+                };
+                readonly rewriter_length: {
+                    readonly type: "string";
+                    readonly enum: readonly ["as-is", "shorter", "longer"];
+                    readonly description: "Length adjustment for rewriting (Rewriter API only).";
+                };
+            };
+            readonly required: readonly [];
+            readonly additionalProperties: false;
+        };
+        readonly model_id: {
+            readonly type: "string";
+        };
+        readonly tasks: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly "x-ui-editor": "multiselect";
+        };
+        readonly title: {
+            readonly type: "string";
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly "x-ui-editor": "textarea";
+        };
+        readonly metadata: {
+            readonly type: "object";
+            readonly default: {};
+            readonly "x-ui-hidden": true;
+        };
+    };
+    readonly required: readonly ["model_id", "tasks", "provider", "title", "description", "provider_config", "metadata", "provider", "provider_config"];
+    readonly additionalProperties: false;
+};
+export type WebBrowserModelRecord = FromSchema<typeof WebBrowserModelRecordSchema>;
+export declare const WebBrowserModelConfigSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly provider: {
+            readonly const: "WEB_BROWSER";
+            readonly description: "Discriminator: Chrome Built-in AI (Gemini Nano).";
+        };
+        readonly provider_config: {
+            readonly type: "object";
+            readonly description: "Chrome Built-in AI configuration.";
+            readonly properties: {
+                readonly summary_type: {
+                    readonly type: "string";
+                    readonly enum: readonly ["tl;dr", "key-points", "teaser", "headline"];
+                    readonly description: "Summarization style (Summarizer API only).";
+                };
+                readonly summary_length: {
+                    readonly type: "string";
+                    readonly enum: readonly ["short", "medium", "long"];
+                    readonly description: "Desired summary length (Summarizer API only).";
+                };
+                readonly summary_format: {
+                    readonly type: "string";
+                    readonly enum: readonly ["plain-text", "markdown"];
+                    readonly description: "Output format for summaries (Summarizer API only).";
+                };
+                readonly rewriter_tone: {
+                    readonly type: "string";
+                    readonly enum: readonly ["as-is", "more-formal", "more-casual"];
+                    readonly description: "Tone for rewriting (Rewriter API only).";
+                };
+                readonly rewriter_length: {
+                    readonly type: "string";
+                    readonly enum: readonly ["as-is", "shorter", "longer"];
+                    readonly description: "Length adjustment for rewriting (Rewriter API only).";
+                };
+            };
+            readonly required: readonly [];
+            readonly additionalProperties: false;
+        };
+        readonly model_id: {
+            readonly type: "string";
+        };
+        readonly tasks: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly "x-ui-editor": "multiselect";
+        };
+        readonly title: {
+            readonly type: "string";
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly "x-ui-editor": "textarea";
+        };
+        readonly metadata: {
+            readonly type: "object";
+            readonly default: {};
+            readonly "x-ui-hidden": true;
+        };
+    };
+    readonly required: readonly ["provider", "provider_config", "provider", "provider_config"];
+    readonly additionalProperties: false;
+};
+export type WebBrowserModelConfig = FromSchema<typeof WebBrowserModelConfigSchema>;
+//# sourceMappingURL=WebBrowser_ModelSchema.d.ts.map

package/dist/web-browser/common/WebBrowser_ModelSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebBrowser_ModelSchema.d.ts","sourceRoot":"","sources":["../../../src/web-browser/common/WebBrowser_ModelSchema.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAwB,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGlE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2CO,CAAC;AAE1C,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQC,CAAC;AAE1C,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEnF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQC,CAAC;AAE1C,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/web-browser/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./common/WebBrowser_Constants";
+export * from "./common/WebBrowser_JobRunFns";
+export * from "./common/WebBrowser_ModelSchema";
+export * from "./WebBrowserProvider";
+export * from "./WebBrowser_Worker";
+//# sourceMappingURL=index.d.ts.map

package/dist/web-browser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/web-browser/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iCAAiC,CAAC;AAChD,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC"}

package/dist/web-browser/index.js

@@ -0,0 +1,457 @@
+import"../index.browser-6j5pq722.js";
+
+// src/web-browser/common/WebBrowser_Constants.ts
+var WEB_BROWSER = "WEB_BROWSER";
+var WebBrowserPipelineTask = {
+  summarizer: "summarizer",
+  "language-detector": "language-detector",
+  translator: "translator",
+  prompt: "prompt",
+  rewriter: "rewriter"
+};
+// src/web-browser/common/WebBrowser_JobRunFns.ts
+import { PermanentJobError } from "@workglow/job-queue";
+import { getLogger } from "@workglow/util";
+function getConfig(model) {
+  return model?.provider_config ?? {};
+}
+function getApi(name, global) {
+  if (!global) {
+    throw new PermanentJobError(`Chrome Built-in AI "${name}" API is not available in this browser.`);
+  }
+  return global;
+}
+async function ensureAvailable(name, factory) {
+  const status = await factory.availability();
+  if (status === "unavailable") {
+    throw new PermanentJobError(`Chrome Built-in AI "${name}" is not available (status: "no"). ` + `Ensure you are using a compatible Chrome version with the flag enabled.`);
+  }
+}
+async function* snapshotStreamToTextDeltas(stream, port, buildFallbackOutput) {
+  const reader = stream.getReader();
+  let previousSnapshot = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      if (value.startsWith(previousSnapshot)) {
+        const delta = value.slice(previousSnapshot.length);
+        previousSnapshot = value;
+        if (delta) {
+          yield { type: "text-delta", port, textDelta: delta };
+        }
+      } else {
+        previousSnapshot = value;
+        yield { type: "snapshot", data: buildFallbackOutput(value) };
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  yield { type: "finish", data: {} };
+}
+async function* snapshotStreamToSnapshots(stream, buildOutput) {
+  const reader = stream.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      yield { type: "snapshot", data: buildOutput(value) };
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  yield { type: "finish", data: {} };
+}
+var WebBrowser_TextSummary = async (input, model, update_progress, signal) => {
+  const factory = getApi("Summarizer", globalThis?.ai?.summarizer ?? (typeof Summarizer !== "undefined" ? Summarizer : undefined));
+  await ensureAvailable("Summarizer", factory);
+  const config = getConfig(model);
+  if (Array.isArray(input.text)) {
+    getLogger().warn("WebBrowser_TextSummary: array input received; processing sequentially");
+    const results = [];
+    for (const item of input.text) {
+      const summarizer2 = await factory.create({
+        type: config.summary_type,
+        length: config.summary_length,
+        format: config.summary_format
+      });
+      try {
+        results.push(await summarizer2.summarize(item, { signal }));
+      } finally {
+        summarizer2.destroy();
+      }
+    }
+    update_progress(100, "Completed text summarization");
+    return { text: results };
+  }
+  const summarizer = await factory.create({
+    type: config.summary_type,
+    length: config.summary_length,
+    format: config.summary_format
+  });
+  try {
+    const text = await summarizer.summarize(input.text, { signal });
+    update_progress(100, "Completed text summarization");
+    return { text };
+  } finally {
+    summarizer.destroy();
+  }
+};
+var WebBrowser_TextLanguageDetection = async (input, model, update_progress, signal) => {
+  const factory = getApi("LanguageDetector", typeof LanguageDetector !== "undefined" ? LanguageDetector : undefined);
+  await ensureAvailable("LanguageDetector", factory);
+  if (Array.isArray(input.text)) {
+    getLogger().warn("WebBrowser_TextLanguageDetection: array input received; processing sequentially");
+    const allResults = [];
+    for (const item of input.text) {
+      const detector2 = await factory.create();
+      try {
+        const detected = await detector2.detect(item, { signal });
+        const mapped = detected.map((d) => ({ language: d.detectedLanguage, score: d.confidence })).slice(0, input.maxLanguages ?? 5);
+        allResults.push(mapped);
+      } finally {
+        detector2.destroy();
+      }
+    }
+    update_progress(100, "Completed language detection");
+    return { languages: allResults };
+  }
+  const detector = await factory.create();
+  try {
+    const detected = await detector.detect(input.text, { signal });
+    const languages = detected.map((d) => ({ language: d.detectedLanguage, score: d.confidence })).slice(0, input.maxLanguages ?? 5);
+    update_progress(100, "Completed language detection");
+    return { languages };
+  } finally {
+    detector.destroy();
+  }
+};
+var WebBrowser_TextTranslation = async (input, model, update_progress, signal) => {
+  const factory = getApi("Translator", typeof Translator !== "undefined" ? Translator : undefined);
+  await ensureAvailable("Translator", factory);
+  const translationAvailability = await factory.availability({
+    sourceLanguage: input.source_lang,
+    targetLanguage: input.target_lang
+  });
+  if (!translationAvailability || translationAvailability === "unavailable") {
+    throw new PermanentJobError(`Translator not available for language pair ${String(input.source_lang)} -> ${String(input.target_lang)}`);
+  }
+  if (Array.isArray(input.text)) {
+    getLogger().warn("WebBrowser_TextTranslation: array input received; processing sequentially");
+    const results = [];
+    for (const item of input.text) {
+      const translator2 = await factory.create({
+        sourceLanguage: input.source_lang,
+        targetLanguage: input.target_lang
+      });
+      try {
+        results.push(await translator2.translate(item, { signal }));
+      } finally {
+        translator2.destroy();
+      }
+    }
+    update_progress(100, "Completed text translation");
+    return { text: results, target_lang: input.target_lang };
+  }
+  const translator = await factory.create({
+    sourceLanguage: input.source_lang,
+    targetLanguage: input.target_lang
+  });
+  try {
+    const text = await translator.translate(input.text, { signal });
+    update_progress(100, "Completed text translation");
+    return { text, target_lang: input.target_lang };
+  } finally {
+    translator.destroy();
+  }
+};
+var WebBrowser_TextGeneration = async (input, model, update_progress, signal) => {
+  const factory = getApi("LanguageModel", typeof LanguageModel !== "undefined" ? LanguageModel : undefined);
+  await ensureAvailable("LanguageModel", factory);
+  if (Array.isArray(input.prompt)) {
+    getLogger().warn("WebBrowser_TextGeneration: array input received; processing sequentially");
+    const results = [];
+    for (const item of input.prompt) {
+      const session2 = await factory.create({
+        temperature: input.temperature ?? undefined
+      });
+      try {
+        results.push(await session2.prompt(item, { signal }));
+      } finally {
+        session2.destroy();
+      }
+    }
+    update_progress(100, "Completed text generation");
+    return { text: results };
+  }
+  const session = await factory.create({
+    temperature: input.temperature ?? undefined
+  });
+  try {
+    const text = await session.prompt(input.prompt, { signal });
+    update_progress(100, "Completed text generation");
+    return { text };
+  } finally {
+    session.destroy();
+  }
+};
+var WebBrowser_TextRewriter = async (input, model, update_progress, signal) => {
+  const factory = getApi("Rewriter", typeof Rewriter !== "undefined" ? Rewriter : undefined);
+  await ensureAvailable("Rewriter", factory);
+  const config = getConfig(model);
+  if (Array.isArray(input.text)) {
+    getLogger().warn("WebBrowser_TextRewriter: array input received; processing sequentially");
+    const results = [];
+    for (const item of input.text) {
+      const rewriter2 = await factory.create({
+        tone: config.rewriter_tone,
+        length: config.rewriter_length
+      });
+      try {
+        results.push(await rewriter2.rewrite(item, {
+          signal,
+          context: input.prompt
+        }));
+      } finally {
+        rewriter2.destroy();
+      }
+    }
+    update_progress(100, "Completed text rewriting");
+    return { text: results };
+  }
+  const rewriter = await factory.create({
+    tone: config.rewriter_tone,
+    length: config.rewriter_length
+  });
+  try {
+    const text = await rewriter.rewrite(input.text, {
+      signal,
+      context: input.prompt
+    });
+    update_progress(100, "Completed text rewriting");
+    return { text };
+  } finally {
+    rewriter.destroy();
+  }
+};
+var WebBrowser_ModelInfo = async (input) => {
+  return {
+    model: input.model,
+    is_local: true,
+    is_remote: false,
+    supports_browser: true,
+    supports_node: false,
+    is_cached: false,
+    is_loaded: false,
+    file_sizes: null
+  };
+};
+var WebBrowser_TextSummary_Stream = async function* (input, model, signal) {
+  const factory = getApi("Summarizer", typeof Summarizer !== "undefined" ? Summarizer : undefined);
+  await ensureAvailable("Summarizer", factory);
+  const config = getConfig(model);
+  const summarizer = await factory.create({
+    type: config.summary_type,
+    length: config.summary_length,
+    format: config.summary_format
+  });
+  try {
+    const stream = summarizer.summarizeStreaming(input.text, { signal });
+    yield* snapshotStreamToTextDeltas(stream, "text", (text) => ({ text }));
+  } finally {
+    summarizer.destroy();
+  }
+};
+var WebBrowser_TextTranslation_Stream = async function* (input, model, signal) {
+  const factory = getApi("Translator", typeof Translator !== "undefined" ? Translator : undefined);
+  let status;
+  try {
+    status = await factory.availability({
+      sourceLanguage: input.source_lang,
+      targetLanguage: input.target_lang
+    });
+  } catch (error) {
+    throw new PermanentJobError(`Chrome Built-in AI "Translator" is not available (status: "no"). ` + `Ensure you are using a compatible Chrome version with the flag enabled.`);
+  }
+  if (status === "unavailable") {
+    throw new PermanentJobError(`Chrome Built-in AI "Translator" is not available (status: "no"). ` + `Ensure you are using a compatible Chrome version with the flag enabled.`);
+  }
+  const translator = await factory.create({
+    sourceLanguage: input.source_lang,
+    targetLanguage: input.target_lang
+  });
+  try {
+    const stream = translator.translateStreaming(input.text, { signal });
+    yield* snapshotStreamToSnapshots(stream, (text) => ({
+      text,
+      target_lang: input.target_lang
+    }));
+  } finally {
+    translator.destroy();
+  }
+};
+var WebBrowser_TextGeneration_Stream = async function* (input, model, signal) {
+  const factory = getApi("LanguageModel", typeof LanguageModel !== "undefined" ? LanguageModel : undefined);
+  await ensureAvailable("LanguageModel", factory);
+  const session = await factory.create({
+    temperature: input.temperature ?? undefined
+  });
+  try {
+    const stream = session.promptStreaming(input.prompt, { signal });
+    yield* snapshotStreamToTextDeltas(stream, "text", (text) => ({
+      text
+    }));
+  } finally {
+    session.destroy();
+  }
+};
+var WebBrowser_TextRewriter_Stream = async function* (input, model, signal) {
+  const factory = getApi("Rewriter", typeof Rewriter !== "undefined" ? Rewriter : undefined);
+  await ensureAvailable("Rewriter", factory);
+  const config = getConfig(model);
+  const rewriter = await factory.create({
+    tone: config.rewriter_tone,
+    length: config.rewriter_length
+  });
+  try {
+    const stream = rewriter.rewriteStreaming(input.text, {
+      signal,
+      context: input.prompt
+    });
+    yield* snapshotStreamToTextDeltas(stream, "text", (text) => ({ text }));
+  } finally {
+    rewriter.destroy();
+  }
+};
+var WEB_BROWSER_TASKS = {
+  ModelInfoTask: WebBrowser_ModelInfo,
+  TextSummaryTask: WebBrowser_TextSummary,
+  TextLanguageDetectionTask: WebBrowser_TextLanguageDetection,
+  TextTranslationTask: WebBrowser_TextTranslation,
+  TextGenerationTask: WebBrowser_TextGeneration,
+  TextRewriterTask: WebBrowser_TextRewriter
+};
+var WEB_BROWSER_STREAM_TASKS = {
+  TextSummaryTask: WebBrowser_TextSummary_Stream,
+  TextTranslationTask: WebBrowser_TextTranslation_Stream,
+  TextGenerationTask: WebBrowser_TextGeneration_Stream,
+  TextRewriterTask: WebBrowser_TextRewriter_Stream
+};
+// src/web-browser/common/WebBrowser_ModelSchema.ts
+import { ModelConfigSchema, ModelRecordSchema } from "@workglow/ai";
+var WebBrowserModelSchema = {
+  type: "object",
+  properties: {
+    provider: {
+      const: WEB_BROWSER,
+      description: "Discriminator: Chrome Built-in AI (Gemini Nano)."
+    },
+    provider_config: {
+      type: "object",
+      description: "Chrome Built-in AI configuration.",
+      properties: {
+        summary_type: {
+          type: "string",
+          enum: ["tl;dr", "key-points", "teaser", "headline"],
+          description: "Summarization style (Summarizer API only)."
+        },
+        summary_length: {
+          type: "string",
+          enum: ["short", "medium", "long"],
+          description: "Desired summary length (Summarizer API only)."
+        },
+        summary_format: {
+          type: "string",
+          enum: ["plain-text", "markdown"],
+          description: "Output format for summaries (Summarizer API only)."
+        },
+        rewriter_tone: {
+          type: "string",
+          enum: ["as-is", "more-formal", "more-casual"],
+          description: "Tone for rewriting (Rewriter API only)."
+        },
+        rewriter_length: {
+          type: "string",
+          enum: ["as-is", "shorter", "longer"],
+          description: "Length adjustment for rewriting (Rewriter API only)."
+        }
+      },
+      required: [],
+      additionalProperties: false
+    }
+  },
+  required: ["provider", "provider_config"],
+  additionalProperties: true
+};
+var WebBrowserModelRecordSchema = {
+  type: "object",
+  properties: {
+    ...ModelRecordSchema.properties,
+    ...WebBrowserModelSchema.properties
+  },
+  required: [...ModelRecordSchema.required, ...WebBrowserModelSchema.required],
+  additionalProperties: false
+};
+var WebBrowserModelConfigSchema = {
+  type: "object",
+  properties: {
+    ...ModelConfigSchema.properties,
+    ...WebBrowserModelSchema.properties
+  },
+  required: [...ModelConfigSchema.required, ...WebBrowserModelSchema.required],
+  additionalProperties: false
+};
+// src/web-browser/WebBrowserProvider.ts
+import {
+  AiProvider
+} from "@workglow/ai";
+class WebBrowserProvider extends AiProvider {
+  name = WEB_BROWSER;
+  isLocal = true;
+  supportsBrowser = true;
+  taskTypes = [
+    "ModelInfoTask",
+    "TextSummaryTask",
+    "TextLanguageDetectionTask",
+    "TextTranslationTask",
+    "TextGenerationTask",
+    "TextRewriterTask"
+  ];
+  constructor(tasks, streamTasks, reactiveTasks) {
+    super(tasks, streamTasks, reactiveTasks);
+  }
+}
+// src/web-browser/WebBrowser_Worker.ts
+import { getLogger as getLogger2, globalServiceRegistry, WORKER_SERVER } from "@workglow/util";
+function WEB_BROWSER_WORKER_JOBRUN_REGISTER() {
+  const workerServer = globalServiceRegistry.get(WORKER_SERVER);
+  new WebBrowserProvider(WEB_BROWSER_TASKS, WEB_BROWSER_STREAM_TASKS).registerOnWorkerServer(workerServer);
+  workerServer.sendReady();
+  getLogger2().info("WEB_BROWSER_WORKER_JOBRUN registered");
+}
+export {
+  WebBrowser_TextTranslation_Stream,
+  WebBrowser_TextTranslation,
+  WebBrowser_TextSummary_Stream,
+  WebBrowser_TextSummary,
+  WebBrowser_TextRewriter_Stream,
+  WebBrowser_TextRewriter,
+  WebBrowser_TextLanguageDetection,
+  WebBrowser_TextGeneration_Stream,
+  WebBrowser_TextGeneration,
+  WebBrowser_ModelInfo,
+  WebBrowserProvider,
+  WebBrowserPipelineTask,
+  WebBrowserModelSchema,
+  WebBrowserModelRecordSchema,
+  WebBrowserModelConfigSchema,
+  WEB_BROWSER_WORKER_JOBRUN_REGISTER,
+  WEB_BROWSER_TASKS,
+  WEB_BROWSER_STREAM_TASKS,
+  WEB_BROWSER
+};
+
+//# debugId=2D3A8A06C95D0C3D64756E2164756E21