@signalcore/ui 1.0.0-beta.1 → 1.0.0-beta.3

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,12 @@ 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 "manual":
+      return { text: words.manual, timed: false };
+    case "after":
+      return { text: words.after(trigger.after ?? null), timed: false };
     case "event":
       return {
         text: words.event(trigger.app_title ?? trigger.app, trigger.event_title),

package/src/blocks.ts

@@ -100,6 +100,30 @@ export interface AutomationBlock {
   view: AutomationView | null;
 }
 
+/**
+ * How the connection an app's card asked for stands: its name and logo, and where the person
+ * authorizes it while it waits for them.
+ */
+export interface ConnectView {
+  title: string;
+  icon: string | null;
+  status: "pending" | "active" | "error" | "disconnected";
+  url: string | null;
+}
+
+/**
+ * An app for the person to connect, drawn by the platform alone (the agent's `connect_app`,
+ * never composed): its name and logo, the line the agent wrote of what it will do with it, and
+ * the button that opens its consent page; the API fills in `connection`, and the card changes
+ * live as it does (waiting, working, failed). Null while there is none yet.
+ */
+export interface ConnectBlock {
+  type: "connect";
+  app: string;
+  purpose: string;
+  connection: ConnectView | null;
+}
+
 // --- Action -------------------------------------------------------------------------------
 
 /** One thing the person can do: pressing it sends `action`, or, with `url`, opens that page. */
@@ -238,6 +262,7 @@ export type Block =
   | ImageBlock
   | AutomationBlock
   | FileBlock
+  | ConnectBlock
   | ButtonBlock
   | ChoiceBlock
   | FormBlock;

package/src/browser.ts

@@ -6,7 +6,7 @@
 import type { BrowserFrame, BrowserInput, Message } from "./types";
 
 /** The action that hands the person the browser; the turn waits on it until they give it back. */
-export const HAND_OVER = "browser_hand_over";
+const HAND_OVER = "browser_hand_over";
 
 /**
  * The browser's screen as it comes: the latest picture, and whoever watches. Kept out of the
@@ -66,7 +66,7 @@ export function siteOf(url: string): { host: string; rest: string } {
   }
 }
 
-export interface Size {
+interface Size {
   width: number;
   height: number;
 }
@@ -86,7 +86,7 @@ export function pointOf(
 }
 
 /** DevTools' mask of the keys held with another: Alt 1, Ctrl 2, Meta 4, Shift 8. */
-export function modifiersOf(event: {
+function modifiersOf(event: {
   altKey: boolean;
   ctrlKey: boolean;
   metaKey: boolean;
@@ -268,7 +268,7 @@ export function bytesOf(base64: string): Uint8Array<ArrayBuffer> {
 }
 
 /** Draws a picture on a canvas, unless a newer one comes while it is still being decoded. */
-export interface Painter {
+interface Painter {
   paint: (jpeg: string) => void;
   dispose: () => void;
 }

package/src/call.ts

@@ -34,7 +34,7 @@ export type CallProblem =
   | "unsupported"
   /** Calls aren't set up where the agent works (the API refused with `no_calls`). */
   | "off"
-  /** The agent takes no calls: a squad's builder (`builder`). */
+  /** The agent takes no calls: the builder (`builder`). */
   | "builder"
   /** The API wouldn't make the call, for any other reason it named. */
   | "refused"

package/src/client.ts

@@ -127,8 +127,10 @@ export interface Client {
     /** Takes one memory from it. */
     forget: (id: string, memoryId: string) => Promise<void>;
     /**
-     * The owner's call with the agent, from the browser (v3/VOICE.md): the call and its
-     * conversation (a test) made now, and where to join it (`VoiceCall`'s `connect`).
+     * The owner's call with the agent, from our own app (v3/VOICE.md): the call and its
+     * conversation (a test) made now, and where to join it (`VoiceCall`'s `connect`). App only:
+     * it is `/api`'s, signed in by the owner's cookie, and 404s on `/v1`; a host's page calls with
+     * `conversations.call(agentId)`.
      */
     call: (id: string) => Promise<CallToken>;
   };
@@ -169,8 +171,14 @@ export interface Client {
   conversations: {
     /** One conversation with its messages. */
     get: (id: string) => Promise<ConversationDetail>;
-    /** A new conversation with an agent. */
-    start: (agentId: string) => Promise<Conversation>;
+    /** The agent's conversations, newest first: a person's own only, each with what is unread. */
+    list: (agentId: string) => Promise<Conversation[]>;
+    /** A new conversation with an agent, titled when given. */
+    start: (agentId: string, options?: { title?: string | undefined }) => Promise<Conversation>;
+    /** How far the person has read it: all of it, now. */
+    read: (id: string) => Promise<Conversation>;
+    /** Its title, as the person gives it. */
+    rename: (id: string, title: string) => Promise<Conversation>;
     /** The files that arrived in a conversation: attached, sent through a form. */
     files: (id: string) => Promise<ConversationFile[]>;
     /**
@@ -201,6 +209,10 @@ export interface Client {
 
 const seg = encodeURIComponent;
 
+/** A request's JSON body. */
+const body = (value: unknown): Blob =>
+  new Blob([JSON.stringify(value)], { type: "application/json" });
+
 /** A file's path in a URL: each name of it encoded, the slashes between them kept. */
 const filePath = (path: string): string => path.split("/").map(seg).join("/");
 
@@ -357,11 +369,7 @@ export function createClient(options: ClientOptions): Client {
     tasks: {
       list: (agentId) => json("GET", `/agents/${seg(agentId)}/tasks`),
       switch: (agentId, taskId, on) =>
-        json(
-          "PATCH",
-          `/agents/${seg(agentId)}/tasks/${seg(taskId)}`,
-          new Blob([JSON.stringify({ on })], { type: "application/json" }),
-        ),
+        json("PATCH", `/agents/${seg(agentId)}/tasks/${seg(taskId)}`, body({ on })),
       remove: (agentId, taskId) => run("DELETE", `/agents/${seg(agentId)}/tasks/${seg(taskId)}`),
     },
     channels: {
@@ -370,7 +378,15 @@ export function createClient(options: ClientOptions): Client {
     },
     conversations: {
       get: (id) => json("GET", `/conversations/${seg(id)}`),
-      start: (agentId) => json("POST", `/agents/${seg(agentId)}/conversations`),
+      list: (agentId) => json("GET", `/agents/${seg(agentId)}/conversations`),
+      start: (agentId, { title } = {}) =>
+        json(
+          "POST",
+          `/agents/${seg(agentId)}/conversations`,
+          title === undefined ? undefined : body({ title }),
+        ),
+      read: (id) => json("POST", `/conversations/${seg(id)}/read`, body({})),
+      rename: (id, title) => json("PATCH", `/conversations/${seg(id)}`, body({ title })),
       files: (id) => json("GET", `/conversations/${seg(id)}/files`),
       upload: (id, file, options) => sendFile(`/conversations/${seg(id)}/files`, file, options),
       play: async (id, fileId) => {