@opencxh/domain 1.82.0 → 1.84.0

package/dist/entities/ai-conversation/index.d.ts

@@ -0,0 +1 @@
+export * from './types';

package/dist/entities/ai-conversation/types.d.ts

@@ -0,0 +1,25 @@
+export type AIConversationVisibility = "shared" | "personal";
+/**
+ * A single assistant conversation (thread). Grouped into the tools-panel tabs by
+ * `scopeKey`; messages, runs and thread-continuity key on the conversation id.
+ *
+ * - `shared`   → tied to the scope, visible to everyone who may see that scope
+ *                (e.g. the interaction's team). `ownerUserId` is unset.
+ * - `personal` → private to `ownerUserId`, even within a shared scope.
+ *
+ * The scope-owning app declares whether a scope's anchor conversation is shared.
+ */
+export interface AIConversation {
+    id: string;
+    organizationId: string;
+    /** "workspace:<userId>" | "interaction:<id>" | future kinds like "contact:<id>". */
+    scopeKey: string;
+    visibility: AIConversationVisibility;
+    /** Set when `visibility === "personal"`. */
+    ownerUserId?: string;
+    title: string;
+    /** "auto" = the scope-anchor conversation; "user" = opened via the + button. */
+    origin: "auto" | "user";
+    createdAt: number;
+    updatedAt: number;
+}

package/dist/entities/ai-message/types.d.ts

