@signalcore/ui 1.0.0-beta.0 → 1.0.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalcore/ui",
-  "version": "1.0.0-beta.0",
+  "version": "1.0.0-beta.2",
   "description": "SignalCore's components for the people an agent serves: the chat, the call, the agent's space, and the <signalcore-chat> widget.",
   "keywords": [
     "signalcore",

package/src/AgentAbout.tsx

@@ -150,7 +150,12 @@ export const ABOUT_MESSAGES: AboutMessages = {
   does: "What it does on its own",
   noAutomations: "Nothing on its own yet: it answers when someone writes to it.",
   paused: "Paused",
-  kinds: { schedule: "At a time", webhook: "When called", event: "On an event" },
+  kinds: {
+    schedule: "At a time",
+    webhook: "When called",
+    event: "On an event",
+    platform: "On a message",
+  },
   topics: {
     apps: "Apps",
     tools: "Tools",
@@ -934,11 +939,13 @@ function Gone({ classNames, children }: { classNames: ClassNames; children: Reac
   return <p className={classes(classNames, "sc-about__empty")}>{children}</p>;
 }
 
-/** An automation's mark says its kind: a time, a call from another system, an event. */
+/** An automation's mark says its kind: a time, a call from another system, an event, a
+ * message. */
 const KIND_ICONS: Readonly<Record<AutomationKind, Icon>> = {
   schedule: "clock",
   webhook: "code",
   event: "bell",
+  platform: "message",
 };
 
 /** An app's mark: the host's logo when it draws one, else the provider's, bare. */
@@ -1080,7 +1087,7 @@ function Automations({
               <Row
                 key={automation.id}
                 mark={
-                  automation.provider === undefined ? (
+                  automation.provider === undefined || automation.provider === null ? (
                     <Mark icon={GLYPHS[KIND_ICONS[automation.kind]]} />
                   ) : (
                     appMark(

package/src/AgentChat.tsx

@@ -59,6 +59,7 @@ import type {
   Message,
   Request,
   Step,
+  StepApp,
   StepState,
 } from "./types";
 import {
@@ -1294,7 +1295,12 @@ function Reply({
                 <BuilderStep step={step} words={words} classNames={classNames} />
               ) : (
                 <>
-                  <Mark state={step.state} action={step.action} classNames={classNames} />
+                  <Mark
+                    state={step.state}
+                    action={step.action}
+                    app={step.app ?? null}
+                    classNames={classNames}
+                  />
                   <span>{words.steps[step.action] ?? actionWords(step.action)}</span>
                   {/* What a step answered is the model's, in its words: only why it failed. */}
                   {step.state === "failed" && step.output !== null && <small>{step.output}</small>}
@@ -1393,7 +1399,12 @@ function BuilderStep({
 }) {
   const row = (
     <>
-      <Mark state={step.state} action={step.action} classNames={classNames} />
+      <Mark
+        state={step.state}
+        action={step.action}
+        app={step.app ?? null}
+        classNames={classNames}
+      />
       <span>{words.steps[step.action] ?? actionWords(step.action)}</span>
       {step.state === "failed" && <em>{words.failed}</em>}
     </>
@@ -1417,16 +1428,22 @@ function BuilderStep({
 function Mark({
   state,
   action,
+  app,
   classNames,
 }: {
   state: StepState;
   action: string;
+  app: StepApp | null;
   classNames: ClassNames;
 }) {
   const Glyph = stepGlyph(action);
+  // A connected app's step wears the app's logo once done; only an https one is loaded.
+  const logo = app?.icon && /^https:\/\//i.test(app.icon) ? app.icon : null;
   return (
     <span aria-hidden className={classes(classNames, "sc-chat__mark")}>
-      {state === "done" ? (
+      {state === "done" && logo !== null ? (
+        <img src={logo} alt="" loading="lazy" draggable={false} />
+      ) : state === "done" ? (
         <Glyph />
       ) : state === "running" ? null : (
         <svg viewBox="0 0 14 14" fill="none">

package/src/AgentTasks.tsx

@@ -2,7 +2,7 @@ import { ArrowLeftIcon, TrashIcon } from "@phosphor-icons/react";
 import { useCallback, useEffect, useRef, useState } from "react";
 
 import { Automation } from "./automation/Automation";
-import type { Task } from "./automation/types";
+import { taskCard, type Task } from "./automation/types";
 import { classes } from "./classes";
 import type { Client } from "./client";
 import { Button } from "./kit/Button";
@@ -139,7 +139,7 @@ export function AgentTasks({
           {tasks.map((task) => (
             <Automation
               key={task.id}
-              automation={task}
+              automation={taskCard(task)}
               runs={task.runs}
               switching={busy === task.id}
               onSwitch={(on) => void change(task, () => client.tasks.switch(agentId, task.id, on))}

package/src/VoiceCall.tsx

@@ -92,7 +92,7 @@ export const VOICE_CALL_MESSAGES: VoiceCallMessages = {
     },
     builder: {
       title: (name) => `${name} doesn't take calls`,
-      help: "A squad's builder only writes. Call one of the squad's agents.",
+      help: "The builder only writes. Call one of the agents.",
     },
     refused: {
       title: (name) => `${name} can't take this call`,

package/src/about.ts

@@ -1,9 +1,12 @@
 /**
  * Qué puede: what an agent says about itself and the facts it rests on (`GET /agents/{id}/about`,
  * `POST /agents/{id}/describe`). The words are the model's, written from the agent's folder and
- * stale the moment it changes; the facts are the platform's, read each time.
+ * stale the moment it changes; the facts are the platform's, read each time. Their types are the
+ * contract's (`contract.ts`).
  */
 
+import type * as C from "./contract";
+
 /** The marks the package draws (a topic's, an automation's kind, a note's tone). */
 export const ICONS = [
   "message",
@@ -30,89 +33,33 @@ export const ICONS = [
 
 export type Icon = (typeof ICONS)[number];
 
-/** One automation as the agent tells it: what it does then, and when. */
-export interface Does {
-  /** The automation's id. */
-  automation: string;
-  text: string;
-  /** When it runs, the way a person says it: "Cada día a las 8:00". */
-  when: string;
-}
+/** One automation as the agent tells it: what it does then, and when ("Cada día a las 8:00"). */
+export type Does = C.Does;
 
 /** What the agent says about itself: a lead, what it does, what it asks leave for. */
-export interface About {
-  /** Two or three sentences, first person, in the owner's language. */
-  summary: string;
-  does: Does[];
-  asks: string[];
-}
+export type About = C.About;
 
-export type ActionSource = "default" | "library" | "own";
-
-export interface ActionFact {
-  name: string;
-  description: string;
-  source: ActionSource;
-  on: boolean;
-  needs_approval: boolean;
-  destructive: boolean;
-  /** Its input as the model gets it (JSON Schema); left out by an API from before. */
-  input_schema?: Readonly<Record<string, unknown>> | undefined;
-}
+export type ActionSource = C.ActionRowOut["source"];
 
-export type AutomationKind = "schedule" | "webhook" | "event";
-
-/** Something the agent does on its own: at a time, when another system calls, on an event. */
-export interface AutomationFact {
-  id: string;
-  /** Its file's name, `automations/<name>.py`: how its page is reached. */
-  name: string;
-  kind: AutomationKind;
-  title: string;
-  /** What it does, in the owner's words. */
-  summary: string;
-  /** The same words, for a reader of the older shape. */
-  say: string;
-  /** A cron line and its time zone, for one that runs at a time. */
-  schedule?: string | null | undefined;
-  timezone?: string | null | undefined;
-  /** Where another system calls it, for a webhook (a path on the API). */
-  url?: string | null | undefined;
-  /** For one on an app's event: the app (the connection's name), the event as its provider
-   * names it, and the app as its mark is drawn (`composio:gmail`, the provider's logo). */
-  app?: string | null | undefined;
-  /** The app as people write it (`Google Calendar`). */
-  app_title?: string | null | undefined;
-  event?: string | null | undefined;
-  provider?: string | undefined;
-  icon?: string | null | undefined;
-  /** Off: declared, but it doesn't run. */
-  on: boolean;
-  next_run_at?: string | null | undefined;
-}
+/** One of its actions: where it comes from, whether it is on and asks first, its input. */
+export type ActionFact = C.ActionRowOut;
 
+export type AutomationKind = C.FactAutomation["kind"];
+
+/** Something the agent does on its own: at a time, when another system calls, on an app's event
+ * (with the app's name and mark), on a message. */
+export type AutomationFact = C.FactAutomation;
+
+/** Who brings an app: one of the providers, an MCP server, the business's own API. */
 export type Provider = "arcade" | "composio" | "mcp" | "api";
 
-export interface ConnectionFact {
-  provider: Provider;
-  name: string;
-  /** The app, as the provider names it (`gmail`). */
-  toolkit?: string | undefined;
-  /** The app as people write it (`Google Calendar`). */
-  title?: string | undefined;
-  /** pending · active · error · disconnected */
-  status?: string | undefined;
-  /** The provider's names of what the agent may do in it (`Gmail.SendEmail`). */
-  actions: string[];
-  /** What the provider calls each of them for people (`List Events`), when it says. */
-  titles?: Readonly<Record<string, string>> | undefined;
-  /** A URL to the app's own mark, when the provider gives one. */
-  icon?: string | null | undefined;
-}
+/** An app it was given: its name and mark, and its tools, with their names for people
+ * (`titles`) and as the model calls them (`called`). */
+export type ConnectionFact = C.FactConnection;
 
 /** An app of the agent's as people write it: its provider's name, else its alias made words. */
 export const appTitle = (connection: ConnectionFact): string =>
-  connection.title ?? toolName(connection.name);
+  connection.title || toolName(connection.name);
 
 /** A tool of an app as people read it: its provider's name for it, else its own made words. */
 export const toolTitle = (connection: ConnectionFact, action: string): string =>
@@ -143,7 +90,10 @@ export function actionWords(name: string): string {
 /** The longest name the model takes for a tool (`app/connections` cuts there too). */
 const MAX_TOOL_NAME = 64;
 
-/** `gmail` + `Gmail.SendEmail` → `gmail__Gmail_SendEmail`: the tool the model is given. */
+/**
+ * `gmail` + `Gmail.SendEmail` → `gmail__Gmail_SendEmail`: the tool the model is given.
+ * @deprecated The facts say it: `ConnectionFact.called`.
+ */
 export const generatedName = (alias: string, action: string): string =>
   `${alias}__${action.replace(/[^A-Za-z0-9_]/g, "_")}`.slice(0, MAX_TOOL_NAME);
 
@@ -156,7 +106,7 @@ export function appSteps(connections: readonly ConnectionFact[]): Record<string,
   return Object.fromEntries(
     connections.flatMap((connection) =>
       connection.actions.map((action) => [
-        generatedName(connection.name, action),
+        connection.called[action] ?? generatedName(connection.name, action),
         `${toolTitle(connection, action)} (${appTitle(connection)})`,
       ]),
     ),
@@ -165,85 +115,33 @@ export function appSteps(connections: readonly ConnectionFact[]): Record<string,
 
 export type ChannelKind = "whatsapp" | "instagram" | "email" | "sms" | "web" | "phone";
 
-export interface ChannelFact {
-  kind: ChannelKind;
-  name: string;
-  status: string;
-}
+export type ChannelFact = C.FactChannel;
 
 /** A file the agent can read: its own, or one of the organization's, shared with every agent. */
-export interface FileFact {
-  path: string;
-  size: number;
-  /** Text, Markdown, JSON, YAML or PDF, read by `search_files`; anything else is only kept. */
-  searchable: boolean;
-  /** The organization's, not the agent's own. */
-  shared: boolean;
-}
+export type FileFact = C.FactFile;
 
-/** A line the agent kept with `remember`. */
-export interface MemoryFact {
-  id: string;
-  /** The agent that keeps it; the contact it is about, when it is about one. */
-  agent_id?: string | undefined;
-  contact_id?: string | null | undefined;
-  text: string;
-  created_at: string;
-}
+/** A line the agent kept with `remember`: its own, or about the contact it names. */
+export type MemoryFact = C.MemoryOut;
 
-/** A key the agent may use: its own, or one of the organization's, shared with every agent. */
-export interface VaultFact {
-  name: string;
-  /** The hosts it may be sent to. */
-  hosts?: string[] | undefined;
-  /** The organization's, not the agent's own. */
-  shared?: boolean | undefined;
-}
+/** A key the agent may use: its own, or one of the organization's its access gives it. */
+export type VaultFact = C.FactKey;
 
 /** A table of the organization's the agent may read or write (an agenda, the clients). */
-export interface DataFact {
-  table: string;
-  /** Its name for people, when it has one. */
-  title?: string | null | undefined;
-  can: string[];
-}
+export type DataFact = C.FactTable;
 
-export interface AskFact {
-  agent_id: string;
-  name: string;
-}
+export type AskFact = C.FactAsk;
 
-export type DeviceKind = "extension" | "installer";
+export type DeviceKind = C.FactDevice["kind"];
 
-export interface DeviceFact {
-  kind: DeviceKind;
-  name: string;
-  status: string;
-}
+export type DeviceFact = C.FactDevice;
 
-/** What the agent has, every list present from day one; one whose phase has not come is empty. */
-export interface Facts {
-  actions: ActionFact[];
-  automations: AutomationFact[];
-  connections: ConnectionFact[];
-  channels: ChannelFact[];
-  /** Its own first, then the organization's shared. */
-  files: FileFact[];
-  /** Newest first. */
-  memories: MemoryFact[];
-  vault: VaultFact[];
-  data: DataFact[];
-  asks: AskFact[];
-  devices: DeviceFact[];
-}
+/** What the agent has, every list present from day one; one whose phase has not come is empty:
+ * its files its own first, its memories newest first. */
+export type Facts = C.Facts;
 
-export interface AboutOut {
-  /** Null until the agent has written about itself once. */
-  about: About | null;
-  /** When the words were written; null when the folder changed since, so they are stale. */
-  about_at: string | null;
-  facts: Facts;
-}
+/** What it says (null until written once; `about_at` null when the folder changed since, so the
+ * words are stale) and the facts. */
+export type AboutOut = C.AboutOut;
 
 /**
  * What the panel lists of the facts beside what the agent does on its own, gathered into a few

package/src/automation/cron.ts

@@ -1,5 +1,5 @@
 /**
- * A schedule's cron line, read into what it fires at: the moments of a day (a squad's day, an
+ * A schedule's cron line, read into what it fires at: the moments of a day (the agents' day, an
  * automation's next runs) and the sentence that says it (`whenOf`). Five fields (minute, hour,
  * day of the month, month, day of the week) with `*`, lists, ranges, steps and English names, as
  * the API's croniter reads them; anything past that is not read (null).

package/src/automation/marks.tsx

@@ -51,9 +51,11 @@ export function AppMark({
 const KINDS: Readonly<Record<Exclude<Trigger["kind"], "event">, Icon>> = {
   schedule: ClockIcon,
   webhook: WebhooksLogoIcon,
+  platform: ChatCircleIcon,
 };
 
-/** What starts an automation, as a mark: a clock, a webhook, the app whose event it waits for. */
+/** What starts an automation, as a mark: a clock, a webhook, a message, the app whose event it
+ * waits for. */
 export function TriggerMark({
   trigger,
   size,
@@ -69,10 +71,12 @@ export function TriggerMark({
   return <AppMark name={name} icon={trigger.icon} size={size} apps={apps} />;
 }
 
-/** What started a run: its time, a call, its app's event, a chat with the agent, a test. */
+/** What started a run: its time, a call, its app's event, a message, a chat with the agent, a
+ * test. */
 const BY: Readonly<Record<Exclude<RunBy, "event">, Icon>> = {
   schedule: ClockIcon,
   webhook: WebhooksLogoIcon,
+  platform: ChatCircleIcon,
   agent: ChatCircleIcon,
   test: FlaskIcon,
 };

package/src/automation/messages.ts

@@ -66,6 +66,8 @@ export interface AutomationMessages {
   /** What another kind of trigger waits for. */
   webhook: string;
   event: (app: string | null, event: string | null) => string;
+  /** One of the platform's events: a contact's message stored on a channel. */
+  platform: string;
   /** When it runs next, after when it runs: the day, and the time when the line doesn't say it. */
   next: (day: DayRef, time: string | null) => string;
   /** How it stands, on its pill. */
@@ -124,6 +126,7 @@ export const AUTOMATION_MESSAGES: AutomationMessages = {
   on: (often, days) => `${often}, ${days.charAt(0).toLowerCase()}${days.slice(1)}`,
   custom: "On a schedule of its own",
   webhook: "When another system calls it",
+  platform: "When a message arrives",
   event: (app, event) =>
     event ? `When ${event} in ${app ?? "an app"}` : `On an event in ${app ?? "an app"}`,
   next: (day, time) => {
@@ -171,6 +174,7 @@ export const AUTOMATION_MESSAGES: AutomationMessages = {
       schedule: "scheduled",
       webhook: "webhook",
       event: app ? `${app} event` : "event",
+      platform: "a message",
       agent: "you asked in the chat",
       test: "test",
     })[by],

package/src/automation/types.ts

@@ -1,146 +1,86 @@
 /**
  * An agent's automations and their runs, as the API gives them (v3/AUTOMATIONS.md): what starts
- * each one, the steps its code names, the table it moves, and every run with its record. Written
- * by hand, one to one with the API's answers; times are ISO 8601 in UTC.
+ * each one, the steps its code names, the table it moves, and every run with its record. The
+ * contract's own types (`contract.ts`, generated from the API's); times are ISO 8601 in UTC.
  */
 
+import type * as C from "../contract";
+
 /**
  * What a step uses, as the manifest reads it from the code before any run: an app, the model,
  * the agent, the owner's inbox, a message to a contact on a channel (`sc.send`), a table, the web.
  */
-export interface Use {
-  kind: "app" | "ai" | "agent" | "notify" | "send" | "data" | "http";
-  /** An app's: the connection's name (its alias). */
-  app: string | null;
-  /** An app's: its display name. */
-  title: string | null;
-  /** An app's: its logo (https), when known. */
-  icon: string | null;
-}
+export type Use = C.Use;
 
 /** A step of the code (`sc.step("…")`), in the code's order, with what it uses. */
-export interface Step {
-  name: string;
-  uses: Use[];
-}
+export type Step = C.Step;
 
-/** What starts an automation: a time (cron, on a zone's clock), a call to its URL, an app's event. */
-export interface Trigger {
-  kind: "schedule" | "webhook" | "event";
-  /** Five-field cron. */
-  schedule: string | null;
-  /** IANA zone. */
-  timezone: string | null;
-  /** The webhook's full URL. */
-  url: string | null;
-  /** An event's app: the connection's name, its display name, its logo. */
-  app: string | null;
-  app_title: string | null;
-  /** The provider's event slug, and the event in words when the provider gives them. */
-  event: string | null;
-  event_title: string | null;
-  icon: string | null;
-}
+/** What starts an automation: a time (cron, on a zone's clock), a call to its URL, an app's
+ * event, one of the platform's. */
+export type Trigger = C.TriggerView;
 
-/** The table an automation moves, as counts of its rows per value of one field. */
-export interface Board {
-  table: string;
-  /** The table's title. */
-  title: string;
-  /** The field the rows are counted by. */
-  field: string;
-  /** Per value, biggest first, at most 8. */
-  counts: { value: string; count: number }[];
-}
+/** The table an automation moves, as counts of its rows per value of one field (biggest first,
+ * at most 8). */
+export type Board = C.Board;
 
-export type RunStatus = "running" | "waiting" | "done" | "failed" | "skipped";
+export type RunStatus = C.RunOut["status"];
 
-/** What started a run: its time, a call, an app's event, the agent in a chat, a test. */
-export type RunBy = "schedule" | "webhook" | "event" | "agent" | "test";
+/** What started a run: its time, a call, an app's event, the platform, the agent, a test. */
+export type RunBy = C.RunOut["by"];
 
 /** One start of an automation, whatever started it. */
-export interface Run {
-  id: string;
-  agent_id: string;
-  /** The automation's name. */
-  automation: string;
-  /** The automation's title when it ran. */
-  title: string;
-  by: RunBy;
-  /** Started by the agent: the conversation it was asked in. */
-  conversation_id: string | null;
-  status: RunStatus;
-  /** What the code returned: the run's one line. */
-  summary: string | null;
-  /** Why it failed, in words, naming the step: "Paró en «…»: …". */
-  error: string | null;
-  /** A test: what would change the world was recorded, not done. */
-  dry: boolean;
-  started_at: string;
-  ended_at: string | null;
-  tokens_in: number;
-  tokens_out: number;
-  /** The conversations it opened. */
-  opened: string[];
-}
+export type Run = C.RunOut;
 
 /** One call of a run's record, in the order it was made. */
-export interface RunStep {
-  seq: number;
-  /** The `sc.step` it ran in. */
-  step: string | null;
-  /**
-   * `tool:<app>.<TOOL>` · `ai` · `notify` · `send` · `agent.start` · `data.find` · `data.add` ·
-   * `data.update` · `http` · `files.search` · `memory.remember` · `memory.recall`.
-   */
-  call: string;
-  /** Both trimmed. */
-  input: unknown;
-  output: unknown;
-  error: string | null;
-  ms: number;
-  at: string;
-  /** A test's write: recorded, not done. */
-  would: boolean;
-}
+export type RunStep = C.RunStepOut;
 
 /** A run with its record (`GET /runs/{id}`). */
-export type RunRecord = Run & { steps: RunStep[] };
+export type RunRecord = C.RunDetailOut;
 
-export type AutomationState = "active" | "paused" | "failing";
+export type AutomationState = C.AutomationOut["state"];
 
 /** One automation: `automations/<name>.py` in the agent's folder, with its trigger and its state. */
-export interface Automation {
-  /** Its trigger's id. */
-  id: string;
-  agent_id: string;
-  /** Its file's name; unique per agent. */
-  name: string;
-  title: string;
-  /** What it does, in the owner's words. */
-  summary: string;
-  trigger: Trigger;
-  on: boolean;
-  next_run_at: string | null;
-  steps: Step[];
-  board: Board | null;
-  /** `failing`: its last finished real run failed. */
-  state: AutomationState;
-  /** Its newest run, tests included. */
-  last_run: Run | null;
-}
+export type Automation = C.AutomationOut;
 
 /** An automation with its newest runs (`GET /agents/{id}/automations/{name}`: 20; in a block: 5). */
-export type AutomationView = Automation & { runs: Run[] };
+export type AutomationView = C.AutomationDetailOut;
 
 /**
- * A task the agent runs for one contact (`GET /agents/{id}/tasks`): set up in words in a
- * conversation with them, read as an automation is (its instruction is its `summary`, its trigger
- * a schedule: a cron line, or none for a task once at `next_run_at`), with its newest five runs.
+ * A task the agent runs for one contact (`GET /agents/{id}/tasks`): an instance of an automation
+ * for contacts (`automation`), or of the platform's instruction (its words in `inputs`), on a
+ * schedule (a cron line, or once at `next_run_at`), with its newest five runs.
  */
-export type Task = AutomationView & {
-  contact_id: string;
-  /** The conversation it runs in: the one it was set up in. */
-  conversation_id: string | null;
-  created_at: string;
-};
+export type Task = C.TaskOut;
+
+/** A task as the automation card draws it, from what it is: its words its summary, its trigger
+ * its schedule, failing when its last finished real run failed. */
+export function taskCard(task: Task): AutomationView {
+  const ended = task.runs.filter((run) => run.status !== "running" && run.status !== "waiting");
+  const last = ended.find((run) => !run.dry);
+  const words = task.inputs["instruction"];
+  return {
+    id: task.id,
+    agent_id: task.agent_id,
+    name: task.automation ?? "instruction",
+    title: task.title,
+    summary: typeof words === "string" ? words : "",
+    trigger: {
+      kind: "schedule",
+      schedule: task.schedule,
+      timezone: task.timezone,
+      url: null,
+      app: null,
+      app_title: null,
+      event: null,
+      event_title: null,
+      icon: null,
+    },
+    on: task.on,
+    next_run_at: task.next_run_at,
+    steps: [],
+    board: null,
+    state: !task.on ? "paused" : last?.status === "failed" ? "failing" : "active",
+    last_run: task.runs[0] ?? null,
+    runs: task.runs,
+  };
+}

package/src/automation/when.ts

@@ -24,7 +24,7 @@ export interface When {
   timed: boolean;
 }
 
-/** A trigger in words: its schedule as a sentence, a webhook's call, an app's event. */
+/** A trigger in words: its schedule as a sentence, a webhook's call, an app's event, a message. */
 export function whenOf(trigger: Trigger, words: AutomationMessages, code: string): When {
   switch (trigger.kind) {
     case "schedule":
@@ -33,6 +33,8 @@ export function whenOf(trigger: Trigger, words: AutomationMessages, code: string
         : scheduleOf(trigger.schedule, words, code);
     case "webhook":
       return { text: words.webhook, timed: false };
+    case "platform":
+      return { text: words.platform, timed: false };
     case "event":
       return {
         text: words.event(trigger.app_title ?? trigger.app, trigger.event_title),