@fastagent-sh/fastagent 0.16.0 → 0.16.2

package/dist/host/node.d.ts

@@ -48,9 +48,11 @@ export declare function router(routes: Routes): ChannelHandler;
  * Serve `handler` on a Node HTTP server. Thin mechanism: bind, report the port, let the caller stop
  * accepting or force-close active connections — no logging/signals/exit (the CLI owns those).
  * `listening` resolves with the bound port (useful for port 0) or rejects on a bind error.
+ * `host` is the bind address; unset means all interfaces (what containers need).
  */
 export declare function serveNode(handler: ChannelHandler, options: {
     port: number;
+    host?: string;
 }): {
     listening: Promise<number>;
     close: () => Promise<void>;

package/dist/host/node.js

@@ -35,12 +35,13 @@ export function router(routes) {
  * Serve `handler` on a Node HTTP server. Thin mechanism: bind, report the port, let the caller stop
  * accepting or force-close active connections — no logging/signals/exit (the CLI owns those).
  * `listening` resolves with the bound port (useful for port 0) or rejects on a bind error.
+ * `host` is the bind address; unset means all interfaces (what containers need).
  */
 export function serveNode(handler, options) {
     const server = createServer(nodeListener(async (req) => handler(req)));
     const listening = new Promise((resolve, reject) => {
         server.once("error", reject); // a bind failure surfaces here, before "listening"
-        server.listen(options.port, () => {
+        server.listen({ port: options.port, host: options.host }, () => {
             server.off("error", reject);
             resolve(server.address().port);
         });

package/dist/pi.d.ts

@@ -1,5 +1,5 @@
 export { createPiAgent, createPiAgentFromDefinition, type CreatePiAgentFromDefinitionOptions, type CreatePiAgentOptions, } from "./engines/pi/create.ts";
-export { defineTool, loadTools, type DefineToolOptions, type FastagentTool, type ToolCollision, type ToolContext, } from "./engines/pi/tool.ts";
+export { defineTool, loadTools, type DefineToolOptions, type FastagentTool, type MountedTool, type ToolCollision, type ToolContext, } from "./engines/pi/tool.ts";
 export type { ReadonlySessionManager, ToolActivation } from "./engines/pi/tool-context.ts";
 export { z } from "zod";
 export type { AgentTool, ExecutionEnv, Session, SessionTreeEntry, Skill, SkillDiagnostic, } from "@earendil-works/pi-agent-core";

package/dist/session.d.ts

@@ -21,12 +21,17 @@ export interface SessionControl {
     dispatch(session: string, command: SessionCommand): Promise<SessionResult>;
 }
 /**
- * Static support declaration, two kinds of flag:
- * - COMMAND GATES (`steering`, `followUp`, `manualCompaction`, `modelSelection`, `thinkingLevel`):
+ * STATIC support declaration — sessionless, so nothing here may depend on a session. Two kinds of flag:
+ * - COMMAND GATES (`steering`, `followUp`, `manualCompaction`, `modelSelection`, `thinkingLevel`,
+ *   `navigate`):
  *   clients MUST gate dispatch on them; an unsupported command is rejected before acceptance with
  *   {@link UNSUPPORTED_CAPABILITY_CODE}.
  * - OBSERVATION-QUALITY flags (`toolProgress`, `usage`): whether those events/state fields appear
  *   at all — nothing to dispatch, nothing to reject.
+ *
+ * `modelSelection` may carry a list because the registry is a deployment fact; thinking levels
+ * depend on the session's current model, so they live on {@link SessionState.availableThinkingLevels}.
+ *
  * `state`/`entries`/`events` are mandatory (the reconnect contract) and deliberately absent here.
  */
 export interface SessionCapabilities {
@@ -36,9 +41,15 @@ export interface SessionCapabilities {
     modelSelection: false | {
         allowedModels: string[];
     };
-    thinkingLevel: false | {
-        allowedLevels: string[];
-    };
+    /** Whether `set_thinking` is servable at all. WHICH levels is per-session — see
+     *  {@link SessionState.availableThinkingLevels}. */
+    thinkingLevel: boolean;
+    /** Whether `navigate` is servable at all — `false` both when the engine's sessions are linear and
+     *  when this deployment has no write path for them; either way the tree the contract publishes
+     *  (`SessionEntry.parentId` + `SessionEntries.leafEntryId`) is read-only here. Named after its COMMAND, unlike the older gates (`manualCompaction` gates
+     *  `compact`, `thinkingLevel` gates `set_thinking`): those already force a client to translate,
+     *  and a gate keyed by the command literal is the only naming a derived map could ever produce. */
+    navigate: boolean;
     toolProgress: boolean;
     usage: boolean;
 }
@@ -79,7 +90,7 @@ export declare const NOTHING_TO_COMPACT_CODE = "nothing_to_compact";
  *  command as-is fails again. (A run registered without modulation controls is a capability
  *  problem, not a run problem, and rejects with {@link UNSUPPORTED_CAPABILITY_CODE}.) */
 export declare const RUN_COMMAND_FAILED_CODE = "run_command_failed";
-/** Six commands; deliberately NO `prompt` — starting work is the data plane's definition. */
+/** Seven commands; deliberately NO `prompt` — starting work is the data plane's definition. */
 export type SessionCommand = {
     type: "steer";
     prompt: Prompt;
@@ -97,6 +108,14 @@ export type SessionCommand = {
 } | {
     type: "set_thinking";
     level: string;
+}
+/** Move the session's active leaf to `targetId`, an existing entry — the write verb for the tree
+ *  `entries()` already publishes (and how sibling branches come to exist: the next turn hangs off
+ *  the new leaf). Every entry `entries()` publishes is a legal target; a `targetId` that is not
+ *  one rejects `invalid_command`. A boundary mutation otherwise: same lease as a run. */
+ | {
+    type: "navigate";
+    targetId: string;
 };
 /**
  * Acceptance is not outcome: `ok: true` means admitted or applied, never that the run ultimately
@@ -125,10 +144,13 @@ export interface SessionState {
      *  compaction happens inside a run's activity window and reports as `running`. */
     status: "idle" | "running" | "compacting";
     activeRunId?: string;
-    /** The session's durable overrides (set_model / set_thinking), read from the record — so a
-     *  reconnecting client sees them without scanning entries. Absent = the assembly default. */
+    /** What this session will RUN with, not what was recorded: overrides resolved against the
+     *  deployment (a model the registry lost falls back to the configured one; a level the current
+     *  model cannot do is clamped). Absent where the implementation exposes no model control. */
     model?: string;
     thinkingLevel?: string;
+    /** What `set_thinking` accepts for THIS session — re-read after a `set_model`. */
+    availableThinkingLevels?: string[];
     pending: {
         steering: number;
         followUp: number;
@@ -222,10 +244,13 @@ export type QueueChangedEvent = SessionEvent<"queue_changed", {
     runId: string;
 };
 /** A boundary mutation changed durable session state (L2; no runId — boundary mutations happen
- *  between runs). */
+ *  between runs). `leafEntryId` reports a `navigate` — a deliberate move of the branch head, which
+ *  a second attached client would otherwise have no signal for. It is NOT a general leaf feed:
+ *  every turn advances the leaf too, and that is read from `entries()`/`state()` after the run. */
 export type StateChangedEvent = SessionEvent<"state_changed", {
     model?: string;
     thinkingLevel?: string;
+    leafEntryId?: string;
 }>;
 /** Manual compaction bounds (L2): every `compaction_started` is closed by exactly one
  *  `compaction_finished` — `summary` on success, `error` on failure, `aborted: true` on a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastagent-sh/fastagent",
-  "version": "0.16.0",
+  "version": "0.16.2",
   "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",
@@ -101,9 +101,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.6.0",
-    "@earendil-works/pi-agent-core": "^0.81.1",
-    "@earendil-works/pi-ai": "^0.81.1",
-    "@earendil-works/pi-coding-agent": "^0.81.1",
+    "@earendil-works/pi-agent-core": "^0.83.0",
+    "@earendil-works/pi-ai": "^0.83.0",
+    "@earendil-works/pi-coding-agent": "^0.83.0",
     "@larksuiteoapi/node-sdk": "^1.71.1",
     "@octokit/webhooks-methods": "^6.0.0",
     "@octokit/webhooks-types": "^7.6.1",