@agentorg/cli 0.0.5 → 0.0.7

package/dist/node_modules/@agentorg/hub/dist/src/validate.d.ts

@@ -1,12 +1,10 @@
 import type { DescribedInterface } from "@agentorg/sdk";
-/** A part of an interface with its own schema: a method's input or output, an event, or `open`. */
+/** A part of an interface with its own schema: a method's input or output, or an event. */
 export type Part = {
     method: string;
     side: "input" | "output";
 } | {
     event: string;
-} | {
-    open: true;
 };
 /** How long checking one value may take, once compiled, before it is refused and its worker replaced. */
 export declare const CHECK_BUDGET_MS = 250;

package/dist/node_modules/@agentorg/hub/dist/src/validate.js

@@ -1,28 +1,16 @@
 import { availableParallelism } from "node:os";
 import { Worker } from "node:worker_threads";
 import { Refused } from "@agentorg/sdk";
-const describe = (part) => "method" in part
-    ? `${part.method} ${part.side}`
-    : "event" in part
-        ? `${part.event} event`
-        : "open";
+const describe = (part) => "method" in part ? `${part.method} ${part.side}` : `${part.event} event`;
 function schemaOf(iface, part) {
     if ("method" in part)
-        return iface.kind === "rpc" && Object.hasOwn(iface.methods, part.method)
+        return Object.hasOwn(iface.methods, part.method)
             ? iface.methods[part.method]?.[part.side]
             : undefined;
-    if ("event" in part)
-        return iface.kind === "rpc" && Object.hasOwn(iface.events, part.event)
-            ? iface.events[part.event]
-            : undefined;
-    return iface.kind === "stream" ? iface.open : undefined;
+    return Object.hasOwn(iface.events, part.event) ? iface.events[part.event] : undefined;
 }
 const keyOf = (iface, part) => `${iface.hash} ${describe(part)}`;
 function partsOf(iface) {
-    if (iface.kind === "stream")
-        return [{ open: true }];
-    if (iface.kind !== "rpc")
-        return [];
     return [
         ...Object.keys(iface.methods).flatMap((method) => [
             { method, side: "input" },
@@ -87,7 +75,7 @@ export class Validators {
                 // Compiled: from here the check's own, shorter budget runs.
                 clearTimeout(busy.timer);
                 busy.phase = "check";
-                busy.timer = setTimeout(() => this.#replace(slot), this.#budgetMs);
+                busy.timer = this.#lateAfter(slot, this.#budgetMs);
                 return;
             }
             clearTimeout(busy.timer);
@@ -113,6 +101,20 @@ export class Validators {
         this.#broken = error;
         this.close(error);
     }
+    /**
+     * Start a budget for the job a worker has: a job still on it when it runs out is late, and its
+     * worker is replaced. The timer can fire late because this thread was busy, with the worker's
+     * reply already delivered, so messages are read once more (setImmediate runs after them) before
+     * the job is judged.
+     */
+    #lateAfter(slot, ms) {
+        const timer = setTimeout(() => setImmediate(() => {
+            // Still this budget's job: no reply ended it or moved it on to the check's budget.
+            if (slot.busy?.timer === timer)
+                this.#replace(slot);
+        }), ms);
+        return timer;
+    }
     #replace(slot) {
         const index = this.#slots.indexOf(slot);
         if (index < 0)
@@ -138,7 +140,7 @@ export class Validators {
             // The budget runs from when a ready worker takes the job, not while it waits. Compiling gets
             // its own budget, per schema; the check's starts when the worker says it has compiled.
             const budget = this.#compileBudgetMs * Math.max(1, next.job.parts.length);
-            const timer = setTimeout(() => this.#replace(slot), budget);
+            const timer = this.#lateAfter(slot, budget);
             slot.busy = { ...next, timer, phase: "compile" };
             slot.worker.ref();
             try {

package/dist/node_modules/@agentorg/hub/package.json

@@ -23,12 +23,9 @@
   },
   "dependencies": {
     "@agentorg/interfaces": "0.0.0",
-    "@agentorg/kit": "0.0.0",
     "@agentorg/sdk": "0.0.0",
     "@agentorg/wire": "0.0.0",
     "ajv": "^8.20.0",
-    "react": "^19.3.1",
-    "react-dom": "^19.3.1",
     "ws": "^8.22.1",
     "zod": "^4.6.7"
   },

package/dist/node_modules/@agentorg/interfaces/dist/src/agent-provider.d.ts

@@ -0,0 +1,119 @@
+import { z } from "zod";
+/** A creatable's id, unique within its provider. */
+export declare const CreatableId: z.ZodString;
+/** What the person gives at creation, by the id of each ask. Never a secret. */
+export declare const Answers: z.ZodRecord<z.ZodString, z.ZodString>;
+/** What an agent is made on: the execution layer's instructions and what it asks the person. */
+export declare const Creatable: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    instructions: z.ZodString;
+    asks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        optional: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * How an agent stands now, as what runs it knows: `starting`, `running`, `stopped` by the person,
+ * or `down`, which it didn't ask for. `detail` says why it is down.
+ */
+export declare const AgentStatus: z.ZodObject<{
+    state: z.ZodEnum<{
+        down: "down";
+        running: "running";
+        starting: "starting";
+        stopped: "stopped";
+    }>;
+    detail: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** The models an agent can use, and the one chosen; none chosen means the provider's default. */
+export declare const AgentModels: z.ZodObject<{
+    models: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    current: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * `agent.provider@1`: a program that makes agents: an execution system and its way of running one.
+ * It says what it can create, and makes, starts, stops and removes the agents it made, and keeps
+ * the model chosen for each; each is an Actor. A call naming an agent it didn't make is refused
+ * `unknown`.
+ */
+export declare const agentProvider: import("@agentorg/sdk").RpcInterface<"agent.provider", {
+    creatable: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        creatables: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodString;
+            instructions: z.ZodString;
+            asks: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                optional: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    /**
+     * Make and start an agent of a creatable, named `name`. `settings` is the agent's slot typed
+     * `agent.settings@1`, for whoever serves it to bind, and `chat` its export typed `chat@1`.
+     * Refused `unknown` for a creatable it doesn't offer, and `invalid` when an ask with no
+     * `optional` has no answer.
+     */
+    create: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        creatable: z.ZodString;
+        name: z.ZodString;
+        answers: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        agent: z.ZodString;
+        settings: z.ZodString;
+        chat: z.ZodString;
+    }, z.core.$strip>>;
+    status: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        agent: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        state: z.ZodEnum<{
+            down: "down";
+            running: "running";
+            starting: "starting";
+            stopped: "stopped";
+        }>;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    start: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        agent: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+    /**
+     * Stop an agent, keeping it: it does nothing until it is started. Its record, bindings and
+     * connections stay. Whether its chats can be read meanwhile is the provider's to say.
+     */
+    stop: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        agent: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+    /** The models an agent can use, and the one chosen. */
+    models: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        agent: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        models: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>;
+        current: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    /**
+     * Choose the model for an agent's next requests, kept with the agent; with no `model`, go back
+     * to the provider's default. Refused `unknown` when the model isn't one of `models`.
+     */
+    setModel: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        agent: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+    /** Final: the agent's Actor is closed. */
+    remove: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        agent: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+}, {}, 1>;

package/dist/node_modules/@agentorg/interfaces/dist/src/agent-provider.js

@@ -0,0 +1,96 @@
+import { defineInterface, method } from "@agentorg/sdk";
+import { z } from "zod";
+import { Id, Name } from "./hub.js";
+import { ModelId } from "./llm-session.js";
+const Title = z.string().min(1).max(128);
+const Description = z.string().max(2000);
+/** A creatable's id, unique within its provider. */
+export const CreatableId = z
+    .string()
+    .regex(/^[a-z][a-z0-9-]*$/)
+    .max(64);
+const AskId = z
+    .string()
+    .regex(/^[a-z][A-Za-z0-9_]*$/)
+    .max(64);
+/** What the person gives at creation, by the id of each ask. Never a secret. */
+export const Answers = z.record(AskId, z.string().max(4096));
+/** One thing a creatable asks the person when an agent is made from it. */
+const Ask = z.object({
+    id: AskId,
+    title: Title,
+    description: Description.optional(),
+    optional: z.literal(true).optional(),
+});
+/** What an agent is made on: the execution layer's instructions and what it asks the person. */
+export const Creatable = z.object({
+    id: CreatableId,
+    title: Title,
+    description: Description,
+    instructions: z.string().max(200_000),
+    asks: z.array(Ask).max(32),
+});
+const OnAgent = z.object({ agent: Id });
+/**
+ * How an agent stands now, as what runs it knows: `starting`, `running`, `stopped` by the person,
+ * or `down`, which it didn't ask for. `detail` says why it is down.
+ */
+export const AgentStatus = z.object({
+    state: z.enum(["starting", "running", "stopped", "down"]),
+    detail: z.string().max(2000).optional(),
+});
+/** The models an agent can use, and the one chosen; none chosen means the provider's default. */
+export const AgentModels = z.object({
+    models: z.array(z.object({ id: ModelId, name: z.string().max(256) })),
+    current: ModelId.optional(),
+});
+/**
+ * `agent.provider@1`: a program that makes agents: an execution system and its way of running one.
+ * It says what it can create, and makes, starts, stops and removes the agents it made, and keeps
+ * the model chosen for each; each is an Actor. A call naming an agent it didn't make is refused
+ * `unknown`.
+ */
+export const agentProvider = defineInterface({
+    name: "agent.provider",
+    major: 1,
+    kind: "rpc",
+    methods: {
+        creatable: method({
+            input: z.object({}),
+            output: z.object({ creatables: z.array(Creatable) }),
+        }),
+        /**
+         * Make and start an agent of a creatable, named `name`. `settings` is the agent's slot typed
+         * `agent.settings@1`, for whoever serves it to bind, and `chat` its export typed `chat@1`.
+         * Refused `unknown` for a creatable it doesn't offer, and `invalid` when an ask with no
+         * `optional` has no answer.
+         */
+        create: method({
+            input: z.object({
+                creatable: CreatableId,
+                name: Title,
+                answers: Answers,
+            }),
+            output: z.object({ agent: Id, settings: Name, chat: Name }),
+        }),
+        status: method({ input: OnAgent, output: AgentStatus }),
+        start: method({ input: OnAgent, output: z.object({}) }),
+        /**
+         * Stop an agent, keeping it: it does nothing until it is started. Its record, bindings and
+         * connections stay. Whether its chats can be read meanwhile is the provider's to say.
+         */
+        stop: method({ input: OnAgent, output: z.object({}) }),
+        /** The models an agent can use, and the one chosen. */
+        models: method({ input: OnAgent, output: AgentModels }),
+        /**
+         * Choose the model for an agent's next requests, kept with the agent; with no `model`, go back
+         * to the provider's default. Refused `unknown` when the model isn't one of `models`.
+         */
+        setModel: method({
+            input: OnAgent.extend({ model: ModelId.optional() }),
+            output: z.object({}),
+        }),
+        /** Final: the agent's Actor is closed. */
+        remove: method({ input: OnAgent, output: z.object({}) }),
+    },
+});

package/dist/node_modules/@agentorg/interfaces/dist/src/agent-settings.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+/** A skill's name, as the Agent Skills convention writes it. */
+export declare const SkillName: z.ZodString;
+/**
+ * A file of a skill: a relative path inside its folder, of plain segments, never `.` or `..`, with
+ * no backslash or control character.
+ */
+export declare const SkillPath: z.ZodString;
+/** The most one file of a skill holds, as text. */
+export declare const SKILL_FILE_MAX: number;
+/** What a list says of a skill, from its `SKILL.md` front matter. */
+export declare const SkillEntry: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strip>;
+/**
+ * `agent.settings@1`: what an agent is run with, read by the program that runs it. Each caller is
+ * answered with its own: the instructions it was given and the skills exposed to it, so an agent
+ * sees nothing of another's. It is read at each model request.
+ */
+export declare const agentSettings: import("@agentorg/sdk").RpcInterface<"agent.settings", {
+    get: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        instructions: z.ZodString;
+        skills: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    /**
+     * A file of a skill exposed to the caller, `SKILL.md` if no `path`. Refused `unknown` when the
+     * skill isn't exposed to it or has no such file.
+     */
+    skill: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        name: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        text: z.ZodString;
+    }, z.core.$strip>>;
+}, {
+    /** The caller's instructions or skills changed: read them again at the next request. */
+    changed: import("@agentorg/sdk").EventSpec<z.ZodObject<{}, z.core.$strip>>;
+}, 1>;

package/dist/node_modules/@agentorg/interfaces/dist/src/agent-settings.js

@@ -0,0 +1,53 @@
+import { defineInterface, event, method } from "@agentorg/sdk";
+import { z } from "zod";
+/** A skill's name, as the Agent Skills convention writes it. */
+export const SkillName = z
+    .string()
+    .regex(/^[a-z0-9]+(-[a-z0-9]+)*$/)
+    .max(64);
+/**
+ * A file of a skill: a relative path inside its folder, of plain segments, never `.` or `..`, with
+ * no backslash or control character.
+ */
+export const SkillPath = z
+    .string()
+    .regex(/^(?!\.\.?(\/|$))(?!.*\/\.\.?(\/|$))([^/\\\p{Cc}\p{Zl}\p{Zp}]+\/)*[^/\\\p{Cc}\p{Zl}\p{Zp}]+$/u)
+    .max(1024);
+/** The most one file of a skill holds, as text. */
+export const SKILL_FILE_MAX = 256 * 1024;
+/** What a list says of a skill, from its `SKILL.md` front matter. */
+export const SkillEntry = z.object({
+    name: SkillName,
+    description: z.string().max(1024),
+});
+/**
+ * `agent.settings@1`: what an agent is run with, read by the program that runs it. Each caller is
+ * answered with its own: the instructions it was given and the skills exposed to it, so an agent
+ * sees nothing of another's. It is read at each model request.
+ */
+export const agentSettings = defineInterface({
+    name: "agent.settings",
+    major: 1,
+    kind: "rpc",
+    methods: {
+        get: method({
+            input: z.object({}),
+            output: z.object({
+                instructions: z.string().max(200_000),
+                skills: z.array(SkillEntry),
+            }),
+        }),
+        /**
+         * A file of a skill exposed to the caller, `SKILL.md` if no `path`. Refused `unknown` when the
+         * skill isn't exposed to it or has no such file.
+         */
+        skill: method({
+            input: z.object({ name: SkillName, path: SkillPath.optional() }),
+            output: z.object({ text: z.string().max(SKILL_FILE_MAX) }),
+        }),
+    },
+    events: {
+        /** The caller's instructions or skills changed: read them again at the next request. */
+        changed: event(z.object({})),
+    },
+});

package/dist/node_modules/@agentorg/interfaces/dist/src/chat.d.ts

@@ -1,4 +1,6 @@
 import { z } from "zod";
+/** The longest title a chat has. */
+export declare const CHAT_TITLE_MAX = 200;
 /**
  * A tool call a `tool` message stands for: its name, whether it is `running` or ended `done` or
  * `refused`, and its input (the call's JSON arguments) and output (its JSON result, or the
@@ -39,44 +41,60 @@ export declare const ChatMessage: z.ZodObject<{
         output: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export declare const ChatState: z.ZodEnum<{
-    error: "error";
-    idle: "idle";
-    thinking: "thinking";
-    tool: "tool";
-}>;
-/**
- * What the agent is doing. On `error`, `detail.code` is the refusal's code, such as the model's
- * `usage_limit` or `not_signed_in`, so a view can offer the right action.
- */
+/** What the agent is doing: `working` while it answers anything, in any chat. */
 export declare const ChatStatus: z.ZodObject<{
     state: z.ZodEnum<{
-        error: "error";
         idle: "idle";
-        thinking: "thinking";
-        tool: "tool";
+        working: "working";
     }>;
-    detail: z.ZodOptional<z.ZodObject<{
+}, z.core.$strip>;
+/**
+ * One of an agent's chats, as a list shows it. Its `title` is its first message's first line until
+ * it is renamed. `latest` is its newest reply, so a view can tell what is new without reading the
+ * chat. `problem` is there while a message in it got no answer, until its next reply.
+ */
+export declare const ChatEntry: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    at: z.ZodString;
+    latest: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        at: z.ZodString;
+    }, z.core.$strip>>;
+    problem: z.ZodOptional<z.ZodObject<{
         code: z.ZodString;
         message: z.ZodString;
     }, z.core.$strip>>;
+    archived: z.ZodBoolean;
 }, z.core.$strip>;
 /**
- * `chat@1`: a conversation with an agent. `send` starts a turn, whose messages, streaming text and
- * status arrive as events. Events are live only: `history` is the record, and `state` the status
- * now.
+ * `chat@1`: an agent's chats. A chat is the messages sent in it and nothing more: `send` with no
+ * `chat` starts one, and with one, goes on in it. Messages and streaming text arrive as events,
+ * each naming its chat. What works is the agent, not a chat: `status` says when it starts and
+ * when it is done. Events are live only: `history` is a chat's record, `state` the agent's status
+ * now, and `list` the chats. A provider that can't take
+ * a message now refuses it `busy`. A call naming a chat the agent doesn't have is refused
+ * `unknown`.
  */
 export declare const chat: import("@agentorg/sdk").RpcInterface<"chat", {
+    /**
+     * Send this message in `chat`, or in a new chat; the result says which. The agent answers it
+     * in that chat. An archived chat takes a message like any other, and stays archived. Refused
+     * `busy` when the provider can't take it now.
+     */
     send: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        chat: z.ZodOptional<z.ZodString>;
         text: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
+        chat: z.ZodString;
         messageId: z.ZodString;
     }, z.core.$strip>>;
     /**
-     * Messages before `before` (or the newest), oldest first; `more` when older ones remain. A
-     * provider returns fewer than `limit` when a page would not fit one frame.
+     * A chat's messages before `before` (or the newest), oldest first; `more` when older ones
+     * remain. A provider returns fewer than `limit` when a page would not fit one frame.
      */
     history: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        chat: z.ZodString;
         before: z.ZodOptional<z.ZodString>;
         limit: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>, z.ZodObject<{
@@ -102,29 +120,51 @@ export declare const chat: import("@agentorg/sdk").RpcInterface<"chat", {
         }, z.core.$strip>>;
         more: z.ZodBoolean;
     }, z.core.$strip>>;
-    /** Stop the current turn, if any. */
-    cancel: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
-    /** The status now, as the latest `status` event said; for a view opened mid-turn. */
+    /** The agent's status now, as its latest `status` event said; for a view opened late. */
     state: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
         state: z.ZodEnum<{
-            error: "error";
             idle: "idle";
-            thinking: "thinking";
-            tool: "tool";
+            working: "working";
         }>;
-        detail: z.ZodOptional<z.ZodObject<{
-            code: z.ZodString;
-            message: z.ZodString;
-        }, z.core.$strip>>;
     }, z.core.$strip>>;
     /**
-     * Run the last turn again from the record, without recording the person's message again;
-     * `messageId` is that message's. Refused `busy` during a turn, and `nothing_to_retry` when no
-     * message has been sent.
+     * The chats after `before` in the list (or from its start), newest first by their last
+     * message; `more` when others follow. Those not archived, or with `archived`, those that are.
+     * A message sent in a chat moves it to the front, so a later page may repeat a chat that
+     * moved, and never leaves out one that didn't: the `chat` event says each that did. A `before`
+     * the agent doesn't have gives an empty page.
      */
-    retry: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
-        messageId: z.ZodString;
+    list: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        archived: z.ZodOptional<z.ZodBoolean>;
+        before: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        chats: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            at: z.ZodString;
+            latest: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                at: z.ZodString;
+            }, z.core.$strip>>;
+            problem: z.ZodOptional<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+            }, z.core.$strip>>;
+            archived: z.ZodBoolean;
+        }, z.core.$strip>>;
+        more: z.ZodBoolean;
     }, z.core.$strip>>;
