@dbx-tools/appkit-generator 0.0.0-stage → 0.9.138

package/lib/src/plugin.js

@@ -0,0 +1,205 @@
+/**
+ * AppKit ToolProvider plugin for governed Databricks demo generation.
+ *
+ * @module
+ */
+import { defineManifest, toPlugin } from "@databricks/appkit";
+import { defineTool } from "@databricks/appkit/beta";
+import { pluginRegistry, ToolRegistryPlugin } from "@dbx-tools/appkit";
+import { mastra } from "@dbx-tools/appkit-mastra";
+import { webSearch } from "@dbx-tools/appkit-web-search";
+import { errorUtils, log } from "@dbx-tools/shared-core";
+import { GENERATOR_ROUTES, GeneratorClientConfigSchema, GeneratorPluginClient, BrandGenerationEventSchema, BrandGenerationRequestSchema, } from "@dbx-tools/shared-generator/brand";
+import { KpiResearchRequestSchema, KpiResearchResultSchema } from "@dbx-tools/shared-generator/kpi";
+import { CreateGeneratorPresentationRequestSchema, GeneratedAssetsSchema, GeneratedDashboardSchema, GeneratedGenieSpaceSchema, GeneratedSchemaSchema, GeneratorPlanSchema, MaterializeGeneratorDataRequestSchema, MaterializedGeneratorDataSchema, PlanGeneratorDataRequestSchema, ProvisionGeneratorSchemaRequestSchema, } from "@dbx-tools/shared-generator/workflow";
+import { resolveGeneratorConfig, } from "./config.js";
+import manifest from "./manifest.json" with { type: "json" };
+import { GeneratorOperations } from "./operations.js";
+import { GENERATE_BRAND_TOOL_DESCRIPTION } from "./schema.js";
+import { createGeneratorWorkflow } from "./workflow.js";
+const logger = log.logger("generator");
+const WORKFLOW_KEY = "generatorDemoAssets";
+/** AppKit plugin exposing reusable generator tools and a hosted Mastra workflow. */
+export class GeneratorPlugin extends ToolRegistryPlugin {
+    static manifest = defineManifest(manifest);
+    resolved = resolveGeneratorConfig(this.config);
+    operations;
+    workflow;
+    /** AppKit mount prefix used by browser clients. */
+    get basePath() {
+        return `/api/${this.name}`;
+    }
+    /** Native tools exposed independently of the composed workflow. */
+    get toolRegistry() {
+        const operations = this.requireOperations();
+        const mutation = { effect: "write", destructive: true, requiresUserContext: true };
+        return {
+            generate_brand: defineTool({
+                description: GENERATE_BRAND_TOOL_DESCRIPTION,
+                schema: BrandGenerationRequestSchema,
+                annotations: { effect: "read", requiresUserContext: true },
+                autoInheritable: false,
+                execute: (input, signal) => operations.generateBrand(BrandGenerationRequestSchema.parse(input), signal),
+            }),
+            research_kpis: defineTool({
+                description: "Research evidence-backed KPIs for company demo questions.",
+                schema: KpiResearchRequestSchema,
+                annotations: { effect: "read", requiresUserContext: true },
+                autoInheritable: false,
+                execute: (input, signal) => operations.researchKpis(KpiResearchRequestSchema.parse(input), signal),
+            }),
+            plan_demo_data: defineTool({
+                description: "Build a typed deterministic data plan from brand and KPI research.",
+                schema: PlanGeneratorDataRequestSchema,
+                annotations: { effect: "read", requiresUserContext: true },
+                autoInheritable: false,
+                execute: (input, signal) => operations.planData(PlanGeneratorDataRequestSchema.parse(input), signal),
+            }),
+            provision_schema: defineTool({
+                description: "Provision and grant the active user's deterministic Unity Catalog schema.",
+                schema: ProvisionGeneratorSchemaRequestSchema,
+                annotations: mutation,
+                autoInheritable: false,
+                execute: (input, signal) => operations.provisionSchema(ProvisionGeneratorSchemaRequestSchema.parse(input), signal),
+            }),
+            materialize_data: defineTool({
+                description: "Create generated Delta data and validate every planned KPI.",
+                schema: MaterializeGeneratorDataRequestSchema,
+                annotations: mutation,
+                autoInheritable: false,
+                execute: (input, signal) => operations.materializeData(MaterializeGeneratorDataRequestSchema.parse(input), signal),
+            }),
+            create_dashboard: defineTool({
+                description: "Create and publish an AI/BI dashboard with automatic companion Genie.",
+                schema: CreateGeneratorPresentationRequestSchema,
+                annotations: mutation,
+                autoInheritable: false,
+                execute: (input, signal) => operations.createDashboard(CreateGeneratorPresentationRequestSchema.parse(input), signal),
+            }),
+            create_genie_space: defineTool({
+                description: "Create a standalone Genie space when no dashboard is requested.",
+                schema: CreateGeneratorPresentationRequestSchema,
+                annotations: mutation,
+                autoInheritable: false,
+                execute: (input, signal) => operations.createGenie(CreateGeneratorPresentationRequestSchema.parse(input), signal),
+            }),
+        };
+    }
+    /** Capture sibling capabilities and register the workflow before Mastra boots. */
+    async setup() {
+        this.operations = new GeneratorOperations({
+            config: this.resolved,
+            researchClient: this.researchClient(),
+        });
+        this.workflow = createGeneratorWorkflow(this.operations);
+        pluginRegistry
+            .require(this.context, mastra, this)
+            .exports()
+            .registerWorkflow(WORKFLOW_KEY, this.workflow);
+        logger.info("ready", {
+            model: this.resolved.model ?? "automatic",
+            catalog: this.resolved.catalog ?? "brand-only",
+            warehouse: this.resolved.warehouseId ?? "brand-only",
+            workflow: WORKFLOW_KEY,
+        });
+    }
+    shutdown() {
+        return;
+    }
+    clientConfig() {
+        return GeneratorClientConfigSchema.parse({ basePath: this.basePath });
+    }
+    /** Stream standalone brand generation to the existing Brand page. */
+    injectRoutes(router) {
+        this.route(router, {
+            name: "generateBrand",
+            method: "post",
+            path: GENERATOR_ROUTES.generateBrand,
+            handler: async (req, res) => {
+                const parsed = BrandGenerationRequestSchema.safeParse(req.body);
+                if (!parsed.success) {
+                    res.status(400).json({ error: "Enter a brand name and an optional HTTPS website." });
+                    return;
+                }
+                res.set({
+                    "Cache-Control": "no-cache, no-transform",
+                    Connection: "keep-alive",
+                    "Content-Type": "text/event-stream",
+                    "X-Accel-Buffering": "no",
+                });
+                res.flushHeaders();
+                let closed = false;
+                const controller = new AbortController();
+                res.on("close", () => {
+                    closed = true;
+                    controller.abort();
+                });
+                const send = (event) => {
+                    if (closed)
+                        return;
+                    const validated = BrandGenerationEventSchema.parse(event);
+                    res.write(`event: ${validated.type}\ndata: ${JSON.stringify(validated)}\n\n`);
+                };
+                try {
+                    const generated = await this.asUser(req)
+                        .requireOperations()
+                        .generateBrand(parsed.data, controller.signal, send);
+                    send({ type: "result", package: generated });
+                }
+                catch (cause) {
+                    logger.warn("brand-route-failed", { error: errorUtils.toError(cause) });
+                    send({
+                        type: "error",
+                        message: "Brand generation failed. Retry the request; if it fails again, check the server logs.",
+                    });
+                }
+                finally {
+                    if (!closed)
+                        res.end();
+                }
+            },
+        });
+    }
+    /** Programmatic operations and workflow for trusted application code. */
+    exports() {
+        return {
+            generateBrand: this.requireOperations().generateBrand.bind(this.requireOperations()),
+            researchKpis: this.requireOperations().researchKpis.bind(this.requireOperations()),
+            planData: this.requireOperations().planData.bind(this.requireOperations()),
+            provisionSchema: this.requireOperations().provisionSchema.bind(this.requireOperations()),
+            materializeData: this.requireOperations().materializeData.bind(this.requireOperations()),
+            createDashboard: this.requireOperations().createDashboard.bind(this.requireOperations()),
+            createGenie: this.requireOperations().createGenie.bind(this.requireOperations()),
+            workflow: this.workflow,
+            schemas: {
+                kpiResearch: KpiResearchResultSchema,
+                plan: GeneratorPlanSchema,
+                location: GeneratedSchemaSchema,
+                materialized: MaterializedGeneratorDataSchema,
+                dashboard: GeneratedDashboardSchema,
+                genie: GeneratedGenieSpaceSchema,
+                assets: GeneratedAssetsSchema,
+            },
+            client: GeneratorPluginClient,
+        };
+    }
+    /** Resolve the sibling web-search plugin without recreating its policy. */
+    researchClient() {
+        const sibling = pluginRegistry.require(this.context, webSearch, this).exports();
+        return {
+            search: sibling.search,
+            fetch: sibling.fetch,
+            fetchAssetPage: sibling.fetchAssetPage,
+            fetchImage: sibling.fetchImage,
+        };
+    }
+    /** Initialized operations or a clear lifecycle error. */
+    requireOperations() {
+        if (!this.operations)
+            throw new Error("Generator plugin setup has not completed");
+        return this.operations;
+    }
+}
+/** Register AppKit generator tools and workflow integration. */
+export const generator = toPlugin(GeneratorPlugin);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AppKit ToolProvider plugin for governed Databricks demo generation.\n *\n * @module\n */\n\nimport { defineManifest, toPlugin, type IAppRouter } from \"@databricks/appkit\";\nimport { defineTool, type ToolRegistry } from \"@databricks/appkit/beta\";\nimport { pluginRegistry, ToolRegistryPlugin } from \"@dbx-tools/appkit\";\nimport { mastra } from \"@dbx-tools/appkit-mastra\";\nimport { webSearch } from \"@dbx-tools/appkit-web-search\";\nimport { errorUtils, log } from \"@dbx-tools/shared-core\";\nimport {\n  GENERATOR_ROUTES,\n  GeneratorClientConfigSchema,\n  GeneratorPluginClient,\n  BrandGenerationEventSchema,\n  BrandGenerationRequestSchema,\n  type BrandGenerationEvent,\n} from \"@dbx-tools/shared-generator/brand\";\nimport { KpiResearchRequestSchema, KpiResearchResultSchema } from \"@dbx-tools/shared-generator/kpi\";\nimport {\n  CreateGeneratorPresentationRequestSchema,\n  GeneratedAssetsSchema,\n  GeneratedDashboardSchema,\n  GeneratedGenieSpaceSchema,\n  GeneratedSchemaSchema,\n  GeneratorPlanSchema,\n  MaterializeGeneratorDataRequestSchema,\n  MaterializedGeneratorDataSchema,\n  PlanGeneratorDataRequestSchema,\n  ProvisionGeneratorSchemaRequestSchema,\n} from \"@dbx-tools/shared-generator/workflow\";\nimport {\n  resolveGeneratorConfig,\n  type GeneratorPluginConfig,\n  type ResolvedGeneratorConfig,\n} from \"./config.ts\";\nimport manifest from \"./manifest.json\" with { type: \"json\" };\nimport { GeneratorOperations } from \"./operations.ts\";\nimport type { BrandResearchClient } from \"./research.ts\";\nimport { GENERATE_BRAND_TOOL_DESCRIPTION } from \"./schema.ts\";\nimport { createGeneratorWorkflow, type GeneratorWorkflow } from \"./workflow.ts\";\n\nconst logger = log.logger(\"generator\");\nconst WORKFLOW_KEY = \"generatorDemoAssets\";\n\n/** AppKit plugin exposing reusable generator tools and a hosted Mastra workflow. */\nexport class GeneratorPlugin extends ToolRegistryPlugin<GeneratorPluginConfig> {\n  static manifest = defineManifest<\"generator\">(manifest);\n\n  private readonly resolved: ResolvedGeneratorConfig = resolveGeneratorConfig(this.config);\n  private operations: GeneratorOperations | undefined;\n  private workflow: GeneratorWorkflow | undefined;\n\n  /** AppKit mount prefix used by browser clients. */\n  private get basePath(): string {\n    return `/api/${this.name}`;\n  }\n\n  /** Native tools exposed independently of the composed workflow. */\n  protected get toolRegistry(): ToolRegistry {\n    const operations = this.requireOperations();\n    const mutation = { effect: \"write\" as const, destructive: true, requiresUserContext: true };\n    return {\n      generate_brand: defineTool({\n        description: GENERATE_BRAND_TOOL_DESCRIPTION,\n        schema: BrandGenerationRequestSchema,\n        annotations: { effect: \"read\", requiresUserContext: true },\n        autoInheritable: false,\n        execute: (input, signal) =>\n          operations.generateBrand(BrandGenerationRequestSchema.parse(input), signal),\n      }),\n      research_kpis: defineTool({\n        description: \"Research evidence-backed KPIs for company demo questions.\",\n        schema: KpiResearchRequestSchema,\n        annotations: { effect: \"read\", requiresUserContext: true },\n        autoInheritable: false,\n        execute: (input, signal) =>\n          operations.researchKpis(KpiResearchRequestSchema.parse(input), signal),\n      }),\n      plan_demo_data: defineTool({\n        description: \"Build a typed deterministic data plan from brand and KPI research.\",\n        schema: PlanGeneratorDataRequestSchema,\n        annotations: { effect: \"read\", requiresUserContext: true },\n        autoInheritable: false,\n        execute: (input, signal) =>\n          operations.planData(PlanGeneratorDataRequestSchema.parse(input), signal),\n      }),\n      provision_schema: defineTool({\n        description: \"Provision and grant the active user's deterministic Unity Catalog schema.\",\n        schema: ProvisionGeneratorSchemaRequestSchema,\n        annotations: mutation,\n        autoInheritable: false,\n        execute: (input, signal) =>\n          operations.provisionSchema(ProvisionGeneratorSchemaRequestSchema.parse(input), signal),\n      }),\n      materialize_data: defineTool({\n        description: \"Create generated Delta data and validate every planned KPI.\",\n        schema: MaterializeGeneratorDataRequestSchema,\n        annotations: mutation,\n        autoInheritable: false,\n        execute: (input, signal) =>\n          operations.materializeData(MaterializeGeneratorDataRequestSchema.parse(input), signal),\n      }),\n      create_dashboard: defineTool({\n        description: \"Create and publish an AI/BI dashboard with automatic companion Genie.\",\n        schema: CreateGeneratorPresentationRequestSchema,\n        annotations: mutation,\n        autoInheritable: false,\n        execute: (input, signal) =>\n          operations.createDashboard(CreateGeneratorPresentationRequestSchema.parse(input), signal),\n      }),\n      create_genie_space: defineTool({\n        description: \"Create a standalone Genie space when no dashboard is requested.\",\n        schema: CreateGeneratorPresentationRequestSchema,\n        annotations: mutation,\n        autoInheritable: false,\n        execute: (input, signal) =>\n          operations.createGenie(CreateGeneratorPresentationRequestSchema.parse(input), signal),\n      }),\n    };\n  }\n\n  /** Capture sibling capabilities and register the workflow before Mastra boots. */\n  override async setup(): Promise<void> {\n    this.operations = new GeneratorOperations({\n      config: this.resolved,\n      researchClient: this.researchClient(),\n    });\n    this.workflow = createGeneratorWorkflow(this.operations);\n    pluginRegistry\n      .require(this.context, mastra, this)\n      .exports()\n      .registerWorkflow(WORKFLOW_KEY, this.workflow);\n    logger.info(\"ready\", {\n      model: this.resolved.model ?? \"automatic\",\n      catalog: this.resolved.catalog ?? \"brand-only\",\n      warehouse: this.resolved.warehouseId ?? \"brand-only\",\n      workflow: WORKFLOW_KEY,\n    });\n  }\n\n  shutdown(): void {\n    return;\n  }\n\n  override clientConfig() {\n    return GeneratorClientConfigSchema.parse({ basePath: this.basePath });\n  }\n\n  /** Stream standalone brand generation to the existing Brand page. */\n  override injectRoutes(router: IAppRouter): void {\n    this.route(router, {\n      name: \"generateBrand\",\n      method: \"post\",\n      path: GENERATOR_ROUTES.generateBrand,\n      handler: async (req, res) => {\n        const parsed = BrandGenerationRequestSchema.safeParse(req.body);\n        if (!parsed.success) {\n          res.status(400).json({ error: \"Enter a brand name and an optional HTTPS website.\" });\n          return;\n        }\n        res.set({\n          \"Cache-Control\": \"no-cache, no-transform\",\n          Connection: \"keep-alive\",\n          \"Content-Type\": \"text/event-stream\",\n          \"X-Accel-Buffering\": \"no\",\n        });\n        res.flushHeaders();\n        let closed = false;\n        const controller = new AbortController();\n        res.on(\"close\", () => {\n          closed = true;\n          controller.abort();\n        });\n        const send = (event: BrandGenerationEvent) => {\n          if (closed) return;\n          const validated = BrandGenerationEventSchema.parse(event);\n          res.write(`event: ${validated.type}\\ndata: ${JSON.stringify(validated)}\\n\\n`);\n        };\n        try {\n          const generated = await this.asUser(req)\n            .requireOperations()\n            .generateBrand(parsed.data, controller.signal, send);\n          send({ type: \"result\", package: generated });\n        } catch (cause) {\n          logger.warn(\"brand-route-failed\", { error: errorUtils.toError(cause) });\n          send({\n            type: \"error\",\n            message:\n              \"Brand generation failed. Retry the request; if it fails again, check the server logs.\",\n          });\n        } finally {\n          if (!closed) res.end();\n        }\n      },\n    });\n  }\n\n  /** Programmatic operations and workflow for trusted application code. */\n  override exports() {\n    return {\n      generateBrand: this.requireOperations().generateBrand.bind(this.requireOperations()),\n      researchKpis: this.requireOperations().researchKpis.bind(this.requireOperations()),\n      planData: this.requireOperations().planData.bind(this.requireOperations()),\n      provisionSchema: this.requireOperations().provisionSchema.bind(this.requireOperations()),\n      materializeData: this.requireOperations().materializeData.bind(this.requireOperations()),\n      createDashboard: this.requireOperations().createDashboard.bind(this.requireOperations()),\n      createGenie: this.requireOperations().createGenie.bind(this.requireOperations()),\n      workflow: this.workflow,\n      schemas: {\n        kpiResearch: KpiResearchResultSchema,\n        plan: GeneratorPlanSchema,\n        location: GeneratedSchemaSchema,\n        materialized: MaterializedGeneratorDataSchema,\n        dashboard: GeneratedDashboardSchema,\n        genie: GeneratedGenieSpaceSchema,\n        assets: GeneratedAssetsSchema,\n      },\n      client: GeneratorPluginClient,\n    };\n  }\n\n  /** Resolve the sibling web-search plugin without recreating its policy. */\n  private researchClient(): BrandResearchClient {\n    const sibling = pluginRegistry.require(this.context, webSearch, this).exports();\n    return {\n      search: sibling.search,\n      fetch: sibling.fetch,\n      fetchAssetPage: sibling.fetchAssetPage,\n      fetchImage: sibling.fetchImage,\n    };\n  }\n\n  /** Initialized operations or a clear lifecycle error. */\n  private requireOperations(): GeneratorOperations {\n    if (!this.operations) throw new Error(\"Generator plugin setup has not completed\");\n    return this.operations;\n  }\n}\n\n/** Register AppKit generator tools and workflow integration. */\nexport const generator = toPlugin(GeneratorPlugin);\n"]}

