@segmentstream/ontology 0.92.1 → 0.93.0

package/dist/service/chat/reads.d.ts

@@ -5,7 +5,12 @@ import { CurrentPrincipal } from "../authentication.js";
 import type { OntologyBackend } from "../runtime-contract.js";
 import type { ConversationTransport } from "../agent/conversations.js";
 import type { ChatList, ChatHistory } from "./schemas.js";
-export declare function chatReads(backend: OntologyBackend["Service"], conversations?: ConversationTransport, attribution?: ChatAttributionSettings): {
+export declare function chatReads(backend: OntologyBackend["Service"], options: {
+    /** The providers whose chats are listed, as `listedChatProviders` gives them. */
+    readonly providers: ReadonlyArray<string>;
+    readonly conversations?: ConversationTransport;
+    readonly attribution?: ChatAttributionSettings;
+}): {
     list: (input: typeof ChatList.Type) => Effect.Effect<{
         items: {
             id: string;

package/dist/service/chat/reads.js

@@ -5,13 +5,16 @@ import { CurrentPrincipal } from "../authentication.js";
 import { currentCaller } from "../caller-context.js";
 import { chatAttribution } from "./attribution.js";
 import { chatResolver, groupConversation, isChatMember } from "./resolve.js";
-export function chatReads(backend, conversations, attribution) {
+/** The providers whose archived conversations are keyed by the chat a destination names. */
+const HISTORY_PROVIDERS = ["telegram"];
+export function chatReads(backend, options) {
+    const { providers, conversations, attribution } = options;
     return {
         list: (input) => Effect.gen(function* () {
             const principal = yield* CurrentPrincipal;
             const caller = yield* currentCaller;
             const query = input.query?.toLowerCase();
-            const items = (yield* chatResolver(backend, principal).list(input.chat))
+            const items = (yield* chatResolver(backend, principal, providers).list(input.chat))
                 .filter((item) => query === undefined || item.title.toLowerCase().includes(query))
                 .sort((a, b) => a.id.localeCompare(b.id));
             const user = yield* backend.get({ entity: "user", id: principal.id });
@@ -39,7 +42,10 @@ export function chatReads(backend, conversations, attribution) {
             if (principal.kind !== "member") {
                 return yield* new PermissionDenied({ message: "Only members may read conversations." });
             }
-            const target = yield* chatResolver(backend, principal, "telegram", {
+            // History reads Telegram chats only. Other channels archive a conversation under their
+            // session's address with private coordinates, not under the chat a destination names, so
+            // their history would be incomplete until the archive keys them the same way.
+            const target = yield* chatResolver(backend, principal, HISTORY_PROVIDERS, {
                 memberGroups: true,
             }).resolve(input.chat);
             // A group's members read its history, as they read its attachments; agent_chat:read reads

package/dist/service/chat/resolve.d.ts

@@ -25,7 +25,11 @@ export declare function isChatMember(backend: OntologyBackend["Service"], princi
  * reads those chats' attachments: being in a chat is enough, `agent_chat:read` reads them all.
  */
 export declare function withChatMembership(transport: ConversationTransport, backend: OntologyBackend["Service"]): ConversationTransport;
-export declare function chatResolver(backend: OntologyBackend["Service"], principal: Principal, provider?: string, options?: {
+/**
+ * Resolves the chats of `providers`: their group chats in the registry, and each member's private
+ * chat on each provider they have a live identity on, `<provider>:private:<member id>`.
+ */
+export declare function chatResolver(backend: OntologyBackend["Service"], principal: Principal, providers: ReadonlyArray<string>, options?: {
     /** Also resolve the group chats a member is in without chat read or post permission. */
     readonly memberGroups?: boolean;
 }): {

package/dist/service/chat/resolve.js

@@ -65,7 +65,11 @@ export function withChatMembership(transport, backend) {
             cause,
         })), Effect.flatMap((memberGroups) => transport({ ...input, memberGroups })));
 }
-export function chatResolver(backend, principal, provider = "telegram", options = {}) {
+/**
+ * Resolves the chats of `providers`: their group chats in the registry, and each member's private
+ * chat on each provider they have a live identity on, `<provider>:private:<member id>`.
+ */
+export function chatResolver(backend, principal, providers, options = {}) {
     const canGroup = isAllowed("agent_chat:read", principal) || isAllowed("agent_chat:post_message", principal);
     const memberGroups = options.memberGroups === true && principal.kind === "member";
     const canDirectory = isAllowed("user:read", principal) || isAllowed("agent_chat:post_message", principal);
@@ -73,21 +77,22 @@ export function chatResolver(backend, principal, provider = "telegram", options
         if (!canGroup && principal.kind !== "member") {
             return yield* denied();
         }
-        const privateId = chat?.startsWith(`${provider}:private:`)
-            ? chat.slice(`${provider}:private:`.length)
-            : undefined;
+        const named = providers.find((provider) => chat?.startsWith(`${provider}:private:`));
+        const privateId = named === undefined ? undefined : chat.slice(`${named}:private:`.length);
         const groupId = chat !== undefined && UUID.test(chat);
         const filters = [
+            { provider: { in: [...providers] } },
             ...(chat === undefined ? [] : [groupId ? { id: { eq: chat } } : { title: { eq: chat } }]),
             ...(canGroup ? [] : [memberOf(principal)]),
         ];
-        const groups = (!canGroup && !memberGroups) || privateId !== undefined
+        const groups = (!canGroup && !memberGroups) || privateId !== undefined || providers.length === 0
             ? []
-            : yield* records(backend, "agent_chat", filters.length === 0
-                ? {}
-                : { where: filters.length === 1 ? filters[0] : { and: filters } });
+            : yield* records(backend, "agent_chat", {
+                where: filters.length === 1 ? filters[0] : { and: filters },
+            });
         const result = groups
-            .filter((row) => chat === undefined || row.id === chat || row.title === chat)
+            .filter((row) => providers.includes(String(row.provider)) &&
+            (chat === undefined || row.id === chat || row.title === chat))
             .map((row) => ({
             id: String(row.id),
             title: String(row.title),
@@ -119,16 +124,18 @@ export function chatResolver(backend, principal, provider = "telegram", options
                 continue;
             }
             const identities = yield* backend.agents.listIdentities(member.principal.id);
-            const identity = identities.find((item) => item.provider === provider && item.revokedAt === null);
-            if (identity !== undefined) {
-                result.push({
-                    id: `${provider}:private:${member.principal.id}`,
-                    title: member.name,
-                    provider,
-                    external_id: identity.externalId,
-                    kind: "private",
-                    participantIds: [member.principal.id],
-                });
+            for (const provider of named === undefined ? providers : [named]) {
+                const identity = identities.find((item) => item.provider === provider && item.revokedAt === null);
+                if (identity !== undefined) {
+                    result.push({
+                        id: `${provider}:private:${member.principal.id}`,
+                        title: member.name,
+                        provider,
+                        external_id: identity.externalId,
+                        kind: "private",
+                        participantIds: [member.principal.id],
+                    });
+                }
             }
         }
         return result;

package/dist/service/chat/routes.js

@@ -8,6 +8,7 @@ import { RequestId, failureResponse } from "../errors.js";
 import { OntologyBackend } from "../runtime-contract.js";
 import { identityToken, makeOperations } from "../operations.js";
 import { ConversationSearch } from "../agent/conversations.js";
+import { listedChatProviders } from "./providers/index.js";
 import { chatReads } from "./reads.js";
 import { withChatMembership } from "./resolve.js";
 import { ChatList, ChatHistory } from "./schemas.js";
@@ -16,7 +17,11 @@ export function chatRoutes(options) {
         const router = yield* HttpRouter.HttpRouter;
         const backend = yield* OntologyBackend;
         const conversations = options.conversations && withChatMembership(options.conversations, backend);
-        const reads = chatReads(backend, conversations, options.built.plan.ontology.config.chat?.attribution);
+        const reads = chatReads(backend, {
+            providers: listedChatProviders(options.built.plan.ontology.manifest.chat),
+            conversations,
+            attribution: options.built.plan.ontology.config.chat?.attribution,
+        });
         const operations = makeOperations(backend, options.built.plan, options.hooks, options.connections, options.replicate, options.chatDelivery);
         const planned = options.built.plan.entities.find((entity) => entity.name === "agent_chat");
         const action = planned.actions.find((candidate) => candidate.name === "post_message");

package/dist/service/mcp/server.js

@@ -14,6 +14,7 @@ import { CONFIRMATION_PREVIEW_METHOD, previewLocale, withoutConfirmation } from
 import { consumeChatEnvelope, CurrentChatCall } from "../chat/envelope.js";
 import { ChatList, ChatHistory, ChatPostWire, RuntimeChatPostWire } from "../chat/schemas.js";
 import { ChatPostResult } from "../../chat.js";
+import { listedChatProviders } from "../chat/providers/index.js";
 import { chatReads } from "../chat/reads.js";
 import { withChatMembership } from "../chat/resolve.js";
 import { catalogFor } from "../catalog.js";
@@ -831,7 +832,11 @@ export function mcpLayer(options) {
         const operations = makeOperations(backend, options.built.plan, options.hooks, options.connections, options.replicate, options.chatDelivery);
         const conversations = options.conversations && withChatMembership(options.conversations, backend);
         const server = {
-            chats: chatReads(backend, conversations, options.built.plan.ontology.config.chat?.attribution),
+            chats: chatReads(backend, {
+                providers: listedChatProviders(options.built.plan.ontology.manifest.chat),
+                conversations,
+                attribution: options.built.plan.ontology.config.chat?.attribution,
+            }),
             built: options.built,
             tools,
             discovery: createDiscovery(options.built, tools),

package/dist/service/mcp/tools.js

@@ -9,6 +9,7 @@ import { actionInputJsonSchema } from "../../runtime/generated-actions.js";
 import { uploadFields } from "../../storage/attachments.js";
 import { MEMBER_FILE_SCHEMAS } from "../member-files.js";
 import { ConversationSearch } from "../agent/conversations.js";
+import { declaredChatProviders } from "../chat/providers/index.js";
 import { runtimeAllows } from "./runtime-policy.js";
 import { confirmationFacts, needsConfirmation, withConfirmation, } from "./confirmation.js";
 import { ChatList, ChatListResult, ChatHistory, ChatPostWire, RuntimeChatPostWire, } from "../chat/schemas.js";
@@ -735,7 +736,11 @@ export function mcpTools(built, conversations = false, storage = {}, navigation
             ...original,
             inputSchema: encodedJsonSchema(ChatPostWire),
             outputSchema: encodedJsonSchema(ChatPostResult),
-            ...(manifest.chat?.telegram === undefined ? {} : { _meta: { [CHAT_POST_META]: 1 } }),
+            // The same protocol for every provider: an agent that cannot post to one refuses its
+            // destinations when it describes the post.
+            ...(declaredChatProviders(manifest.chat).length === 0
+                ? {}
+                : { _meta: { [CHAT_POST_META]: 1 } }),
             annotations: {
                 readOnlyHint: false,
                 destructiveHint: false,

package/dist/service/schemas.d.ts

@@ -452,6 +452,12 @@ export declare const Catalog: Schema.decodeTo<Schema.Struct<{
         readonly telegram: Schema.optionalKey<Schema.Struct<{
             readonly connection: Schema.String;
         }>>;
+        readonly slack: Schema.optionalKey<Schema.Struct<{
+            readonly connection: Schema.String;
+        }>>;
+        readonly whatsapp: Schema.optionalKey<Schema.Struct<{
+            readonly connection: Schema.String;
+        }>>;
         readonly attribution: Schema.optionalKey<Schema.Struct<{
             readonly template: Schema.optionalKey<Schema.String>;
             readonly separator: Schema.optionalKey<Schema.String>;
@@ -681,6 +687,12 @@ export declare const Catalog: Schema.decodeTo<Schema.Struct<{
         readonly telegram: Schema.optionalKey<Schema.Struct<{
             readonly connection: Schema.String;
         }>>;
+        readonly slack: Schema.optionalKey<Schema.Struct<{
+            readonly connection: Schema.String;
+        }>>;
+        readonly whatsapp: Schema.optionalKey<Schema.Struct<{
+            readonly connection: Schema.String;
+        }>>;
         readonly attribution: Schema.optionalKey<Schema.Struct<{
             readonly template: Schema.optionalKey<Schema.String>;
             readonly separator: Schema.optionalKey<Schema.String>;

package/dist/slack.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Slack's text for an exact chat post. The ontology service sends it and the agent's
+ * confirmation computes it from the same function, so the digest the member approves and the
+ * text delivered are the same.
+ */
+/** The most characters Slack accepts in `chat.postMessage`'s `markdown_text`. */
+export declare const SLACK_MESSAGE_LIMIT = 12000;
+/** Text that Slack's Markdown shows as it is: every character it could read as syntax escaped. */
+export declare function escapeSlackMarkdown(text: string): string;
+/**
+ * The member's exact Markdown, which Slack renders, then the separator and the attribution as
+ * literal text, the attribution in italics. Neither can open or close a construct of the member's
+ * Markdown.
+ */
+export declare function renderSlack(markdown: string, attribution: string, separator?: string): string;

package/dist/slack.js

@@ -0,0 +1,21 @@
+/**
+ * Slack's text for an exact chat post. The ontology service sends it and the agent's
+ * confirmation computes it from the same function, so the digest the member approves and the
+ * text delivered are the same.
+ */
+/** The most characters Slack accepts in `chat.postMessage`'s `markdown_text`. */
+export const SLACK_MESSAGE_LIMIT = 12_000;
+/** The ASCII punctuation Markdown can read as syntax, which a backslash makes literal. */
+const MARKDOWN_SYNTAX = /[\\`*_~[\](){}<>#+\-.!|&]/gu;
+/** Text that Slack's Markdown shows as it is: every character it could read as syntax escaped. */
+export function escapeSlackMarkdown(text) {
+    return text.replace(MARKDOWN_SYNTAX, "\\$&");
+}
+/**
+ * The member's exact Markdown, which Slack renders, then the separator and the attribution as
+ * literal text, the attribution in italics. Neither can open or close a construct of the member's
+ * Markdown.
+ */
+export function renderSlack(markdown, attribution, separator = "\n\n") {
+    return `${markdown}${escapeSlackMarkdown(separator)}_${escapeSlackMarkdown(attribution)}_`;
+}

package/dist/whatsapp.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WhatsApp's text for an exact chat post. The ontology service sends it and the agent's
+ * confirmation computes it from the same function, so the digest the member approves and the
+ * text delivered are the same.
+ */
+/** The most characters WhatsApp accepts in a text message's `body`. */
+export declare const WHATSAPP_MESSAGE_LIMIT = 4096;
+/** Text that WhatsApp shows as it is: every formatting marker replaced by its look-alike. */
+export declare function literalWhatsAppText(text: string): string;
+/**
+ * The member's text as written, then the separator and the attribution as literal text, the
+ * attribution in italics. Neither can open or close the member's formatting.
+ */
+export declare function renderWhatsApp(text: string, attribution: string, separator?: string): string;

package/dist/whatsapp.js

@@ -0,0 +1,29 @@
+/**
+ * WhatsApp's text for an exact chat post. The ontology service sends it and the agent's
+ * confirmation computes it from the same function, so the digest the member approves and the
+ * text delivered are the same.
+ */
+/** The most characters WhatsApp accepts in a text message's `body`. */
+export const WHATSAPP_MESSAGE_LIMIT = 4096;
+/**
+ * WhatsApp's formatting markers (`*bold*`, `_italic_`, `~strikethrough~`, `` ` `` code) and
+ * the look-alike each becomes. WhatsApp has no escape character, so a marker in text the
+ * platform adds is replaced by a character WhatsApp never reads as formatting.
+ */
+const MARKERS = {
+    "*": "∗",
+    _: "＿",
+    "~": "∼",
+    "`": "ˋ",
+};
+/** Text that WhatsApp shows as it is: every formatting marker replaced by its look-alike. */
+export function literalWhatsAppText(text) {
+    return text.replace(/[*_~`]/gu, (marker) => MARKERS[marker]);
+}
+/**
+ * The member's text as written, then the separator and the attribution as literal text, the
+ * attribution in italics. Neither can open or close the member's formatting.
+ */
+export function renderWhatsApp(text, attribution, separator = "\n\n") {
+    return `${text}${literalWhatsAppText(separator)}_${literalWhatsAppText(attribution)}_`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segmentstream/ontology",
-  "version": "0.92.1",
+  "version": "0.93.0",
   "description": "Define a SegmentStream workspace app's ontology: entities, relationships, roles and actions, written with Effect.",
   "license": "Apache-2.0",
   "author": "SegmentStream",
@@ -29,6 +29,14 @@
       "types": "./dist/telegram.d.ts",
       "import": "./dist/telegram.js"
     },
+    "./slack": {
+      "types": "./dist/slack.d.ts",
+      "import": "./dist/slack.js"
+    },
+    "./whatsapp": {
+      "types": "./dist/whatsapp.d.ts",
+      "import": "./dist/whatsapp.js"
+    },
     "./channel-session": {
       "types": "./dist/channel-session.d.ts",
       "import": "./dist/channel-session.js"