@gengage/assistant-fe 0.6.19 → 0.6.22

package/dist/agentic/types.d.ts

@@ -1,5 +1,7 @@
 import type { ProcessActionRequest } from '../common/transport.js';
 import type { StreamEvent, UISpec } from '../common/types.js';
+import type { NormalizedProduct } from './events/product-normalize.js';
+import type { ProductSimilarityProfile } from './algos/similarity.js';
 export interface ChatThread {
     id: string;
     started_at: string;
@@ -21,7 +23,7 @@ export interface ChatContext {
     thread: ChatThread;
     meta: ChatMeta;
 }
-export type RpcMethod = 'tool.invoke' | 'beacon.send' | 'memory.get' | 'memory.set' | (string & {});
+export type RpcMethod = 'tool.invoke' | 'beacon.send' | 'confirmation.request' | 'memory.get' | 'memory.set' | 'memory.remove' | (string & {});
 export type RpcFn = <T = unknown>(method: RpcMethod, payload?: unknown, transfer?: Transferable[]) => Promise<T>;
 export interface ToolBridge {
     invoke<T = unknown>(name: string, input?: unknown): Promise<T>;
@@ -36,26 +38,45 @@ export interface BeClient {
         browserCache?: BrowserCachePolicy;
     }): Promise<unknown>;
 }
+export type Awaitable<T> = T | Promise<T>;
 export interface FlowStepCtx {
     request: ProcessActionRequest;
     context: ChatContext;
     bag: Record<string, unknown>;
     accountConfig: Record<string, unknown>;
+    catalogMapper?: CatalogMapper | undefined;
+    similarityMapper?: SimilarityMapper | undefined;
 }
-export type FlowValue<T> = T | ((ctx: FlowStepCtx) => T);
-export type FlowPatch = (ctx: ChatContext, result: unknown, snapshot: FlowStepCtx) => Partial<ChatContext> | null | undefined;
+export type FlowValue<T> = T | ((ctx: FlowStepCtx) => Awaitable<T>);
+export type FlowPatch = (ctx: ChatContext, result: unknown, snapshot: FlowStepCtx) => Awaitable<Partial<ChatContext> | null | undefined>;
 export type BrowserCachePolicy = boolean | {
     ttlMs?: number;
 };
+export interface BeOpCachePolicy {
+    strategy: 'input-hash';
+    ttlS: number;
+    promptVersion?: string | undefined;
+}
 export type FlowAdapterFn = (input: unknown, ctx: FlowStepCtx) => unknown | Promise<unknown>;
 export type FlowAdapterMap = Record<string, FlowAdapterFn>;