package/lib/src/research.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Brand research composed from the web-search plugin's search and fetch
+ * operations.
+ *
+ * @module
+ */
+import type { WebAssetPageFetchRequest, WebImageFetchRequest, WebImageFetchResult } from "@dbx-tools/appkit-web-search/fetch";
+import type { WebFetchRequest, WebFetchResult, WebSearchRequest, WebSearchResult } from "@dbx-tools/appkit-web-search/schema";
+import { type BrandGenerationProgressEvent, type BrandGenerationRequest, type BrandPackageSource, type BrandVisualReference } from "./schema.ts";
+/** Default number of cited pages fetched for one brand. */
+export declare const DEFAULT_MAX_SOURCES = 4;
+/** Default character cap for each fetched page excerpt. */
+export declare const DEFAULT_SOURCE_MAX_LENGTH = 8000;
+/** Upper bound that prevents one request from fanning out across too many sites. */
+export declare const MAX_SOURCES = 8;
+/** Upper bound on readable characters retained from one fetched page. */
+export declare const MAX_SOURCE_MAX_LENGTH = 20000;
+/** Markup cap used for official and mobile page asset discovery. */
+export declare const ASSET_HTML_MAX_LENGTH = 1500000;
+/** Search and fetch operations supplied by the registered web-search plugin. */
+export interface BrandResearchClient {
+    /** Search the web and return a synthesized answer with citations. */
+    search(request: WebSearchRequest, signal?: AbortSignal): Promise<WebSearchResult>;
+    /** Fetch one cited page as text or HTML. */
+    fetch(request: WebFetchRequest, signal?: AbortSignal): Promise<WebFetchResult>;
+    /** Fetch expanded markup for deterministic in-process asset discovery. */
+    fetchAssetPage?(request: WebAssetPageFetchRequest, signal?: AbortSignal): Promise<WebFetchResult>;
+    /** Fetch one image for multimodal research and package export. */
+    fetchImage(request: WebImageFetchRequest, signal?: AbortSignal): Promise<WebImageFetchResult>;
+}
+/** Research options controlling bounded page reads. */
+export interface BrandResearchOptions {
+    /** Maximum number of unique sources to fetch. */
+    maxSources?: number;
+    /** Maximum text characters retained from each source. */
+    sourceMaxLength?: number;
+    /** Receives observable workflow progress. */
+    onProgress?: BrandProgressReporter;
+}
+/** Callback receiving one validated workflow progress event. */
+export type BrandProgressReporter = (event: BrandGenerationProgressEvent) => void | Promise<void>;
+/** One selected source and the text made available to synthesis. */
+export interface BrandResearchSource extends BrandPackageSource {
+    /** Readable page text, omitted when the fetch failed. */
+    content?: string;
+}
+/** Search answer, fetched sources, and official-page markup used by generation. */
+export interface BrandResearch {
+    /** Web-search model's evidence summary. */
+    answer: string;
+    /** Endpoint or fallback that ran the web search. */
+    model: string;
+    /** Selected and deduplicated citations. */
+    sources: BrandResearchSource[];
+    /** URL of the first source selected as the likely official page. */
+    officialPageUrl: string;
+    /** Raw markup used only for deterministic asset discovery. */
+    officialPageHtml?: string;
+    /** iOS and Android app-store references used as supplemental visual research. */
+    visualReferences: BrandResearchVisualReference[];
+}
+/** Fetched image retained in memory for multimodal synthesis. */
+export interface BrandResearchVisualImage {
+    url: string;
+    contentType?: string;
+    data?: Uint8Array;
+}
+/** Mobile-store page plus downloaded visual references. */
+export interface BrandResearchVisualReference extends Omit<BrandVisualReference, "images"> {
+    images: BrandResearchVisualImage[];
+}
+/** Build the focused, first-party search request for a brand. */
+export declare function brandResearchQuery(request: BrandGenerationRequest): string;
+/**
+ * Search for a brand, fetch a bounded set of cited pages, and retain the first
+ * page's markup for logo and favicon discovery.
+ */
+export declare function researchBrand(request: BrandGenerationRequest, client: BrandResearchClient, options?: BrandResearchOptions, signal?: AbortSignal): Promise<BrandResearch>;

