@8wave/ai-elements 0.117.0 → 0.118.0-beta.16

package/dist-vue/packages/components/src/chat/useWakeupWatch.d.ts

@@ -6,6 +6,11 @@ import { ChatbotApiClient } from '../../../composable/src';
  * time and then reloads the conversation until the wakeup's turn is in it,
  * which the seed carrying its id proves (the seed and the answer are written
  * together). Then it reads the next one, if the turn scheduled it.
+ *
+ * While a wakeup waits, the page also tells the server it is in front of the
+ * user (Fase 1.2): every 30 seconds while the tab is visible, and at once
+ * when it comes back in front, so a round with news mails only a user who
+ * is away. A page with no wakeup waiting sends nothing.
  */
 export declare function useWakeupWatch(options: {
     agentId: () => string;

package/dist-vue/packages/composable/src/chatbot/api/createChatbotApiClient.d.ts

@@ -38,6 +38,8 @@ export interface ChatbotApiClient {
     getChatWakeup(agentId: string, chatId: string): Promise<ChatWakeupState>;
     /** The user's "Stop" of the chat's pending wakeup. */
     stopChatWakeup(agentId: string, chatId: string): Promise<ChatWakeupState>;
+    /** The chat is open in a visible tab: its wakeups mail nothing meanwhile. */
+    markChatWakeupPresence(agentId: string, chatId: string): Promise<void>;
     updateChatTitle(agentId: string, chatId: string, title: string): Promise<Chat>;
     deleteChat(agentId: string, chatId: string): Promise<void>;
     getMessageFeedbacks(chatId: string): Promise<MessageFeedback[]>;

package/dist-vue/packages/models/src/schema/Document.d.ts

@@ -131,15 +131,23 @@ export declare const REFRESH_INTERVAL_SQL: Record<DocumentRefreshInterval, strin
 /**
  * Hours after which a document left `processing` is treated as abandoned.
  *
- * A killed worker leaves that status behind, and nothing else moves it: the row
- * would drop out of the refresh timer's selection for good, because the timer
- * only claims documents that are `success` or `failed`. Past this window the
- * timer takes it anyway, and a manual refresh stops being refused.
+ * Only a claim writes `processing`, and a worker killed mid-run (heap
+ * exhausted, host recycled, revision deactivated) leaves it behind with nothing
+ * else to move it. Two timers act on this window: `dlqSweep` marks the document
+ * `failed` and tells its owner (`failStaleProcessingDocuments`), and the
+ * refresh timer, which otherwise claims only `success` and `failed`, takes a
+ * due page anyway.
  *
- * Generous on purpose: a scrape is bounded by the Functions host timeout, so
- * anything still `processing` after six hours is not running.
+ * Derived from the bound a run cannot outlive: `host.json` leaves
+ * `functionTimeout` at its Container Apps default of 30 minutes, past which the
+ * host stops the run, and every claim, a redelivery's included, moves
+ * `updated_at`. A row whose last claim is an hour old has outlived the longest
+ * possible run twice over. The backend claims too, and stays inside the bound:
+ * a text edited by hand only rewrites its chunks there (seconds, embeddings go
+ * to the queue), and a whole conversion runs inline only with no Service Bus,
+ * which is local development, where no function app consumes its documents.
  */
-export declare const STALE_PROCESSING_HOURS = 6;
+export declare const STALE_PROCESSING_HOURS = 1;
 export declare const DocumentLastRefreshSchema: z.ZodObject<{
     at: z.ZodString;
     result: z.ZodEnum<typeof DocumentRefreshResult>;
@@ -498,7 +506,7 @@ export type DocumentRefusalReason = (typeof DOCUMENT_REFUSAL_REASONS)[number];
  * Why a file is refused for what it is, as `UnprocessableFileError` in the
  * document processor says.
  */
-export declare const UNPROCESSABLE_FILE_REASONS: readonly ["file-unreadable", "file-protected", "file-type-unsupported", "spreadsheet-protected", "spreadsheet-unreadable", "spreadsheet-macros", "spreadsheet-too-large", "spreadsheet-no-table", "audio-no-speech", "audio-too-large"];
+export declare const UNPROCESSABLE_FILE_REASONS: readonly ["file-unreadable", "file-protected", "file-type-unsupported", "spreadsheet-protected", "spreadsheet-unreadable", "spreadsheet-macros", "spreadsheet-too-large", "spreadsheet-no-table", "audio-no-speech", "audio-too-large", "page-too-large"];
 export type UnprocessableFileReason = (typeof UNPROCESSABLE_FILE_REASONS)[number];
 /** Every `reason` a failed document can carry in `metadata.lastIndexError`. */
 export declare const DOCUMENT_INDEX_ERROR_REASONS: readonly (DocumentRefusalReason | UnprocessableFileReason)[];

package/dist-vue/packages/models/src/schema/Integration.d.ts

@@ -14,6 +14,12 @@ export declare enum IntegrationProvider {
  */
 export declare const OAUTH_INTEGRATION_PROVIDERS: IntegrationProvider[];
 export declare function isOAuthIntegrationProvider(provider: IntegrationProvider): boolean;
+/**
+ * Providers that receive the leads the agents collect. A document source is
+ * an integration too, enabled like the others, and has nothing to do with a
+ * lead: whoever reads the integrations for leads reads these alone.
+ */
+export declare const CRM_INTEGRATION_PROVIDERS: IntegrationProvider[];
 export declare enum IntegrationSyncStatus {
     Pending = "pending",
     Success = "success",

package/dist-vue/packages/models/src/schema/Media.d.ts

@@ -26,6 +26,16 @@ export declare const SUPPORTED_VIDEO_TYPES: readonly ["video/mp4", "video/webm",
  * `audio/webm`, what a browser records, waits for a test.
  */
 export declare const SUPPORTED_AUDIO_TYPES: readonly ["audio/mpeg", "audio/mp4", "audio/x-m4a", "audio/aac", "audio/wav", "audio/x-wav", "audio/wave", "audio/ogg", "audio/flac", "audio/x-flac"];
+/**
+ * The extension a stored audio of this bare type takes (`.m4a` for
+ * `audio/x-m4a`), or undefined for a type the transcription does not read.
+ */
+export declare const audioExtensionFor: (mimeType: string) => string | undefined;
+/**
+ * The type of an audio named with this extension (`audio/ogg` for `.opus`),
+ * or undefined for an extension the transcription does not read.
+ */
+export declare const audioMimeTypeFor: (extension: string) => string | undefined;
 /**
  * Whether a file is audio of any kind, read or not: what a channel that does
  * not transcribe has to keep away from the model, since most models refuse an
@@ -39,6 +49,14 @@ export declare const isAudioFile: (name?: string, mimeType?: string) => boolean;
  * `audio/vnd.wave`, `audio/opus`): the model reads the bytes, not the type.
  */
 export declare const isTranscribableAudio: (name?: string, mimeType?: string) => boolean;
+/**
+ * The type a file the transcription reads is handled as (spec
+ * `voice-notes-platform-channels.md`, D1): its own without parameters
+ * (`audio/ogg; codecs=opus` is `audio/ogg`), or the one its extension names
+ * when {@link isTranscribableAudio} took it by the extension. Undefined for a
+ * file the transcription does not read.
+ */
+export declare const transcribableAudioType: (name?: string, mimeType?: string) => string | undefined;
 /**
  * What a chat turn made of an audio the user attached (spec
  * `audio-file-transcription.md`, D4), kept on its file part

package/dist-vue/packages/models/src/schema/Notification.d.ts

@@ -27,6 +27,100 @@ export declare const agentWakeupNotificationGroupKey: (chatId: string) => string
 /** One row per organization and admin: the next day's excess bumps it. */
 export declare const headlessQuotaNotificationGroupKey: (organizationId: string) => string;
 export type NotificationType = (typeof NotificationType)[keyof typeof NotificationType];
+/**
+ * The groups of notifications a user turns on and off in the Notifications
+ * section of the profile (docs/specs/notification-preferences.md): the user
+ * never sees a `NotificationType`, only these names.
+ */
+export declare const NotificationCategory: {
+    readonly AgentReplies: "agent_replies";
+    readonly Documents: "documents";
+    readonly Integrations: "integrations";
+    readonly FlaggedConversations: "flagged_conversations";
+    readonly UsageLimits: "usage_limits";
+};
+export type NotificationCategory = (typeof NotificationCategory)[keyof typeof NotificationCategory];
+/** Where a notification reaches the user: the bell of the app, or an email. */
+export declare const NotificationChannel: {
+    readonly InApp: "inApp";
+    readonly Email: "email";
+};
+export type NotificationChannel = (typeof NotificationChannel)[keyof typeof NotificationChannel];
+export interface NotificationCategoryDefinition {
+    types: readonly NotificationType[];
+    /**
+     * The channels the group has, each with its default. A group without
+     * `email` sends no mail, and the profile shows no switch for it.
+     */
+    defaults: {
+        inApp: boolean;
+        email?: boolean;
+    };
+    /**
+     * Shown only to who is owner or admin in at least one organization. A
+     * hidden group still applies, with its defaults.
+     */
+    adminsOnly: boolean;
+}
+/**
+ * Every group with its types, channels and defaults, in the order the profile
+ * lists them. A new `NotificationType` joins a group here, or
+ * {@link ALWAYS_ON_NOTIFICATION_TYPES}, in the PR that adds it: a test checks
+ * that every type is in one of the two.
+ */
+export declare const NOTIFICATION_CATEGORIES: Record<NotificationCategory, NotificationCategoryDefinition>;
+/**
+ * Outside the preferences and always delivered: security, and the notices an
+ * administrator writes.
+ */
+export declare const ALWAYS_ON_NOTIFICATION_TYPES: readonly NotificationType[];
+/** The group of a notification type, `undefined` for one always delivered. */
+export declare function notificationCategoryOf(type: string): NotificationCategory | undefined;
+export declare const NotificationChannelSettingsSchema: z.ZodObject<{
+    inApp: z.ZodOptional<z.ZodBoolean>;
+    email: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * A user's choices by group. Stored as the difference from the defaults, so a
+ * default that changes applies to whoever never touched it; the same shape is
+ * the body of `PUT /me/notification-settings`, which carries only what changed.
+ */
+export declare const NotificationSettingsOverridesSchema: z.ZodRecord<z.ZodEnum<{
+    readonly AgentReplies: "agent_replies";
+    readonly Documents: "documents";
+    readonly Integrations: "integrations";
+    readonly FlaggedConversations: "flagged_conversations";
+    readonly UsageLimits: "usage_limits";
+}> & z.core.$partial, z.ZodObject<{
+    inApp: z.ZodOptional<z.ZodBoolean>;
+    email: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
+export type NotificationChannelSettings = z.infer<typeof NotificationChannelSettingsSchema>;
+export type NotificationSettingsOverrides = z.infer<typeof NotificationSettingsOverridesSchema>;
+/**
+ * Whether a channel of a group is on for a user with these choices: their own
+ * choice, or the group's default. Always false on a channel the group lacks.
+ */
+export declare function isNotificationChannelOn(overrides: NotificationSettingsOverrides | null | undefined, category: NotificationCategory, channel: NotificationChannel): boolean;
+/**
+ * The stored choices after `changes`: only the ones that differ from the
+ * default survive, and a channel the group lacks, or a group that no longer
+ * exists, is dropped.
+ */
+export declare function mergeNotificationOverrides(current: NotificationSettingsOverrides | null | undefined, changes: NotificationSettingsOverrides): NotificationSettingsOverrides;
+/** One group as the profile shows it: `email` only where the group has it. */
+export declare const NotificationSettingSchema: z.ZodObject<{
+    category: z.ZodEnum<{
+        readonly AgentReplies: "agent_replies";
+        readonly Documents: "documents";
+        readonly Integrations: "integrations";
+        readonly FlaggedConversations: "flagged_conversations";
+        readonly UsageLimits: "usage_limits";
+    }>;
+    inApp: z.ZodBoolean;
+    email: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type NotificationSetting = z.infer<typeof NotificationSettingSchema>;
 /**
  * Group key of the admins' notification about a flagged conversation: one row
  * per chat and admin, bumped by every later analysis of that chat.

package/dist-vue/packages/models/src/schema/Organization.d.ts

@@ -1,3 +1,5 @@
+import { AgentBuiltInTool } from './Agent';
+import { IntegrationProvider } from './Integration';
 import { PlatformType } from './Platform';
 import { StoragePolicy } from './Media';
 import * as z from 'zod';
@@ -258,7 +260,21 @@ export declare enum OrganizationFeature {
     ApiTools = "apiTools",
     SubAgents = "subAgents",
     Endpoints = "endpoints",
-    Integrations = "integrations",
+    /**
+     * One flag per integration provider and not one for all of them, for
+     * the same reason as the channels: a contract names the CRM or the
+     * document source it includes. See {@link INTEGRATION_PROVIDER_FEATURES}.
+     */
+    HubSpot = "hubspot",
+    Salesforce = "salesforce",
+    SharePoint = "sharepoint",
+    /**
+     * The leads: the contact form agents show in the chat and the page that
+     * lists what it collected. Off, it reaches the runtime too: the form is
+     * on by default, and every agent would keep collecting leads nobody can
+     * open. See {@link FEATURE_BUILT_IN_TOOLS}.
+     */
+    Leads = "leads",
     /**
      * Files attached to chat messages, on every surface of the agent. Like
      * the voice it is switched on inside the agent settings, so the gate is
@@ -297,6 +313,23 @@ export declare const ORGANIZATION_FEATURE_DEFAULTS: Record<OrganizationFeature,
  * connection service refuses it, and the channels page does not offer it.
  */
 export declare const PLATFORM_CHANNEL_FEATURES: Partial<Record<PlatformType, OrganizationFeature>>;
+/**
+ * The feature flag of each integration provider. A full record, so a
+ * provider added to the enum does not compile until it has its flag.
+ */
+export declare const INTEGRATION_PROVIDER_FEATURES: Record<IntegrationProvider, OrganizationFeature>;
+/**
+ * Built-in tools a feature flag takes away from every agent of the
+ * organization, whatever the agent's own settings say. For a tool that is on
+ * by default: a gate on the switch that turns it on, like the voice has,
+ * would leave it on for every agent that never touched the switch.
+ */
+export declare const FEATURE_BUILT_IN_TOOLS: Partial<Record<OrganizationFeature, AgentBuiltInTool[]>>;
+/**
+ * The built-in tools the flags take away. Only a flag explicitly `false`
+ * counts, so a caller holding no flags at all takes nothing away.
+ */
+export declare const toolsRemovedByFeatures: (features: Partial<OrganizationFeatures> | undefined) => AgentBuiltInTool[];
 /**
  * Free-form keys AND free-form values on purpose. `z.record(z.enum(...))`
  * rejects unknown keys in zod 4, so a feature dropped from the catalog would
@@ -439,6 +472,7 @@ export type OrganizationPublic = z.infer<typeof OrganizationPublicSchema>;
  */
 export declare const OrganizationCapabilitiesSchema: z.ZodObject<{
     crm: z.ZodBoolean;
+    voice: z.ZodBoolean;
 }, z.core.$strip>;
 export type OrganizationCapabilities = z.infer<typeof OrganizationCapabilitiesSchema>;
 export declare const OrganizationsQuerystringSchema: z.ZodObject<{

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@8wave/ai-elements",
     "private": false,
-    "version": "0.117.0",
+    "version": "0.118.0-beta.16",
     "type": "module",
     "scripts": {
         "dev": "vite --port 8082 --open --host",