+export interface FlowConfirmationRequest {
+    title?: string;
+    message?: string;
+    action?: string;
+    payload?: unknown;
+}
+export type FlowConfirmationValue = boolean | string | FlowConfirmationRequest;
+export type FlowConfirmationGate = FlowValue<FlowConfirmationValue | null | undefined>;
 export interface BeOpStep {
     kind: 'be_op';
     op: string;
     input: FlowValue<unknown>;
+    cache?: FlowValue<BeOpCachePolicy | false | null | undefined>;
     cacheTtlS?: FlowValue<number | undefined>;
     cacheKey?: FlowValue<string | undefined>;
     browserCache?: FlowValue<BrowserCachePolicy | undefined>;
+    timeoutMs?: FlowValue<number | undefined>;
+    confirm?: FlowConfirmationGate;
     out?: string;
     errorOut?: string;
     onError?: readonly FlowStep[];
@@ -65,6 +86,8 @@ export interface ToolStep {
     kind: 'tool';
     name: string;
     input: FlowValue<unknown>;
+    timeoutMs?: FlowValue<number | undefined>;
+    confirm?: FlowConfirmationGate;
     out?: string;
     errorOut?: string;
     onError?: readonly FlowStep[];
@@ -74,12 +97,14 @@ export interface AdapterStep {
     kind: 'adapter';
     name: string;
     input: FlowValue<unknown>;
+    timeoutMs?: FlowValue<number | undefined>;
+    confirm?: FlowConfirmationGate;
     out?: string;
     patch?: FlowPatch;
 }
 export interface EmitStep {
     kind: 'emit';
-    build: (ctx: FlowStepCtx) => StreamEvent;
+    build: (ctx: FlowStepCtx) => Awaitable<StreamEvent>;
 }
 export interface PatchStep {
     kind: 'patch';
@@ -93,6 +118,7 @@ export interface BranchStep {
 export interface ParallelStep {
     kind: 'parallel';
     steps: readonly (readonly FlowStep[])[];
+    timeoutMs?: FlowValue<number | undefined>;
     merge?: {
         bag?: readonly string[];
         panel?: readonly string[];
@@ -110,16 +136,24 @@ export type FlowStep = BeOpStep | ToolStep | AdapterStep | EmitStep | PatchStep
 export type Flow = readonly FlowStep[];
 export type ToolFn = (input: unknown) => unknown | Promise<unknown>;
 export type ToolMap = Record<string, ToolFn>;
+export type CatalogMapper = (raw: Record<string, unknown>) => NormalizedProduct | null;
+export type SimilarityMapper = (raw: Record<string, unknown>) => ProductSimilarityProfile | null;
 export interface AccountModule {
     accountId?: string;
     defaultLocale?: string;
     flows: Record<string, Flow>;
     tools?: ToolMap;
     adapters?: FlowAdapterMap;
+    catalogMapper?: CatalogMapper;
+    similarityMapper?: SimilarityMapper;
     accountConfig?: Record<string, unknown>;
+    trace?: AgentTraceCallback;
     contextPersistence?: {
         panelKeys?: readonly string[];
         panelKeyLimits?: Record<string, number>;
+        messageLimit?: number;
+        maxThreads?: number;
+        threadTtlMs?: number;
     };
 }
 export interface AgentOpBeacon {
@@ -158,6 +192,31 @@ export interface GenericBeacon {
 }
 export type AgentBeaconPayload = AgentOpBeacon | AgentToolBeacon | TurnSummaryBeacon | GenericBeacon;
 export type BeaconCallback = (payload: AgentBeaconPayload) => void;
+export interface AgentTraceEvent {
+    type: 'turn:start' | 'turn:end' | 'turn:error' | 'step:start' | 'step:end' | 'step:error' | 'confirmation:start' | 'confirmation:end' | 'confirmation:error';
+    accountId: string;
+    threadId: string;
+    sessionId: string;
+    stepIndex?: number;
+    stepKind?: FlowStep['kind'];
+    stepName?: string;
+    latencyMs?: number;
+    errorCode?: string;
+}
+export type AgentTraceCallback = (event: AgentTraceEvent) => Awaitable<void>;
+export interface AgentConfirmationRequest extends FlowConfirmationRequest {
+    accountId: string;
+    threadId: string;
+    sessionId: string;
+    stepKind: FlowStep['kind'];
+    stepName?: string;
+}
+export interface AgentConfirmationResult {
+    confirmed: boolean;
+    reason?: string;
+    payload?: unknown;
+}
+export type ConfirmationCallback = (request: AgentConfirmationRequest) => Awaitable<boolean | AgentConfirmationResult>;
 export interface UiSpecEnvelope {
     widget: 'chat' | 'qna' | 'simrel';
     spec: UISpec;
@@ -179,6 +238,14 @@ export interface MemoryBucketAsync {
     }) => Promise<boolean>;
     remove: (key: string) => Promise<void>;
 }
+export type MemoryTier = 'volatile' | 'session' | 'local' | 'indexedDb';
+export interface AgentMemoryProvider {
+    get: (tier: MemoryTier, key: string) => unknown | Promise<unknown>;
+    set: (tier: MemoryTier, key: string, value: unknown, options?: {
+        ttlMs?: number;
+    }) => boolean | void | Promise<boolean | void>;
+    remove?: (tier: MemoryTier, key: string) => void | Promise<void>;
+}
 export interface BrowserMemory {
     accountId: string;
     volatile: MemoryBucketSync & {
@@ -187,6 +254,12 @@ export interface BrowserMemory {
     session: MemoryBucketSync;
     local: MemoryBucketSync;
     indexedDb: MemoryBucketAsync;
+    gc: () => Promise<{
+        volatile: number;
+        session: number;
+        local: number;
+        indexedDb: number;
+    }>;
     stableKey: (value: unknown) => string;
     policy: Record<string, string>;
 }

package/dist/agentic/util/common/declarative-cache.d.ts

@@ -0,0 +1,21 @@
+export declare const INPUT_HASH_CACHE_STRATEGY = "input-hash";
+export declare function inputHashCachePolicy({ ttlS, promptVersion }?: {
+    promptVersion?: string | undefined;
+}): {
+    strategy: string;
+    ttlS: any;
+    promptVersion: string;
+};
+export declare function declarativeBeOpCache({ accountId, op, ttlS, promptVersion, input, keyParts, locale, }?: {
+    accountId?: string | undefined;
+    promptVersion?: string | undefined;
+}): {
+    cache: {
+        strategy: string;
+        ttlS: any;
+        promptVersion: string;
+    };
+    cacheTtlS: any;
+    cacheKey: (args?: {}) => string;
+};
+export declare function withDeclarativeBeOpCache(step: any, policy?: {}): any;

package/dist/agentic/util/common/fallback-status.d.ts

@@ -0,0 +1,10 @@
+export declare const FALLBACK_STATUS: Readonly<{
+    FALLBACK_RESULTS: "fallback_results";
+    FALLBACK_NO_RESULTS: "fallback_no_results";
+    FALLBACK_PARTIAL: "fallback_partial";
+    OP_UNAVAILABLE: "op_unavailable";
+}>;
+export declare function fallbackStatus(status: any, details?: {}): {
+    status: any;
+};
+export declare function isFallbackStatus(value: any): boolean;

package/dist/agentic/util/common/flow-steps.d.ts

@@ -0,0 +1,8 @@
+export declare function createReadPageStep(productDetailsPanelPatch: any): () => {
+    kind: string;
+    name: string;
+    input: () => {};
+    out: string;
+    patch: (ctx: any, result: any) => any;
+    onError: never[];
+}[];

package/dist/agentic/util/common/gss-tool-aliases.d.ts

@@ -0,0 +1,66 @@
+export declare function createGssToolAliases({ accountId, search, facetedSearch, similaritySearch, searchGiftOptions, filters, resultContract, limitations, extraTools, }?: {
+    filters?: {} | undefined;
+    resultContract?: {} | undefined;
+    limitations?: never[] | undefined;
+    extraTools?: never[] | undefined;
+}): {
+    searchKeyword: (queryOrOptions?: {}, options?: {}) => Promise<any>;
+    facetedSearch: (input?: {}, options?: {}) => any;
+    getSearchCapabilities: () => {
+        accountId: any;
+        tools: any;
+        filters: {
+            query: string;
+            categoryId: string;
+            categoryName: string;
+            categoryHints: string;
+            brandHints: string;
+            featureHints: string;
+            facets: string;
+            facetParams: string;
+            priceMin: string;
+            priceMax: string;
+        };
+        resultContract: {
+            productItemFields: string[];
+            productDetailFields: string[];
+            searchResultFields: string[];
+            similarityResultFields: string[];
+            siteContentFields: string[];
+        };
+        privacy: string[];
+        limitations: never[];
+    };
+};
+export declare function gssSearchCapabilities({ accountId, hasSimilarity, hasGiftSearch, filters, resultContract, limitations, extraTools, }?: {
+    hasSimilarity?: boolean | undefined;
+    hasGiftSearch?: boolean | undefined;
+    filters?: {} | undefined;
+    resultContract?: {} | undefined;
+    limitations?: never[] | undefined;
+    extraTools?: never[] | undefined;
+}): {
+    accountId: any;
+    tools: any;
+    filters: {
+        query: string;
+        categoryId: string;
+        categoryName: string;
+        categoryHints: string;
+        brandHints: string;
+        featureHints: string;
+        facets: string;
+        facetParams: string;
+        priceMin: string;
+        priceMax: string;
+    };
+    resultContract: {
+        productItemFields: string[];
+        productDetailFields: string[];
+        searchResultFields: string[];
+        similarityResultFields: string[];
+        siteContentFields: string[];
+    };
+    privacy: string[];
+    limitations: never[];
+};

package/dist/agentic/util/common/iframe-scraper.d.ts

@@ -0,0 +1,22 @@
+export declare function createIframeScraper({ markerParam, markerValue, frameName, sandbox, timeoutMs, hiddenStyle, messageType, parser, isBlockedDocument, }?: {
+    markerParam?: string | undefined;
+    markerValue?: string | undefined;
+    frameName?: any;
+    sandbox?: string | undefined;
+    timeoutMs?: number | undefined;
+    hiddenStyle?: string | undefined;
+}): {
+    markerParam: string;
+    markerValue: any;
+    frameName: any;
+    messageType: any;
+    decorateUrl: (url: any, params?: {}) => string;
+    isScraperFrame: (locationLike?: Location, name?: string) => boolean;
+    load: (url: any, input?: {}, options?: {}) => Promise<unknown>;
+    postCurrentDocument: (payloadFactory?: any, { targetOrigin }?: {
+        targetOrigin?: string | undefined;
+    }) => boolean;
+};
+export declare function installIframeScraperBypass(scraper: any, { accountId, type }?: {
+    type?: string | undefined;
+}): boolean;

package/dist/agentic/util/common/llm-routing.d.ts

@@ -0,0 +1,50 @@
+export declare function routeText(request: any): string;
+export declare function explicitRoute(request: any, routeMap?: {}): any;
+export declare function llmIntentStep({ accountId, cacheTtlS, browserCacheTtlMs, promptVersion, cacheable, piiPatternPack, utterance, compactPageContext: pageContextMapper, compactStructuredContext: structuredContextMapper, extraInput, cacheKeyParts, onError, }?: {
+    cacheTtlS?: number | undefined;
+    promptVersion?: string | undefined;
+    cacheable?: boolean | undefined;
+    piiPatternPack?: {
+        patterns: import("../privacy.js").RedactionPattern[];
+    } | undefined;
+    compactPageContext?: typeof compactPageContext | undefined;
+    compactStructuredContext?: typeof compactStructuredContext | undefined;
+    onError?: never[] | undefined;
+}): {
+    cacheKey: ({ request, context, bag, accountConfig }: {
+        request: any;
+        context: any;
+        bag: any;
+        accountConfig: any;
+    }) => string | undefined;
+    onError: never[];
+    browserCache?: {
+        ttlMs: any;
+    };
+    kind: string;
+    op: string;
+    input: (ctx: any) => {
+        [k: string]: unknown;
+    } & {
+        account_config?: Record<string, unknown>;
+    };
+    out: string;
+    cache: (ctx: any) => {
+        strategy: string;
+        ttlS: any;
+        promptVersion: string;
+    } | undefined;
+};
+export declare function routeKind(route: any, fallback?: string): string;
+export declare function searchQueryFromRoute(request: any, bag: any): {};
+export declare function searchInputFromRoute(request: any, bag: any): {
+    [k: string]: unknown;
+};
+export declare function flowParamsFromRoute(bag: any): any;
+declare function compactPageContext(page?: {}): {
+    [k: string]: unknown;
+};
+declare function compactStructuredContext(context?: {}): {
+    [k: string]: unknown;
+};
+export {};

package/dist/agentic/util/common/object.d.ts

@@ -0,0 +1 @@
+export declare function compactObject(value: unknown): Record<string, unknown>;

package/dist/agentic/util/common/open-product-page.d.ts

@@ -0,0 +1,30 @@
+export declare function createOpenProductPageTool({ rootUrl, successMessage, alreadyCurrentPageMessage, missingUrlMessage, }?: {
+    alreadyCurrentPageMessage?: any;
+    missingUrlMessage?: string | undefined;
+}): (input?: {}) => Promise<{
+    ok: boolean;
+    sku: any;
+    reason: string;
+    message: string;
+    url?: never;
+    method?: never;
+    alreadyCurrentPage?: never;
+} | {
+    ok: boolean;
+    sku: any;
+    url: string;
+    method: string;
+    alreadyCurrentPage: boolean;
+    message: any;
+    reason?: never;
+} | {
+    ok: boolean;
+    sku: any;
+    url: string;
+    method: string;
+    message: any;
+    reason?: never;
+    alreadyCurrentPage?: never;
+}>;
+export declare function normalizeSameOriginUrl(value: any, rootUrl: any, rootOrigin?: string): string;
+export declare function navigateSameTab(url: any): void;

package/dist/agentic/util/common/panel-context.d.ts

@@ -0,0 +1,3 @@
+export declare function homePanelReset(ctx: any, { screenSummary }?: {}): {
+    panel: any;
+};

package/dist/agentic/util/common/privacy.d.ts

@@ -0,0 +1,14 @@
+import { defaultPiiPatterns } from '../privacy.js';
+export { defaultPiiPatterns };
+export declare function createPrivacyHelpers({ patterns, messageFilter, messageNormalizer, messageLimit, }?: {
+    messageNormalizer?: ((value: any) => any) | undefined;
+    messageLimit?: number | undefined;
+}): {
+    redactPii: (value: any) => string;
+    anonymousRequestText: (request: any) => string;
+    anonymizeMessages: (messages?: never[]) => {
+        role: any;
+        content: string;
+    }[];
+};
+export declare function plainMessageContent(value: any): string;

package/dist/agentic/util/common/product-resolver.d.ts

@@ -0,0 +1,20 @@
+export declare function resolveProductCandidates({ accountId, supplied, pageProduct, listingProducts, skus, limit, storedProducts, getStoredPanelProducts, }?: {
+    supplied?: never[] | undefined;
+    pageProduct?: null | undefined;
+    listingProducts?: never[] | undefined;
+    skus?: never[] | undefined;
+    limit?: number | undefined;
+    storedProducts?: never[] | undefined;
+}): any[];
+export declare function createResolveProductsTool({ accountId, rootUrl, getProduct, getProducts, getStoredPanelProducts, limit, }?: {
+    limit?: number | undefined;
+}): (input?: {}) => Promise<{
+    accountId: any;
+    products: any[];
+    rootUrl: any;
+}>;
+export declare function uniqueProductsBySku(products: any, { skus, limit }?: {
+    skus?: never[] | undefined;
+    limit?: number | undefined;
+}): any[];
+export declare function readStoredPanelProducts(accountId: any, visibleProducts?: never[]): never[];

package/dist/agentic/util/common/product-surface.d.ts

@@ -0,0 +1,24 @@
+export declare function createProductSurfaceInspector({ accountId, getPageType, getProduct, getProducts, normalizeProduct, }: {
+    accountId: any;
+    getPageType: any;
+    getProduct: any;
+    getProducts: any;
+    normalizeProduct?: ((product: any) => any) | undefined;
+}): (input?: {}) => {
+    [k: string]: unknown;
+};
+export declare function inspectProductSurface({ accountId, getPageType, getProduct, getProducts, normalizeProduct, input, }: {
+    accountId: any;
+    getPageType: any;
+    getProduct: any;
+    getProducts: any;
+    normalizeProduct?: ((product: any) => any) | undefined;
+    input?: {} | undefined;
+}): {
+    [k: string]: unknown;
+};
+export declare function mergeProductSurfaceEvidence(products: any, surface: any): any[];
+export declare function compactProductSurfaceForLlm(surface: any): {
+    [k: string]: unknown;
+} | null;
+export declare function productSurfaceReviewText(surface: any, fallback: any, options?: {}): any;

package/dist/agentic/util/common/ref-store.d.ts

@@ -0,0 +1,15 @@
+export declare function createLocalRefStore({ namespace, ttlMs, maxEntries }?: {
+    namespace?: string | undefined;
+    ttlMs?: number | undefined;
+    maxEntries?: number | undefined;
+}): {
+    put: (value: any, options?: {}) => Promise<{
+        kind: any;
+        id: string;
+    }>;
+    get: (refOrId: any) => Promise<any>;
+    delete: (refOrId: any) => Promise<void>;
+    materialize: (value: any) => any;
+    cleanup: () => void;
+};
+export declare function isRef(value: any): boolean;

package/dist/agentic/util/common/retail-privacy.d.ts

@@ -0,0 +1,4 @@
+export declare const redactPii: (value: any) => string, anonymousRequestText: (request: any) => string, anonymizeMessages: (messages?: never[]) => {
+    role: any;
+    content: string;
+}[];

package/dist/agentic/util/common/route-params.d.ts

@@ -0,0 +1,3 @@
+export declare function routeFlowParams(bag: any): any;
+export declare function firstArrayValue(value: any): any;
+export declare function routeSkuList(bag: any): string[];

package/dist/agentic/util/common/similarity-ranking.d.ts

@@ -0,0 +1,2 @@
+export declare function rankSimilarityCandidates(source?: {}, products?: never[], options?: {}): never[];
+export declare function withoutSourceProduct(products?: never[], source?: {}): never[];

package/dist/agentic/util/common/site-awareness.d.ts

@@ -0,0 +1,130 @@
+export declare function createSiteAwarenessTools({ accountId, getPageType, getProduct, getProducts, normalizeProduct, }: {
+    accountId: any;
+    getPageType: any;
+    getProduct: any;
+    getProducts: any;
+    normalizeProduct?: ((product: any) => any) | undefined;
+}): {
+    scanSite: (input?: {}) => {
+        [k: string]: unknown;
+    };
+    siteGrep: (input?: {}) => {
+        ok: boolean;
+        matches: never[];
+        message: string;
+        privacy: {
+            rawHtml: boolean;
+            formValues: boolean;
+            redacted: boolean;
+            browserLocal: boolean;
+        };
+        query?: never;
+        count?: never;
+    } | {
+        ok: boolean;
+        query: string;
+        matches: {
+            snippet: string;
+            tag: string;
+            heading: string;
+        }[];
+        count: number;
+        privacy: {
+            rawHtml: boolean;
+            formValues: boolean;
+            redacted: boolean;
+            browserLocal: boolean;
+        };
+        message?: never;
+    };
+    discoverSiteContent: (input?: {}) => {
+        accountId: string;
+        items: ({
+            [k: string]: unknown;
+        } | null)[];
+        count: number;
+        privacy: {
+            rawHtml: boolean;
+            formValues: boolean;
+            redacted: boolean;
+            browserLocal: boolean;
+        };
+    };
+    runSiteCommand: (input?: {}) => {
+        ok: boolean;
+        command: string;
+        message: string;
+        label?: never;
+        privacy?: never;
+    } | {
+        ok: boolean;
+        command: string;
+        label: string;
+        message: string;
+        privacy: {
+            rawHtml: boolean;
+            formValues: boolean;
+            redacted: boolean;
+            browserLocal: boolean;
+        };
+    } | {
+        ok: boolean;
+        blocked: boolean;
+        command: string;
+        message: string;
+        privacy: {
+            rawHtml: boolean;
+            formValues: boolean;
+            redacted: boolean;
+            browserLocal: boolean;
+        };
+        label?: never;
+    } | {
+        ok: boolean;
+        command: string;
+        message: string;
+        privacy: {
+            rawHtml: boolean;
+            formValues: boolean;
+            redacted: boolean;
+            browserLocal: boolean;
+        };
+    };
+    describeVisualContext: (input?: {}) => {
+        accountId: any;
+        ok: boolean;
+        consentedObservations: string[];
+        visibleImages: {
+            alt: string;
+            title: string;
+            src: string;
+            width: number;
+            height: number;
+        }[];
+        message: string;
+        privacy: {
+            rawHtml: boolean;
+            formValues: boolean;
+            screenshotPixels: boolean;
+            redacted: boolean;
+            browserLocal: boolean;
+            requiresConsentForExternalVisualFacts: boolean;
+        };
+    };
+    inspectProductSurface: (input?: {}) => {
+        [k: string]: unknown;
+    };
+    getSiteCapabilities: () => {
+        accountId: any;
+        tools: string[];
+        commands: {
+            scanSite: string;
+            siteGrep: string;
+            discoverSiteContent: string;
+            runSiteCommand: string;
+            describeVisualContext: string;
+            inspectProductSurface: string;
+        };
+        privacy: string[];
+    };
+};

package/dist/agentic/util/lazy-runtime-loader.d.ts

@@ -4,6 +4,7 @@ interface LazyRuntimeLoaderOptions {
     startExport?: string;
     globalBaseUrlKey?: string;
     errorLabel?: string;
+    trustedRuntimeOrigins?: readonly string[] | true;
 }
-export declare function startLazyRuntimeLoader({ accountId, runtimeFile, startExport, globalBaseUrlKey, errorLabel, }?: LazyRuntimeLoaderOptions): Promise<unknown>;
+export declare function startLazyRuntimeLoader({ accountId, runtimeFile, startExport, globalBaseUrlKey, errorLabel, trustedRuntimeOrigins, }?: LazyRuntimeLoaderOptions): Promise<unknown>;
 export {};