@fastagent-sh/fastagent 0.16.2 → 0.17.1

package/dist/session-remote.js

@@ -65,6 +65,23 @@ export async function connectSessionControl(options) {
     const capabilities = await get("/control/capabilities");
     return {
         capabilities: () => capabilities,
+        // NOT prefetched like capabilities: a live definition can grow a skill between calls, so the
+        // list is fetched per call. The endpoint is UNCACHED server-side (it re-reads the definition's
+        // skills/ per request), which is what keeps it honest about a directory that changes underneath
+        // it. A 404 is SKEW, not a fault in the definition: without this the two read identically
+        // (uncoded non-2xx), and a client would report "this agent's skills are unreadable" about a
+        // serve that simply predates the route.
+        async commands() {
+            try {
+                return await get("/control/commands");
+            }
+            catch (error) {
+                if (error instanceof ControlRequestError && error.status === 404) {
+                    throw new ControlRequestError(404, "this serve does not implement /control/commands (it predates the route)");
+                }
+                throw error;
+            }
+        },
         state: (session) => get(`/control/state?session=${encodeURIComponent(session)}`),
         entries: (session, opts) => get(`/control/entries?session=${encodeURIComponent(session)}${opts?.since !== undefined ? `&since=${encodeURIComponent(opts.since)}` : ""}`, PAYLOAD_TIMEOUT_MS),
         async dispatch(session, command) {

package/dist/session.d.ts

@@ -9,6 +9,14 @@
 import type { Json, Prompt } from "./agent.ts";
 export interface SessionControl {
     capabilities(): SessionCapabilities;
+    /** The names this agent exposes — what a composer's `/` completion LISTS. A listing, not a
+     *  dispatch surface: the data plane takes prompts as text, so what typing one means (expanding it,
+     *  sending "use the X skill", filtering a menu) is the client's business. Sessionless (the
+     *  definition is a deployment fact) but ASYNC, because a definition is allowed to be live: an
+     *  implementation that re-reads it per turn must answer from that same read, or the list and the
+     *  behavior diverge. `[]` is a complete answer, not a missing one; a definition the implementation
+     *  cannot read at all is a deployment fault and MAY reject. */
+    commands(): Promise<AgentCommand[]>;
     state(session: string): Promise<SessionState>;
     /** `since` is an APPEND-ORDER position cursor: "every record appended after the one with this
      *  id", regardless of branch structure. Reconstructing the active path in a branched session is
@@ -53,6 +61,18 @@ export interface SessionCapabilities {
     toolProgress: boolean;
     usage: boolean;
 }
+/**
+ * One name a client can offer the user. Field NAMES follow pi's RPC `get_commands` so a client
+ * porting from it maps directly; its `sourceInfo` (file provenance) is deliberately not carried, and
+ * `source` is a free-form string rather than pi's closed union — which kinds exist is an engine's
+ * business ("skill" is the only one fastagent assembles today), and an engine with none answers `[]`
+ * rather than the contract enumerating a set it cannot know.
+ */
+export interface AgentCommand {
+    name: string;
+    description?: string;
+    source: string;
+}
 /** Stable `SessionResult.error.code` for a command the implementation does not support. */
 export declare const UNSUPPORTED_CAPABILITY_CODE = "unsupported_capability";
 /** Stable `SessionResult.error.code` for a run-modulating command (`steer`/`follow_up`/`abort`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastagent-sh/fastagent",
-  "version": "0.16.2",
+  "version": "0.17.1",
   "description": "Vibe first. Then FastAgent: turn a local agent directory into a live service in your app, on GitHub, Telegram, Slack, or behind any channel.",
   "keywords": [
     "agent",