@agentprojectcontext/apx 1.80.2 → 1.89.1

package/src/interfaces/web/src/lib/api/agents.ts

@@ -1,21 +1,40 @@
-import { http } from "../http";
-import type { AgentDetail, AgentEntry, ChatUsage } from "../../types/daemon";
+import { http, streamNdjson } from "../http";
+import type { AgentDetail, AgentEntry, ChatStreamEvent, ChatUsage } from "../../types/daemon";
 
 export const Agents = {
   list:   (pid: string, opts?: { stats?: boolean }) =>
     http.get<AgentEntry[]>(`/api/projects/${pid}/agents${opts?.stats ? "?stats=1" : ""}`),
   get:    (pid: string, slug: string) => http.get<AgentDetail>(`/api/projects/${pid}/agents/${slug}`),
-  create: (pid: string, body: Partial<AgentEntry> & { slug: string }) =>
+  create: (pid: string, body: Partial<AgentEntry> & { slug: string; system?: string }) =>
     http.post<AgentEntry>(`/api/projects/${pid}/agents`, body),
   update: (pid: string, slug: string, body: Partial<AgentEntry> & { system?: string }) =>
     http.patch<AgentEntry>(`/api/projects/${pid}/agents/${encodeURIComponent(slug)}`, body),
   remove: (pid: string, slug: string) =>
     http.del<{ ok: boolean }>(`/api/projects/${pid}/agents/${encodeURIComponent(slug)}`),
-  chat: (pid: string, slug: string, body: { prompt: string; conversation_id?: string; model?: string; channel?: string }) =>
+  // Duplicate an agent server-side into a fresh "<slug>-n" (Name gains " (n)"),
+  // carrying its prompt + memory. Returns the new agent so the caller can open it.
+  clone: (pid: string, slug: string) =>
+    http.post<AgentEntry>(`/api/projects/${pid}/agents/${encodeURIComponent(slug)}/clone`, {}),
+  // Rename an agent's slug (moves its file + runtime dir, repoints Parent refs
+  // and routines). Returns the agent at its new slug — the caller must navigate
+  // to it, since the resource URL changed.
+  rename: (pid: string, slug: string, newSlug: string) =>
+    http.post<AgentEntry>(`/api/projects/${pid}/agents/${encodeURIComponent(slug)}/rename`, { slug: newSlug }),
+  chat: (pid: string, slug: string, body: { prompt: string; conversation_id?: string; model?: string; channel?: string; attachments?: { path: string; name?: string }[] }) =>
     http.post<{ conversation_id: string; text: string; usage?: ChatUsage; engine: string }>(
       `/api/projects/${pid}/agents/${encodeURIComponent(slug)}/chat`,
       body,
     ),
+  // The same turn, streamed token-by-token (NDJSON) — identical event vocabulary
+  // to the super-agent stream, so the chat renders a project agent's answer as it
+  // writes instead of a blank wait that ends in the whole reply at once.
+  chatStream: (
+    pid: string,
+    slug: string,
+    body: { prompt: string; conversation_id?: string; model?: string; channel?: string; attachments?: { path: string; name?: string }[] },
+    onEvent: (ev: ChatStreamEvent) => void,
+    signal?: AbortSignal,
+  ) => streamNdjson<ChatStreamEvent>(`/api/projects/${pid}/agents/${encodeURIComponent(slug)}/chat/stream`, body, onEvent, signal),
   memory: {
     get: (pid: string, slug: string) =>
       http.get<{ body: string }>(`/api/projects/${pid}/agents/${slug}/memory`),

package/src/interfaces/web/src/lib/api/code.ts

@@ -44,6 +44,14 @@ export interface CodeSessionRow {
   updatedAt: string;
   messageCount: number;
   hasGit: boolean;
+  /**
+   * Which project the session lives in. Only the cross-project list fills these
+   * — every other read is already scoped to a project. A session id is NOT
+   * addressable on its own, so a row without its `pid` is a row the UI cannot
+   * open; treat the pair as the identity.
+   */
+  pid?: string;
+  projectName?: string | null;
 }
 
 /** Full session with transcript. */
@@ -83,6 +91,15 @@ const base = (pid: string | number) => `/api/projects/${pid}/code/sessions`;
 
 export const Code = {
   sessions: {
+    /**
+     * Every project's sessions, newest-updated first. This is the DEFAULT list:
+     * a session started from another cwd (`apx exec --code`) belongs to
+     * whichever project that cwd resolved to, and scoping the list to the
+     * project the panel happens to be showing made those simply disappear.
+     */
+    listAll: () =>
+      http.get<{ sessions: CodeSessionRow[] }>("/api/code/sessions").then((r) => r.sessions),
+
     list: (pid: string | number) =>
       http.get<{ sessions: CodeSessionRow[] }>(base(pid)).then((r) => r.sessions),
 

package/src/interfaces/web/src/lib/api/commitments.ts

@@ -1,6 +1,8 @@
 import { http, unwrapPage } from "../http";
 
-export type CommitmentState = "open" | "kept" | "missed";
+// "dropped" = filed by mistake. Deliberately not a synonym for "missed": one
+// says you failed a person, the other says nobody was ever waiting.
+export type CommitmentState = "open" | "kept" | "missed" | "dropped";
 
 export type CommitmentEntry = {
   id: string;
@@ -52,6 +54,10 @@ export const Commitments = {
     http.post<CommitmentEntry>(`/api/projects/${pid}/commitments/${id}/kept`, { note }),
   missed: (pid: string, id: string, note?: string) =>
     http.post<CommitmentEntry>(`/api/projects/${pid}/commitments/${id}/missed`, { note }),
+  drop: (pid: string, id: string, note?: string) =>
+    http.post<CommitmentEntry>(`/api/projects/${pid}/commitments/${id}/drop`, { note }),
+  patch: (pid: string, id: string, patch: Partial<CommitmentEntry>) =>
+    http.patch<CommitmentEntry>(`/api/projects/${pid}/commitments/${id}`, { patch }),
   renegotiate: (pid: string, id: string, due: string, note?: string) =>
     http.post<CommitmentEntry>(`/api/projects/${pid}/commitments/${id}/renegotiate`, { due, note }),
 };

package/src/interfaces/web/src/lib/api/conversations.ts

@@ -1,28 +1,55 @@
 import { http } from "../http";
 import type { ConversationDetail, ConversationListEntry, ThreadListEntry, ThreadDetail } from "../../types/daemon";
 
+/**
+ * One path segment, safe to paste into a URL.
+ *
+ * Agent slugs and thread ids are NAMES, not identifiers we mint, and a coding
+ * CLI brings its own: `opencode#bg`, and with it the pair id
+ * `opencode#bg~tester`. Interpolated raw, everything from the `#` onward became
+ * the URL's fragment and never left the browser — the daemon saw
+ * `…/threads/a2a/opencode`, answered "thread not found", and each of those
+ * chats was a 404 you could see in the list but not open.
+ */
+const seg = (s: string | number) => encodeURIComponent(String(s));
+
 export const Conversations = {
-  list: (pid: string, slug: string) =>
-    http.get<ConversationListEntry[]>(`/api/projects/${pid}/agents/${slug}/conversations`),
+  list: (pid: string, slug: string, includeArchived = false) =>
+    http.get<ConversationListEntry[]>(
+      `/api/projects/${pid}/agents/${seg(slug)}/conversations${includeArchived ? "?include_archived=1" : ""}`,
+    ),
   get:  (pid: string, slug: string, id: string) =>
-    http.get<ConversationDetail>(`/api/projects/${pid}/agents/${slug}/conversations/${id}`),
+    http.get<ConversationDetail>(`/api/projects/${pid}/agents/${seg(slug)}/conversations/${seg(id)}`),
   // Super-agent channel threads (telegram, web quick-chat, desktop …) derived
   // from the global message ledger — one thread per channel+day.
-  threads: (pid: string) =>
-    http.get<ThreadListEntry[]>(`/api/projects/${pid}/super-agent/threads`),
+  threads: (pid: string, includeArchived = false) =>
+    http.get<ThreadListEntry[]>(
+      `/api/projects/${pid}/super-agent/threads${includeArchived ? "?include_archived=1" : ""}`,
+    ),
   thread: (pid: string, channel: string, id: string) =>
-    http.get<ThreadDetail>(`/api/projects/${pid}/super-agent/threads/${channel}/${id}`),
+    http.get<ThreadDetail>(`/api/projects/${pid}/super-agent/threads/${seg(channel)}/${seg(id)}`),
+  // Rename, or put away. Archiving leaves the record exactly where it is and
+  // only takes it out of the lists that offer chats to resume.
+  update: (pid: string, slug: string, id: string, patch: { title?: string; archived?: boolean }) =>
+    http.patch<{ ok: boolean }>(`/api/projects/${pid}/agents/${seg(slug)}/conversations/${seg(id)}`, patch),
+  updateThread: (pid: string, channel: string, id: string, patch: { title?: string; archived?: boolean }) =>
+    http.patch<{ ok: boolean }>(`/api/projects/${pid}/super-agent/threads/${seg(channel)}/${seg(id)}`, patch),
   // Delete a persisted agent conversation (its `.md` file).
   remove: (pid: string, slug: string, id: string) =>
-    http.del<{ ok: boolean }>(`/api/projects/${pid}/agents/${slug}/conversations/${id}`),
-  // Delete a super-agent channel thread (its channel+day ledger file).
+    http.del<{ ok: boolean }>(`/api/projects/${pid}/agents/${seg(slug)}/conversations/${seg(id)}`),
+  // Delete a super-agent channel thread — its channel+day ledger file, or, for
+  // a group room or an a2a pair, every ledger row belonging to that thread.
   removeThread: (pid: string, channel: string, id: string) =>
-    http.del<{ ok: boolean }>(`/api/projects/${pid}/super-agent/threads/${channel}/${id}`),
+    http.del<{ ok: boolean }>(`/api/projects/${pid}/super-agent/threads/${seg(channel)}/${seg(id)}`),
+  // Rewind a persisted agent conversation to its first `keepVisible` user/
+  // assistant turns, dropping the rest — backs "regenerate" and "edit & resend".
+  truncate: (pid: string, slug: string, id: string, keepVisible: number) =>
+    http.post<{ ok: boolean }>(`/api/projects/${pid}/agents/${seg(slug)}/conversations/${seg(id)}/truncate`, { keep_visible: keepVisible }),
   compact: (pid: string, slug: string, id?: string) =>
     http.post<{ ok?: boolean }>(
       id
-        ? `/api/projects/${pid}/agents/${slug}/conversations/${id}/compact`
-        : `/api/projects/${pid}/agents/${slug}/compact`,
+        ? `/api/projects/${pid}/agents/${seg(slug)}/conversations/${seg(id)}/compact`
+        : `/api/projects/${pid}/agents/${seg(slug)}/compact`,
       {}
     ),
 };

package/src/interfaces/web/src/lib/api/embeddings.ts

@@ -13,12 +13,15 @@ export interface EmbedEngineInfo {
   available: boolean;   // probe says it can embed right now
   configured: boolean;  // has a non-empty memory.embeddings.<id> config block
   enabled: boolean;     // included in the fallback chain
+  custom?: boolean;     // a user-added custom:<slug> OpenAI-compatible provider
+  label?: string;       // display name for a custom provider
 }
 
 export interface EmbedProvidersResponse {
   configured_provider: string; // "auto" | <engine id>
   mode: EmbedMode;
   order: string[];
+  active_embedder: string; // embedder tag a real call lands on now ("ollama:…"|"tf")
   engines: EmbedEngineInfo[];
 }
 

package/src/interfaces/web/src/lib/api/engines.ts

@@ -19,6 +19,16 @@ export interface EnginePresets {
   presets: Record<string, EnginePreset>;
 }
 
+export interface EngineTestResult {
+  provider: string;
+  model: string;
+  /** Id the gateway put on the response. Null when the adapter did not echo one. */
+  served_model?: string | null;
+  text: string;
+  usage?: { input_tokens?: number; output_tokens?: number } | null;
+  ms: number;
+}
+
 export const Engines = {
   list: () => http.get<EngineSummary>("/api/engines"),
   // Curated catalog (known models + defaults) shared with the CLI wizard. The
@@ -28,4 +38,8 @@ export const Engines = {
   // the provider slug (so editing an existing provider works without retyping).
   models: (body: { engine: string; slug?: string; base_url?: string; api_key?: string }) =>
     http.post<EngineModels>("/api/engines/models", body),
+  // One-shot connectivity probe. Not a conversation: nothing is stored and the
+  // daemon sends no history, tools or skills with it.
+  test: (body: { provider: string; model: string; message?: string }) =>
+    http.post<EngineTestResult>("/api/engines/test", body),
 };

package/src/interfaces/web/src/lib/api/groups.ts

@@ -0,0 +1,93 @@
+import { http, streamNdjson } from "../http";
+import type { ChatStreamEvent, ChatUsage } from "../../types/daemon";
+
+// A group is a THREAD (channel "group") — listing and reading it go through the
+// shared thread endpoints (Conversations.thread / the threads list / the inbox),
+// not here. This client owns only what's group-specific: creating a room, adding
+// a participant, and running the owner's turn as a streamed mention-cascade.
+
+export interface GroupCreated {
+  id: string;
+  channel: "group";
+  title: string;
+  participants: string[];
+  /** Present when the room mixes agents from several projects. */
+  homes?: Record<string, number | string>;
+}
+
+export type GroupMember = { project_id: number | string; slug: string };
+
+// Agent-loop events forwarded through a group speaker turn (same NDJSON shape as 1:1 chat).
+type GroupAgentStreamEvent = ChatStreamEvent & {
+  type:
+    | "tool_start"
+    | "tool_result"
+    | "tool_deduped"
+    | "assistant_text"
+    | "model_start"
+    | "model_routed"
+    | "engine_failed"
+    | "model_retry"
+    | "tools_suppressed"
+    | "skill_inspector"
+    | "reasoning";
+};
+
+// NDJSON events streamed while a group turn runs. Bodies are re-read from the
+// thread afterward; these drive live speaker attribution + token streaming.
+export type GroupStreamEvent =
+  // The cascade names itself before it does any work, so it can be stopped from
+  // the first token instead of only once it is over.
+  | { type: "start"; turn_id: string; channel: "group"; thread_id: string }
+  | { type: "owner_message" }
+  | { type: "speaker_start"; slug: string; reason?: string | null }
+  | { type: "speaker_delta"; slug: string; delta: string }
+  | { type: "speaker_final"; slug: string; model?: string; usage?: ChatUsage }
+  // One speaker was cut off by Stop; its partial is already in the thread.
+  | { type: "speaker_aborted"; slug: string; text: string }
+  | { type: "done" }
+  | { type: "final" }
+  // The room was stopped. Not an error — see api/turn-abort.js.
+  | { type: "aborted" }
+  | { type: "error"; error: string }
+  | GroupAgentStreamEvent;
+
+export const Groups = {
+  create: (
+    pid: string,
+    body: { title?: string; participants?: string[]; members?: GroupMember[] },
+  ) => http.post<GroupCreated>(`/api/projects/${pid}/groups`, body),
+  addParticipant: (pid: string, gid: string, slug: string) =>
+    http.post<{ id: string; participants: string[] }>(`/api/projects/${pid}/groups/${gid}/participants`, { slug }),
+  removeParticipant: (pid: string, gid: string, slug: string) =>
+    http.del<{ id: string; participants: string[] }>(`/api/projects/${pid}/groups/${gid}/participants/${encodeURIComponent(slug)}`),
+  sendStream: (
+    pid: string,
+    gid: string,
+    prompt: string,
+    onEvent: (ev: GroupStreamEvent) => void,
+    signal?: AbortSignal,
+    attachments?: { path: string; name?: string }[],
+  ) => streamNdjson<GroupStreamEvent>(
+    `/api/projects/${pid}/groups/${gid}/message/stream`,
+    { prompt, ...(attachments?.length ? { attachments } : {}) },
+    onEvent, signal,
+  ),
+  // Re-run from a speaker against the existing last owner message (regenerate).
+  // `from` = slug to resume at; `reason` = who pulled them in (omit if owner).
+  rerunStream: (
+    pid: string,
+    gid: string,
+    onEvent: (ev: GroupStreamEvent) => void,
+    signal?: AbortSignal,
+    resume?: { from: string; reason?: string | null },
+  ) => streamNdjson<GroupStreamEvent>(
+    `/api/projects/${pid}/groups/${gid}/message/stream`,
+    { rerun: true, ...(resume?.from ? { from: resume.from, ...(resume.reason ? { reason: resume.reason } : {}) } : {}) },
+    onEvent, signal,
+  ),
+  // Rewind: keep the first `keepVisible` owner+agent turns, drop the rest
+  // (tool rows ride with their agent; backs regenerate / edit & resend).
+  truncate: (pid: string, gid: string, keepVisible: number) =>
+    http.post<{ ok: boolean; removed: number }>(`/api/projects/${pid}/groups/${gid}/truncate`, { keep_visible: keepVisible }),
+};

package/src/interfaces/web/src/lib/api/images.ts

@@ -0,0 +1,193 @@
+import { http, getToken } from "../http";
+import { apiUrl } from "../net";
+
+// Image-generation client. Talks to the daemon's /images surface (see
+// src/host/daemon/api/images.js + the engine registry at
+// src/core/images/engines/index.js).
+//
+// Engine ids (chain order, "auto" takes the first reachable one):
+//   a1111 → sdcpp → openai → mock
+//
+// Per-engine config lives under config.images.<id>; user-added endpoints under
+// config.images.custom.<slug>, each naming the dialect it speaks in `kind`.
+// Shared defaults (size, steps, cfg…) live under config.images.defaults and are
+// overridden per engine by config.images.<id>.defaults.
+
+export type ImageEngineId = "a1111" | "sdcpp" | "openai" | "mock";
+export type ImageMode = "chain" | "single";
+/** Which dialect a custom endpoint speaks — it decides the adapter. */
+export type ImageCustomKind = "a1111" | "sdcpp" | "openai";
+
+export const IMAGE_CUSTOM_KINDS: ImageCustomKind[] = ["a1111", "sdcpp", "openai"];
+
+/** One engine as reported by /images/providers. */
+export interface ImageEngineInfo {
+  id: string;
+  available: boolean;   // the probe reached it just now
+  configured: boolean;  // has a non-empty images.<id> block
+  enabled: boolean;     // included in the chain (images.<id>.enabled)
+  supports: string[];   // knobs this engine can actually honor
+  note?: string;        // usually the base_url
+  custom?: boolean;     // user-added ("custom:<slug>")
+  kind?: ImageCustomKind;
+  label?: string;
+}
+
+export interface ImageDefaults {
+  width: number;
+  height: number;
+  steps: number;
+  cfg_scale: number;
+  seed: number;
+  count: number;
+  format: string;
+  negative_prompt: string;
+  sampler: string;
+  scheduler: string;
+}
+
+export interface ImageProvidersResponse {
+  configured_provider: string; // "auto" | engine id
+  mode: ImageMode;
+  order: string[];
+  defaults: ImageDefaults;
+  engines: ImageEngineInfo[];
+}
+
+/** What a server says it can do. Every field is optional — many have none. */
+export interface ImageCapabilities {
+  models?: string[];
+  samplers?: string[];
+  schedulers?: string[];
+  formats?: string[];
+  sizes?: string[];
+  defaults?: { width?: number; height?: number } | null;
+  modes?: string[];
+}
+
+export interface ImageCapabilitiesResponse {
+  provider: string;
+  capabilities: ImageCapabilities | null;
+}
+
+export interface GeneratedImage {
+  path: string;      // absolute, under ~/.apx/images/<date>/
+  url: string;       // /api/images/file?path=… — fetch it with the bearer
+  bytes: number;
+  mime: string;
+  format: string;
+  seed?: number | null;
+}
+
+export interface ImageGenerateResult {
+  images: GeneratedImage[];
+  provider: string;
+  model: string | null;
+  prompt: string;
+  request: Partial<ImageDefaults> & { model?: string };
+  /** Knobs this engine could not honor — shown so a silent drop never happens. */
+  ignored: string[];
+  elapsed_ms: number;
+  meta: Record<string, unknown>;
+}
+
+export interface ImageGenerateBody {
+  prompt: string;
+  provider?: string;
+  negative_prompt?: string;
+  width?: number;
+  height?: number;
+  size?: string;
+  steps?: number;
+  cfg_scale?: number;
+  seed?: number;
+  sampler?: string;
+  scheduler?: string;
+  count?: number;
+  format?: string;
+  model?: string;
+}
+
+/** Per-engine config block (images.<id> / images.custom.<slug>). */
+export interface ImageEngineConfig {
+  base_url?: string;
+  api_key?: string;      // may carry a redacted "*** set ***" marker
+  model?: string;
+  enabled?: boolean;
+  timeout_s?: number;
+  poll_interval_ms?: number;
+  size?: string;         // openai only
+  quality?: string;      // openai only
+  label?: string;        // custom only
+  kind?: ImageCustomKind; // custom only
+  defaults?: Partial<ImageDefaults> & { size?: string };
+}
+
+export interface ImagesConfig {
+  provider?: string;
+  mode?: ImageMode;
+  order?: string[];
+  defaults?: Partial<ImageDefaults> & { size?: string };
+  a1111?: ImageEngineConfig;
+  sdcpp?: ImageEngineConfig;
+  openai?: ImageEngineConfig;
+  custom?: Record<string, ImageEngineConfig>;
+}
+
+// Display names and the one-line "what is this" under each row. The daemon
+// owns availability; this only adds names and notes.
+export const IMAGE_PROVIDER_META: Record<string, { name: string; note: string; local?: boolean }> = {
+  a1111: {
+    name: "AUTOMATIC1111 API",
+    note: "The universal dialect: A1111, Forge, SD.Next, Draw Things on macOS, stable-diffusion.cpp. Set a base URL — no API key needed for a local or LAN server.",
+    local: true,
+  },
+  sdcpp: {
+    name: "stable-diffusion.cpp",
+    note: "The same server's native queue: it answers immediately and the job is polled, so a long render never holds a connection open.",
+    local: true,
+  },
+  openai: {
+    name: "OpenAI Images",
+    note: "Cloud (gpt-image-1 / dall-e-3), or any OpenAI-compatible /v1/images endpoint if you set a base URL. This dialect has no steps, cfg or negative prompt.",
+  },
+  mock: {
+    name: "Mock",
+    note: "Offline test engine. Always available as the last rung of the chain.",
+    local: true,
+  },
+};
+
+export const IMAGE_FORMATS = ["png", "jpeg", "webp"];
+export const IMAGE_SIZE_PRESETS = ["512x512", "768x512", "512x768", "1024x1024", "1024x576"];
+
+/**
+ * Build a blob URL for a generated image. The file route is authenticated and
+ * sandboxed to ~/.apx/images, so the browser cannot just point an <img> at it.
+ */
+export async function fetchImageBlobUrl(imagePath: string): Promise<string> {
+  const token = getToken();
+  const res = await fetch(apiUrl(`/api/images/file?path=${encodeURIComponent(imagePath)}`), {
+    headers: token ? { authorization: `Bearer ${token}` } : {},
+  });
+  if (!res.ok) {
+    const detail = await res.text().catch(() => "");
+    throw new Error(`${res.status}: ${detail.slice(0, 160)}`);
+  }
+  return URL.createObjectURL(await res.blob());
+}
+
+export const Images = {
+  /** Engines, availability, routing and the effective defaults. */
+  providers: () => http.get<ImageProvidersResponse>("/api/images/providers"),
+
+  /** What one server offers (models, samplers, schedulers). May be null. */
+  capabilities: (provider?: string) =>
+    http.get<ImageCapabilitiesResponse>(
+      `/api/images/capabilities${provider ? `?provider=${encodeURIComponent(provider)}` : ""}`,
+    ),
+
+  /** Generate. The reply carries file paths plus authenticated urls. */
+  generate: (body: ImageGenerateBody) =>
+    http.post<ImageGenerateResult>("/api/images/generate", body),
+};

package/src/interfaces/web/src/lib/api/inbox.ts

@@ -1,4 +1,5 @@
 import { http, unwrapPage } from "../http";
+import type { ActiveTurn, AgentFace } from "../../types/daemon";
 
 /** One row of the agent inbox: an agent, and the last thing it said. */
 export interface InboxRow {
@@ -8,19 +9,42 @@ export interface InboxRow {
   agent_slug: string;
   agent_name: string | null;
   agent_emoji: string | null;
-  kind: "agent" | "super_agent";
+  /** Blob-preset key for the animated avatar (see components/agents/blobPresets). */
+  agent_icon: string | null;
+  kind: "agent" | "super_agent" | "a2a" | "group";
+  /** For a2a and group chats: the participant slugs, for the multi-face avatar. */
+  participants?: string[];
+  /** Resolved face per participant (blob/emoji/name) so the duo wears real
+   *  avatars — the same shape, from the same resolver, that a thread carries. */
+  participant_faces?: AgentFace[];
+  /** For a2a spawned on someone's behalf: who asked for it ("a pedido de X"). */
+  requested_by?: string | null;
   pinned: boolean;
   conversation_id: string | null;
   channel: string | null;
   messages: number;
   /** What the AGENT last said — not what the user last asked. */
   preview: string | null;
+  /** WHEN it said that. Distinct from `last_activity_at`, which also moves for
+   *  the owner's own send and for every tool row of a turn — see lib/notify.ts,
+   *  where the difference is one bell per answer instead of one per step. */
+  preview_at?: string | null;
   last_activity_at: string;
+  /** Daemon-owned status; survives navigation and is shared by every rail. */
+  active_turn?: ActiveTurn | null;
 }
 
 export const Inbox = {
-  list: (includeEmpty = false) =>
-    http
-      .get<unknown>(`/api/inbox${includeEmpty ? "?include_empty=1" : ""}`)
-      .then((b) => unwrapPage<InboxRow>(b).items),
+  /** `channel` scopes the individual-agent rows to one channel (e.g. "web") so a
+   *  Telegram thread never surfaces on the inbox or the phone. a2a group rows are
+   *  always included. Omit it for the full, every-channel list. */
+  list: (includeEmpty = false, channel?: string) => {
+    const params = new URLSearchParams();
+    if (includeEmpty) params.set("include_empty", "1");
+    if (channel) params.set("channel", channel);
+    const qs = params.toString();
+    return http
+      .get<unknown>(`/api/inbox${qs ? `?${qs}` : ""}`)
+      .then((b) => unwrapPage<InboxRow>(b).items);
+  },
 };

package/src/interfaces/web/src/lib/api/integrations.ts

@@ -45,12 +45,21 @@ export interface PluginSelect {
 export interface PluginAction {
   action: string;
 }
+// When present, the plugin authenticates via a browser OAuth consent flow: the
+// component saves client_id/secret, then opens `action` (which returns an
+// auth_url) in a popup. `redirectPath` is the URI the user registers in the
+// provider console (shown in the UI, resolved against the panel's origin).
+export interface PluginOAuth {
+  action: string;
+  redirectPath: string;
+}
 export interface PluginUi {
   accent?: string;
   configFields: PluginConfigField[];
   select?: PluginSelect;
   connectedFields?: string[];
   actions?: PluginAction[];
+  oauth?: PluginOAuth;
 }
 
 // One entry of the plugin catalog with its resolved status for this project.