package/lib/src/research.js

@@ -0,0 +1,235 @@
+/**
+ * Brand research composed from the web-search plugin's search and fetch
+ * operations.
+ *
+ * @module
+ */
+import { errorUtils, log, stringUtils } from "@dbx-tools/shared-core";
+import { discoverMobileAppVisuals } from "./assets.js";
+import { brandRequestSubject, } from "./schema.js";
+const logger = log.logger("brand/research");
+/** Default number of cited pages fetched for one brand. */
+export const DEFAULT_MAX_SOURCES = 4;
+/** Default character cap for each fetched page excerpt. */
+export const DEFAULT_SOURCE_MAX_LENGTH = 8_000;
+/** Upper bound that prevents one request from fanning out across too many sites. */
+export const MAX_SOURCES = 8;
+/** Upper bound on readable characters retained from one fetched page. */
+export const MAX_SOURCE_MAX_LENGTH = 20_000;
+/** Markup cap used for official and mobile page asset discovery. */
+export const ASSET_HTML_MAX_LENGTH = 1_500_000;
+/** Use expanded asset markup when supplied, retaining compatibility with direct clients. */
+function fetchAssetPage(client, request, signal) {
+    return client.fetchAssetPage
+        ? client.fetchAssetPage(request, signal)
+        : client.fetch({ ...request, format: "html" }, signal);
+}
+/** Build the focused, first-party search request for a brand. */
+export function brandResearchQuery(request) {
+    const subject = brandRequestSubject(request);
+    const website = request.website ? ` The known official website is ${request.website}.` : "";
+    return stringUtils.toDescription(`
+    Research the official brand identity and design direction for "${subject}".${website}
+    The broader brief is: ${request.prompt ?? subject}.
+    Prefer first-party sources and cite the official website first. Identify
+    the canonical and short names, current tagline, plain-language
+    description, audiences, writing tone, brand colors as hex values,
+    typography, documentation, source repository, logo, icon, and favicon.
+    Distinguish documented facts from reasonable visual inferences.
+  `);
+}
+/** Build a targeted mobile-store search query for visual references. */
+function mobileStoreQuery(request, platform) {
+    const subject = brandRequestSubject(request);
+    const site = platform === "ios" ? "apps.apple.com" : "play.google.com/store/apps";
+    return `site:${site} ${JSON.stringify(subject)} official app`;
+}
+/** Find one matching store page and download representative images. */
+async function researchMobileStore(request, platform, client, signal) {
+    try {
+        const search = await client.search({ query: mobileStoreQuery(request, platform) }, signal);
+        const expectedHost = platform === "ios" ? "apps.apple.com" : "play.google.com";
+        const pageUrl = search.citations
+            .map(({ url }) => publicHttpsUrl(url))
+            .find((url) => url && new URL(url).hostname === expectedHost);
+        if (!pageUrl)
+            return undefined;
+        const page = await fetchAssetPage(client, { url: pageUrl, maxLength: ASSET_HTML_MAX_LENGTH }, signal);
+        const discovered = discoverMobileAppVisuals(page.content, page.url);
+        const images = await Promise.all(discovered.imageUrls.slice(0, 4).map(async (url) => {
+            try {
+                const image = await client.fetchImage({ url }, signal);
+                return {
+                    url: image.url,
+                    contentType: image.contentType,
+                    data: image.data,
+                };
+            }
+            catch (error) {
+                logger.warn("mobile-image-fetch-failed", {
+                    platform,
+                    url,
+                    error: errorUtils.errorMessage(error),
+                });
+                return { url };
+            }
+        }));
+        return {
+            platform,
+            appName: discovered.appName,
+            pageUrl: page.url,
+            images,
+        };
+    }
+    catch (error) {
+        logger.warn("mobile-store-research-failed", {
+            platform,
+            error: errorUtils.errorMessage(error),
+        });
+        return undefined;
+    }
+}
+/** Return a normalized public HTTPS URL or `undefined`. */
+function publicHttpsUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === "https:" ? url.toString() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Compute a small first-party likelihood score while preserving search order. */
+function sourceScore(citation, request, index) {
+    const url = new URL(citation.url);
+    const subject = brandRequestSubject(request);
+    const knownWebsite = request.website ? new URL(request.website) : undefined;
+    const normalizedName = subject.toLowerCase().replace(/[^a-z\d]/g, "");
+    const normalizedHost = url.hostname.toLowerCase().replace(/[^a-z\d]/g, "");
+    const sameKnownOrigin = knownWebsite?.origin === url.origin ? 1_000 : 0;
+    const hostMatchesName = normalizedName.length >= 3 &&
+        (normalizedHost.includes(normalizedName) || normalizedName.includes(normalizedHost))
+        ? 100
+        : 0;
+    const titleMatchesName = citation.title?.toLowerCase().includes(subject.toLowerCase()) ? 10 : 0;
+    return sameKnownOrigin + hostMatchesName + titleMatchesName - index;
+}
+/** Select unique HTTPS citations and put the likely official page first. */
+function selectSources(citations, request, maxSources) {
+    const subject = brandRequestSubject(request);
+    const candidates = request.website
+        ? [{ url: request.website, title: `${subject} official website` }, ...citations]
+        : [...citations];
+    const unique = new Map();
+    for (const citation of candidates) {
+        const url = publicHttpsUrl(citation.url);
+        if (url && !unique.has(url))
+            unique.set(url, { ...citation, url });
+    }
+    return [...unique.values()]
+        .map((citation, index) => ({ citation, score: sourceScore(citation, request, index) }))
+        .sort((left, right) => right.score - left.score)
+        .slice(0, maxSources)
+        .map(({ citation }) => citation);
+}
+/** Fetch one citation as readable text without failing the whole research pass. */
+async function fetchSource(client, citation, sourceMaxLength, onComplete, signal) {
+    try {
+        const page = await client.fetch({ url: citation.url, format: "text", maxLength: sourceMaxLength }, signal);
+        return {
+            ...citation,
+            url: page.url,
+            ...(page.title ? { title: page.title } : {}),
+            fetched: true,
+            content: page.content,
+        };
+    }
+    catch (error) {
+        logger.warn("source-fetch-failed", {
+            url: citation.url,
+            error: errorUtils.errorMessage(error),
+        });
+        return { ...citation, fetched: false };
+    }
+    finally {
+        await onComplete();
+    }
+}
+/**
+ * Search for a brand, fetch a bounded set of cited pages, and retain the first
+ * page's markup for logo and favicon discovery.
+ */
+export async function researchBrand(request, client, options = {}, signal) {
+    const subject = brandRequestSubject(request);
+    const maxSources = Math.min(Math.max(1, options.maxSources ?? DEFAULT_MAX_SOURCES), MAX_SOURCES);
+    const sourceMaxLength = Math.max(1, Math.min(options.sourceMaxLength ?? DEFAULT_SOURCE_MAX_LENGTH, MAX_SOURCE_MAX_LENGTH));
+    await options.onProgress?.({
+        type: "progress",
+        stage: "search",
+        message: `Searching for official ${subject} brand sources`,
+    });
+    const [search, iosReference, androidReference] = await Promise.all([
+        client.search({ query: brandResearchQuery(request) }, signal),
+        researchMobileStore(request, "ios", client, signal),
+        researchMobileStore(request, "android", client, signal),
+    ]);
+    const visualReferences = [iosReference, androidReference].filter((reference) => reference !== undefined);
+    await options.onProgress?.({
+        type: "progress",
+        stage: "visuals",
+        message: `Reviewed ${visualReferences.length} mobile app references`,
+        current: visualReferences.length,
+        total: 2,
+    });
+    const citations = selectSources(search.citations, request, maxSources);
+    if (citations.length === 0) {
+        throw new Error(`Brand research for "${subject}" returned no public HTTPS sources to fetch.`);
+    }
+    let completedSources = 0;
+    await options.onProgress?.({
+        type: "progress",
+        stage: "fetch",
+        message: `Reading 0 of ${citations.length} sources`,
+        current: 0,
+        total: citations.length,
+    });
+    const official = citations[0];
+    const [sources, officialHtml] = await Promise.all([
+        Promise.all(citations.map((citation) => fetchSource(client, citation, sourceMaxLength, async () => {
+            completedSources += 1;
+            await options.onProgress?.({
+                type: "progress",
+                stage: "fetch",
+                message: `Read ${completedSources} of ${citations.length} sources`,
+                current: completedSources,
+                total: citations.length,
+            });
+        }, signal))),
+        fetchAssetPage(client, {
+            url: official.url,
+            maxLength: ASSET_HTML_MAX_LENGTH,
+        }, signal).catch((error) => {
+            logger.warn("official-page-html-fetch-failed", {
+                url: official.url,
+                error: errorUtils.errorMessage(error),
+            });
+            return undefined;
+        }),
+    ]);
+    await options.onProgress?.({
+        type: "progress",
+        stage: "assets",
+        message: officialHtml
+            ? "Found official page artwork"
+            : "Using the official site favicon fallback",
+    });
+    return {
+        answer: search.answer,
+        model: search.model,
+        sources,
+        officialPageUrl: officialHtml?.url ?? official.url,
+        ...(officialHtml ? { officialPageHtml: officialHtml.content } : {}),
+        visualReferences,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"research.js","sourceRoot":"","sources":["../../src/research.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Brand research composed from the web-search plugin's search and fetch\n * operations.\n *\n * @module\n */\n\nimport type {\n  WebAssetPageFetchRequest,\n  WebImageFetchRequest,\n  WebImageFetchResult,\n} from \"@dbx-tools/appkit-web-search/fetch\";\nimport type {\n  WebFetchRequest,\n  WebFetchResult,\n  WebSearchCitation,\n  WebSearchRequest,\n  WebSearchResult,\n} from \"@dbx-tools/appkit-web-search/schema\";\nimport { errorUtils, log, stringUtils } from \"@dbx-tools/shared-core\";\nimport { discoverMobileAppVisuals } from \"./assets.ts\";\nimport {\n  brandRequestSubject,\n  type BrandGenerationProgressEvent,\n  type BrandGenerationRequest,\n  type BrandPackageSource,\n  type BrandVisualReference,\n} from \"./schema.ts\";\n\nconst logger = log.logger(\"brand/research\");\n\n/** Default number of cited pages fetched for one brand. */\nexport const DEFAULT_MAX_SOURCES = 4;\n\n/** Default character cap for each fetched page excerpt. */\nexport const DEFAULT_SOURCE_MAX_LENGTH = 8_000;\n\n/** Upper bound that prevents one request from fanning out across too many sites. */\nexport const MAX_SOURCES = 8;\n\n/** Upper bound on readable characters retained from one fetched page. */\nexport const MAX_SOURCE_MAX_LENGTH = 20_000;\n\n/** Markup cap used for official and mobile page asset discovery. */\nexport const ASSET_HTML_MAX_LENGTH = 1_500_000;\n\n/** Search and fetch operations supplied by the registered web-search plugin. */\nexport interface BrandResearchClient {\n  /** Search the web and return a synthesized answer with citations. */\n  search(request: WebSearchRequest, signal?: AbortSignal): Promise<WebSearchResult>;\n  /** Fetch one cited page as text or HTML. */\n  fetch(request: WebFetchRequest, signal?: AbortSignal): Promise<WebFetchResult>;\n  /** Fetch expanded markup for deterministic in-process asset discovery. */\n  fetchAssetPage?(request: WebAssetPageFetchRequest, signal?: AbortSignal): Promise<WebFetchResult>;\n  /** Fetch one image for multimodal research and package export. */\n  fetchImage(request: WebImageFetchRequest, signal?: AbortSignal): Promise<WebImageFetchResult>;\n}\n\n/** Research options controlling bounded page reads. */\nexport interface BrandResearchOptions {\n  /** Maximum number of unique sources to fetch. */\n  maxSources?: number;\n  /** Maximum text characters retained from each source. */\n  sourceMaxLength?: number;\n  /** Receives observable workflow progress. */\n  onProgress?: BrandProgressReporter;\n}\n\n/** Callback receiving one validated workflow progress event. */\nexport type BrandProgressReporter = (event: BrandGenerationProgressEvent) => void | Promise<void>;\n\n/** One selected source and the text made available to synthesis. */\nexport interface BrandResearchSource extends BrandPackageSource {\n  /** Readable page text, omitted when the fetch failed. */\n  content?: string;\n}\n\n/** Search answer, fetched sources, and official-page markup used by generation. */\nexport interface BrandResearch {\n  /** Web-search model's evidence summary. */\n  answer: string;\n  /** Endpoint or fallback that ran the web search. */\n  model: string;\n  /** Selected and deduplicated citations. */\n  sources: BrandResearchSource[];\n  /** URL of the first source selected as the likely official page. */\n  officialPageUrl: string;\n  /** Raw markup used only for deterministic asset discovery. */\n  officialPageHtml?: string;\n  /** iOS and Android app-store references used as supplemental visual research. */\n  visualReferences: BrandResearchVisualReference[];\n}\n\n/** Fetched image retained in memory for multimodal synthesis. */\nexport interface BrandResearchVisualImage {\n  url: string;\n  contentType?: string;\n  data?: Uint8Array;\n}\n\n/** Mobile-store page plus downloaded visual references. */\nexport interface BrandResearchVisualReference extends Omit<BrandVisualReference, \"images\"> {\n  images: BrandResearchVisualImage[];\n}\n\n/** Use expanded asset markup when supplied, retaining compatibility with direct clients. */\nfunction fetchAssetPage(\n  client: BrandResearchClient,\n  request: WebAssetPageFetchRequest,\n  signal?: AbortSignal,\n): Promise<WebFetchResult> {\n  return client.fetchAssetPage\n    ? client.fetchAssetPage(request, signal)\n    : client.fetch({ ...request, format: \"html\" }, signal);\n}\n\n/** Build the focused, first-party search request for a brand. */\nexport function brandResearchQuery(request: BrandGenerationRequest): string {\n  const subject = brandRequestSubject(request);\n  const website = request.website ? ` The known official website is ${request.website}.` : \"\";\n  return stringUtils.toDescription(`\n    Research the official brand identity and design direction for \"${subject}\".${website}\n    The broader brief is: ${request.prompt ?? subject}.\n    Prefer first-party sources and cite the official website first. Identify\n    the canonical and short names, current tagline, plain-language\n    description, audiences, writing tone, brand colors as hex values,\n    typography, documentation, source repository, logo, icon, and favicon.\n    Distinguish documented facts from reasonable visual inferences.\n  `);\n}\n\n/** Build a targeted mobile-store search query for visual references. */\nfunction mobileStoreQuery(\n  request: BrandGenerationRequest,\n  platform: BrandVisualReference[\"platform\"],\n): string {\n  const subject = brandRequestSubject(request);\n  const site = platform === \"ios\" ? \"apps.apple.com\" : \"play.google.com/store/apps\";\n  return `site:${site} ${JSON.stringify(subject)} official app`;\n}\n\n/** Find one matching store page and download representative images. */\nasync function researchMobileStore(\n  request: BrandGenerationRequest,\n  platform: BrandVisualReference[\"platform\"],\n  client: BrandResearchClient,\n  signal?: AbortSignal,\n): Promise<BrandResearchVisualReference | undefined> {\n  try {\n    const search = await client.search({ query: mobileStoreQuery(request, platform) }, signal);\n    const expectedHost = platform === \"ios\" ? \"apps.apple.com\" : \"play.google.com\";\n    const pageUrl = search.citations\n      .map(({ url }) => publicHttpsUrl(url))\n      .find((url) => url && new URL(url).hostname === expectedHost);\n    if (!pageUrl) return undefined;\n    const page = await fetchAssetPage(\n      client,\n      { url: pageUrl, maxLength: ASSET_HTML_MAX_LENGTH },\n      signal,\n    );\n    const discovered = discoverMobileAppVisuals(page.content, page.url);\n    const images = await Promise.all(\n      discovered.imageUrls.slice(0, 4).map(async (url): Promise<BrandResearchVisualImage> => {\n        try {\n          const image = await client.fetchImage({ url }, signal);\n          return {\n            url: image.url,\n            contentType: image.contentType,\n            data: image.data,\n          };\n        } catch (error) {\n          logger.warn(\"mobile-image-fetch-failed\", {\n            platform,\n            url,\n            error: errorUtils.errorMessage(error),\n          });\n          return { url };\n        }\n      }),\n    );\n    return {\n      platform,\n      appName: discovered.appName,\n      pageUrl: page.url,\n      images,\n    };\n  } catch (error) {\n    logger.warn(\"mobile-store-research-failed\", {\n      platform,\n      error: errorUtils.errorMessage(error),\n    });\n    return undefined;\n  }\n}\n\n/** Return a normalized public HTTPS URL or `undefined`. */\nfunction publicHttpsUrl(value: string): string | undefined {\n  try {\n    const url = new URL(value);\n    return url.protocol === \"https:\" ? url.toString() : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/** Compute a small first-party likelihood score while preserving search order. */\nfunction sourceScore(\n  citation: WebSearchCitation,\n  request: BrandGenerationRequest,\n  index: number,\n): number {\n  const url = new URL(citation.url);\n  const subject = brandRequestSubject(request);\n  const knownWebsite = request.website ? new URL(request.website) : undefined;\n  const normalizedName = subject.toLowerCase().replace(/[^a-z\\d]/g, \"\");\n  const normalizedHost = url.hostname.toLowerCase().replace(/[^a-z\\d]/g, \"\");\n  const sameKnownOrigin = knownWebsite?.origin === url.origin ? 1_000 : 0;\n  const hostMatchesName =\n    normalizedName.length >= 3 &&\n    (normalizedHost.includes(normalizedName) || normalizedName.includes(normalizedHost))\n      ? 100\n      : 0;\n  const titleMatchesName = citation.title?.toLowerCase().includes(subject.toLowerCase()) ? 10 : 0;\n  return sameKnownOrigin + hostMatchesName + titleMatchesName - index;\n}\n\n/** Select unique HTTPS citations and put the likely official page first. */\nfunction selectSources(\n  citations: readonly WebSearchCitation[],\n  request: BrandGenerationRequest,\n  maxSources: number,\n): WebSearchCitation[] {\n  const subject = brandRequestSubject(request);\n  const candidates = request.website\n    ? [{ url: request.website, title: `${subject} official website` }, ...citations]\n    : [...citations];\n  const unique = new Map<string, WebSearchCitation>();\n  for (const citation of candidates) {\n    const url = publicHttpsUrl(citation.url);\n    if (url && !unique.has(url)) unique.set(url, { ...citation, url });\n  }\n  return [...unique.values()]\n    .map((citation, index) => ({ citation, score: sourceScore(citation, request, index) }))\n    .sort((left, right) => right.score - left.score)\n    .slice(0, maxSources)\n    .map(({ citation }) => citation);\n}\n\n/** Fetch one citation as readable text without failing the whole research pass. */\nasync function fetchSource(\n  client: BrandResearchClient,\n  citation: WebSearchCitation,\n  sourceMaxLength: number,\n  onComplete: () => void | Promise<void>,\n  signal?: AbortSignal,\n): Promise<BrandResearchSource> {\n  try {\n    const page = await client.fetch(\n      { url: citation.url, format: \"text\", maxLength: sourceMaxLength },\n      signal,\n    );\n    return {\n      ...citation,\n      url: page.url,\n      ...(page.title ? { title: page.title } : {}),\n      fetched: true,\n      content: page.content,\n    };\n  } catch (error) {\n    logger.warn(\"source-fetch-failed\", {\n      url: citation.url,\n      error: errorUtils.errorMessage(error),\n    });\n    return { ...citation, fetched: false };\n  } finally {\n    await onComplete();\n  }\n}\n\n/**\n * Search for a brand, fetch a bounded set of cited pages, and retain the first\n * page's markup for logo and favicon discovery.\n */\nexport async function researchBrand(\n  request: BrandGenerationRequest,\n  client: BrandResearchClient,\n  options: BrandResearchOptions = {},\n  signal?: AbortSignal,\n): Promise<BrandResearch> {\n  const subject = brandRequestSubject(request);\n  const maxSources = Math.min(Math.max(1, options.maxSources ?? DEFAULT_MAX_SOURCES), MAX_SOURCES);\n  const sourceMaxLength = Math.max(\n    1,\n    Math.min(options.sourceMaxLength ?? DEFAULT_SOURCE_MAX_LENGTH, MAX_SOURCE_MAX_LENGTH),\n  );\n  await options.onProgress?.({\n    type: \"progress\",\n    stage: \"search\",\n    message: `Searching for official ${subject} brand sources`,\n  });\n  const [search, iosReference, androidReference] = await Promise.all([\n    client.search({ query: brandResearchQuery(request) }, signal),\n    researchMobileStore(request, \"ios\", client, signal),\n    researchMobileStore(request, \"android\", client, signal),\n  ]);\n  const visualReferences = [iosReference, androidReference].filter(\n    (reference): reference is BrandResearchVisualReference => reference !== undefined,\n  );\n  await options.onProgress?.({\n    type: \"progress\",\n    stage: \"visuals\",\n    message: `Reviewed ${visualReferences.length} mobile app references`,\n    current: visualReferences.length,\n    total: 2,\n  });\n  const citations = selectSources(search.citations, request, maxSources);\n  if (citations.length === 0) {\n    throw new Error(`Brand research for \"${subject}\" returned no public HTTPS sources to fetch.`);\n  }\n  let completedSources = 0;\n  await options.onProgress?.({\n    type: \"progress\",\n    stage: \"fetch\",\n    message: `Reading 0 of ${citations.length} sources`,\n    current: 0,\n    total: citations.length,\n  });\n\n  const official = citations[0];\n  const [sources, officialHtml] = await Promise.all([\n    Promise.all(\n      citations.map((citation) =>\n        fetchSource(\n          client,\n          citation,\n          sourceMaxLength,\n          async () => {\n            completedSources += 1;\n            await options.onProgress?.({\n              type: \"progress\",\n              stage: \"fetch\",\n              message: `Read ${completedSources} of ${citations.length} sources`,\n              current: completedSources,\n              total: citations.length,\n            });\n          },\n          signal,\n        ),\n      ),\n    ),\n    fetchAssetPage(\n      client,\n      {\n        url: official.url,\n        maxLength: ASSET_HTML_MAX_LENGTH,\n      },\n      signal,\n    ).catch((error: unknown) => {\n      logger.warn(\"official-page-html-fetch-failed\", {\n        url: official.url,\n        error: errorUtils.errorMessage(error),\n      });\n      return undefined;\n    }),\n  ]);\n  await options.onProgress?.({\n    type: \"progress\",\n    stage: \"assets\",\n    message: officialHtml\n      ? \"Found official page artwork\"\n      : \"Using the official site favicon fallback\",\n  });\n\n  return {\n    answer: search.answer,\n    model: search.model,\n    sources,\n    officialPageUrl: officialHtml?.url ?? official.url,\n    ...(officialHtml ? { officialPageHtml: officialHtml.content } : {}),\n    visualReferences,\n  };\n}\n"]}