@@ -10,7 +10,7 @@ export interface AIMessageOutput {
 export interface AIMessage {
     id: string;
     organizationId: string;
-    interactionId: string;
+    conversationId: string;
     sender: "user" | "assistant" | "system";
     timestamp: number;
     input: AIMessageInput;
@@ -27,7 +27,7 @@ export interface AIMessage {
  * systemPrompt/enabledTools from it.
  */
 export interface AIMessageAskPayload {
-    interactionId: string;
+    conversationId: string;
     input: AIMessageInput;
     profileId: string;
     previousExternalId?: string;

package/dist/entities/ai-profile/types.d.ts

@@ -1,3 +1,4 @@
+import { OwnerScope } from '../contact/types';
 export interface PredefinedPrompt {
     name: string;
     prompt: string;
@@ -5,6 +6,12 @@ export interface PredefinedPrompt {
 export interface AIProfile<T extends Record<string, any> = Record<string, any>> {
     id: string;
     organizationId: string;
+    /**
+     * Who may use this profile. Company-wide (`org`) or bound to a `team`; profiles
+     * are never personal. Optional only during the migration window - the server
+     * defaults new profiles to `org` and backfills existing ones.
+     */
+    ownerScope?: OwnerScope;
     name: string;
     description?: string;
     accountId: string;
@@ -15,4 +22,10 @@ export interface AIProfile<T extends Record<string, any> = Record<string, any>>
     predefinedPrompts?: PredefinedPrompt[];
     /** Namespaced tool names this profile may use (default: none enabled). */
     enabledTools?: string[];
+    /**
+     * Whether the acting user's PERSONAL MCP tools (their own per-user connections)
+     * are available on this profile, on top of the admin-curated `enabledTools`.
+     * "off" (default) = strictly the curated set; "allow" = also include personal.
+     */
+    personalTools?: "off" | "allow";
 }

package/dist/entities/contact/provider.d.ts

@@ -4,6 +4,15 @@ export interface ContactSearchQuery {
     text?: string;
     scope?: OwnerScope[];
     limit?: number;
+    /**
+     * Channels whose identities the search should cover. The composer passes the
+     * one acting channel; the intent starter passes every channel the user can
+     * act as. Providers search each identity they own among these and merge —
+     * e.g. Microsoft searches the relevant people of every shared mailbox in the
+     * list. Order matters: providers may cap the fan-out, so pass most-relevant
+     * first.
+     */
+    channelIds?: string[];
 }
 export interface ContactProvider {
     id: string;

package/dist/entities/mcp/types.d.ts

@@ -1,3 +1,24 @@
+/** How the AI server authenticates to an MCP server. */
+export type McpAuthMode = "header" | "oauth";
+/** Whether an OAuth-authenticated MCP server uses one shared org account or one per user. */
+export type McpOAuthAccountScope = "user" | "org";
+/**
+ * Client-facing OAuth view for an MCP server. Never carries the client secret
+ * or tokens — those live server-side (entity `oauth.client` / ManagedAccount).
+ */
+export interface McpOAuthClientView {
+    scope: McpOAuthAccountScope;
+    /** Requested scopes (optional override of discovered/default scopes). */
+    scopes?: string[];
+    /** OAuth client_id (manual config or Dynamic Client Registration result). Not secret. */
+    clientId?: string;
+    /** True when a manual client secret is stored (masked; never sent raw). */
+    hasClientSecret?: boolean;
+    /** True when an account exists for the relevant scope/user. */
+    connected?: boolean;
+    /** Health of that account: "connected" (usable), or needs re-auth ("expired"/"error"). */
+    status?: "connected" | "expired" | "error";
+}
 /** Configuration for an external MCP (Model Context Protocol) server, per organization. */
 export interface McpServerConfig {
     id: string;
@@ -6,7 +27,64 @@ export interface McpServerConfig {
     /** Only Streamable HTTP transport is supported for server-side connections. */
     transport: "http";
     url: string;
-    /** Optional auth/extra headers sent on connect (e.g. `Authorization`). */
+    /** Optional auth/extra headers sent on connect (e.g. `Authorization`). Header-mode only. */
     headers?: Record<string, string>;
     enabled: boolean;
+    /** How we authenticate to this server. Defaults to "header" for back-compat. */
+    authMode?: McpAuthMode;
+    /** OAuth settings, present when `authMode === "oauth"`. */
+    oauth?: McpOAuthClientView;
+    /**
+     * Owner of this server DEFINITION: absent/null = org-defined (admin-managed),
+     * set = a user's own custom personal server. Governs who may edit/delete it and
+     * where it is visible; orthogonal to `oauth.scope` (which is about credentials).
+     */
+    ownerUserId?: string;
+    /**
+     * Org-defined servers only: users may connect this personally (the "catalog").
+     * Only meaningful together with `oauth.scope === "user"`.
+     */
+    personalConnect?: boolean;
+}
+/**
+ * Write-only OAuth fields accepted by create/update (not part of the read view).
+ * `clientSecret` is masked on read, mirroring the header-secret pattern.
+ */
+export interface McpServerOAuthInput {
+    scope?: McpOAuthAccountScope;
+    scopes?: string[];
+    clientId?: string;
+    clientSecret?: string;
+}
+/**
+ * A curated, platform-maintained connector template shown in the admin "add from
+ * catalog" picker. Selecting one pre-fills the create endpoint (no secrets - these
+ * providers support Dynamic Client Registration). Not persisted; served read-only.
+ */
+export interface McpCatalogEntry {
+    key: string;
+    name: string;
+    description?: string;
+    /** Grouping label for the catalog picker (e.g. "Project management"). */
+    category?: string;
+    iconUrl?: string;
+    docsUrl?: string;
+    url: string;
+    authMode: McpAuthMode;
+    oauth?: {
+        scope?: McpOAuthAccountScope;
+        scopes?: string[];
+    };
+}
+/** Body accepted by the create/update endpoints (write shape, distinct from the read view). */
+export interface McpServerInput {
+    name?: string;
+    url?: string;
+    enabled?: boolean;
+    /** Header-mode secrets; masked values mean "unchanged". */
+    headers?: Record<string, string>;
+    authMode?: McpAuthMode;
+    oauth?: McpServerOAuthInput;
+    /** Org-defined servers: mark as personally connectable (catalog membership). */
+    personalConnect?: boolean;
 }

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from './entities/kb';
 export * from './entities/topic';
 export * from './entities/ai-account';
 export * from './entities/ai-context';
+export * from './entities/ai-conversation';
 export * from './entities/ai-message';
 export * from './entities/ai-profile';
 export * from './entities/mcp';
@@ -24,6 +25,7 @@ export * from './platform/ai-tools';
 export * from './platform/api';
 export * from './platform/common';
 export * from './platform/capabilities';
+export * from './platform/context';
 export * from './platform/communication';
 export * from './platform/federated';
 export * from './platform/intents';

package/dist/platform/communication.d.ts

@@ -5,6 +5,13 @@ export interface Session {
     providerId: string;
     direction: 'inbound' | 'outbound';
     remoteIdentity: string;
+    /**
+     * Number of remote participants, when the provider can report it. Used by
+     * transcript labeling: with more than one remote party the audio is a single
+     * mixed stream, so `remoteIdentity` can't be trusted to name the speaker and
+     * the label falls back to a generic one. Absent/1 = single remote party.
+     */
+    remoteParticipantCount?: number;
     state: SessionState;
     startTime?: number;
     hasVideo: boolean;

package/dist/platform/context.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Host context resolved for the tools-panel. Any app can contribute one via the
+ * `context.collect` service; the shell picks the highest-priority non-null claim
+ * for the current route and falls back to `{ kind: "global", scopeKey:
+ * "workspace:<userId>" }` when no app claims it.
+ *
+ * `kind` drives tool visibility (`ExtensionConfig.contexts`); `scopeKey` groups
+ * the assistant's conversations; `shared` marks the scope's anchor conversation
+ * as team-shared.
+ */
+export interface HostContext {
+    kind: string;
+    scopeKey: string;
+    /** The scope's anchor conversation is shared with everyone who may see the scope. */
+    shared?: boolean;
+    /** Default title for the anchor conversation. */
+    title?: string;
+    /** Highest wins when multiple apps claim the same route. */
+    priority?: number;
+    /** Extra data providers attach (e.g. interaction, activities, transcripts). */
+    slices?: Record<string, unknown>;
+}

package/dist/platform/storage.d.ts

@@ -1,10 +1,26 @@
+import { OwnerScope } from '../entities/contact/types';
+/**
+ * A virtual folder: a named, scoped root that binds to a storage backend
+ * (a StorageAccount on a storage provider) at a base path. Its `ownerScope`
+ * decides who can see and use it (personal / team / org). Files live inside it.
+ *
+ * Kept named `VirtualMount` for continuity with existing consumers (ui-kit
+ * StorageInput, platform-api); surfaced to users as a "folder".
+ */
 export interface VirtualMount {
     id: string;
+    organizationId?: string;
     name: string;
+    /** Storage provider id (e.g. base64("s3:storage")). */
     providerId: string;
+    /** StorageAccount id backing this folder. Falls back to the provider default when omitted. */
+    accountId?: string;
     basePath: string;
-    policyId: string;
+    /** Who may see and use this folder. */
+    ownerScope: OwnerScope;
     metadata?: Record<string, any>;
+    createdAt?: number;
+    updatedAt?: number;
 }
 export interface FilePointer {
     id: string;
@@ -19,15 +35,19 @@ export interface FilePointer {
     createdAt?: number;
     tags?: string[];
 }
-export type FileAction = 'file:Read' | 'file:Write' | 'file:Delete' | 'file:List' | 'file:Share';
-export interface FilePolicyStatement {
-    effect: 'Allow' | 'Deny';
-    principal: string[];
-    action: FileAction[];
-    resource: string[];
-}
-export interface FilePolicy {
+/**
+ * A linked storage backend account (credentials to an S3 bucket, an FTP host, …).
+ * Backed by the canonical ManagedAccount store, mirroring the AI app's account
+ * pattern. Secrets never reach the UI — this is the public view.
+ */
+export interface StorageAccount {
     id: string;
-    name: string;
-    statements: FilePolicyStatement[];
+    organizationId: string;
+    /** Account-provider id, e.g. base64("s3:account"). */
+    providerId: string;
+    displayName: string;
+    /** Whether this is the org's default account for its provider. */
+    isDefault?: boolean;
+    /** Provider-specific, non-secret fields (region, bucket, basePath, …). */
+    metadata?: Record<string, any>;
 }

package/dist/platform/ui.d.ts

@@ -57,7 +57,11 @@ export interface ToastConfig {
         variant?: 'primary' | 'secondary';
     }[];
 }
-export type ExtensionContext = 'global' | 'call' | 'interaction';
+/**
+ * Well-known context kinds, kept for autocomplete; any app may declare its own
+ * kind (e.g. "contact") via a context provider, so the type stays open.
+ */
+export type ExtensionContext = 'global' | 'call' | 'interaction' | (string & {});
 export interface ExtensionConfig {
     id: string;
     slot: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencxh/domain",
-  "version": "1.82.0",
+  "version": "1.84.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",