+    /** Give a chat another title: one line, so only the first line of `title` is kept. */
+    rename: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        chat: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+    /** Put a chat among the archived ones, or back. It stays readable either way. */
+    archive: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        chat: z.ZodString;
+        archived: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
 }, {
     message: import("@agentorg/sdk").EventSpec<z.ZodObject<{
         id: z.ZodString;
@@ -145,22 +185,37 @@ export declare const chat: import("@agentorg/sdk").RpcInterface<"chat", {
             input: z.ZodOptional<z.ZodString>;
             output: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        chat: z.ZodString;
     }, z.core.$strip>>;
     /** Text of the assistant message `id`, as it streams; its `message` event follows. */
     delta: import("@agentorg/sdk").EventSpec<z.ZodObject<{
+        chat: z.ZodString;
         id: z.ZodString;
         text: z.ZodString;
     }, z.core.$strip>>;
+    /** The agent's status, when it changes. */
     status: import("@agentorg/sdk").EventSpec<z.ZodObject<{
         state: z.ZodEnum<{
-            error: "error";
             idle: "idle";
-            thinking: "thinking";
-            tool: "tool";
+            working: "working";
         }>;
-        detail: z.ZodOptional<z.ZodObject<{
+    }, z.core.$strip>>;
+    /**
+     * A chat as it now is: it was started, renamed or archived, a message was sent in it, or one
+     * got no answer.
+     */
+    chat: import("@agentorg/sdk").EventSpec<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        at: z.ZodString;
+        latest: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            at: z.ZodString;
+        }, z.core.$strip>>;
+        problem: z.ZodOptional<z.ZodObject<{
             code: z.ZodString;
             message: z.ZodString;
         }, z.core.$strip>>;
+        archived: z.ZodBoolean;
     }, z.core.$strip>>;
 }, 1>;