@fastagent-sh/fastagent 0.17.1 → 0.19.0

package/dist/channels/slack/slack.js

@@ -4,14 +4,14 @@ import { isAbsolute, join } from "node:path";
 import { log } from "../../log.js";
 import { readBodyCapped } from "../body.js";
 import { text } from "../respond.js";
-import { createSeenRing } from "../seen.js";
-import { createThreadParticipants } from "../thread-participants.js";
-import { createTaskTracker } from "../tasks.js";
-import { ensureStateHome, removeRetiredStateFile } from "../state.js";
-import { dispatchStop, isStopText } from "../stop-command.js";
-import { codePointPrefix } from "../text.js";
-import { createTurnQueue } from "../turn-queue.js";
-import { createTurnStore } from "../turn-store.js";
+import { createSeenRing } from "../kit/seen.js";
+import { createThreadParticipants } from "../kit/thread-participants.js";
+import { createTaskTracker } from "../kit/tasks.js";
+import { ensureStateHome } from "../kit/state.js";
+import { dispatchStop, isStopText } from "../kit/stop-command.js";
+import { codePointPrefix } from "../kit/text.js";
+import { createTurnQueue } from "../kit/turn-queue.js";
+import { createTurnStore } from "../kit/turn-store.js";
 import { createSlackBotTokenProvider } from "./bot-auth.js";
 import { collectSlackBufferedFiles, createSlackContextBuffer } from "./context-buffer.js";
 import { invokeSlackTurn } from "./invoke-turn.js";
@@ -141,10 +141,6 @@ export function slackChannel(options) {
          *  under a custom route is the `routed.session === undefined` condition on the write, not the
          *  absence of a route: a route that supplies its own session records nothing here. */
         const threadKey = (teamId, channelId, threadTs) => `slack:${teamId}:${channelId}:${threadTs}`;
-        // The participant model replaced the owned-thread index (a cache, so nothing is lost). REMOVE THIS
-        // after the release following the participant model ships — by then no live deployment can still
-        // be carrying the file. test/migration-deadline.test.ts fails when due.
-        removeRetiredStateFile(stateHome, "owned-threads.json", label);
         const welcomed = createWelcomedUsers(join(stateHome, "welcomed.json"), label);
         const buffer = createSlackContextBuffer(join(stateHome, "buffers.json"), label);
         const store = createTurnStore(join(stateHome, "turns.json"), {

package/dist/channels/slack/welcomed.js

@@ -1,6 +1,6 @@
 /** Durable set of users who have already received the first-run DM welcome, so it is sent at most once. */
 import { log } from "../../log.js";
-import { loadStateFile, saveStateFile } from "../state.js";
+import { loadStateFile, saveStateFile } from "../kit/state.js";
 function key(teamId, userId) {
     return `${teamId}:${userId}`;
 }

package/dist/channels/telegram/context-buffer.d.ts

@@ -1,10 +1,10 @@
 /**
- * Telegram's half of the shared context buffer (mechanics + consume protocol: ../context-buffer.ts):
+ * Telegram's half of the shared context buffer (mechanics + consume protocol: ../kit/context-buffer.ts):
  * the entry shape, its fold-line rendering, and buffered-attachment selection. Bucketed by Telegram
  * "place" (chat[:thread]), not session: an un-summoned message has no route session, and the flush
  * feeds whatever turn answers that place.
  */
-import { type ContextBuffer as GenericContextBuffer } from "../context-buffer.ts";
+import { type ContextBuffer as GenericContextBuffer } from "../kit/context-buffer.ts";
 /** One buffered un-summoned message (object identity is the commit key). Besides the sender label and
  *  one-line body, it carries what a LATER summon needs to resolve references into the discussion:
  *  message ids ("reply to the one Alex answered"), and attachment file_ids so "summarize the file from

package/dist/channels/telegram/context-buffer.js

@@ -1,10 +1,10 @@
 /**
- * Telegram's half of the shared context buffer (mechanics + consume protocol: ../context-buffer.ts):
+ * Telegram's half of the shared context buffer (mechanics + consume protocol: ../kit/context-buffer.ts):
  * the entry shape, its fold-line rendering, and buffered-attachment selection. Bucketed by Telegram
  * "place" (chat[:thread]), not session: an un-summoned message has no route session, and the flush
  * feeds whatever turn answers that place.
  */
-import { BUFFER_ATTACH_MAX, createContextBuffer as createGenericContextBuffer, } from "../context-buffer.js";
+import { BUFFER_ATTACH_MAX, createContextBuffer as createGenericContextBuffer, } from "../kit/context-buffer.js";
 function bufferLine(e) {
     const meta = [
         e.messageId !== undefined ? `msg ${e.messageId}` : undefined,

package/dist/channels/telegram/invoke-turn.d.ts

@@ -6,7 +6,7 @@
  * wiring and the per-turn lifecycle.
  */
 import type { Agent, AgentEvent } from "../../agent.ts";
-import { type BusyRetry } from "../invoke-turn-kit.ts";
+import { type BusyRetry } from "../kit/invoke-turn-kit.ts";
 import type { BufferedRef } from "./context-buffer.ts";
 /** Everything the transport needs to fetch a turn's attachments. */
 export interface TurnTransport {

package/dist/channels/telegram/invoke-turn.js

@@ -1,5 +1,5 @@
 import { log } from "../../log.js";
-import { DEFAULT_BUSY_RETRY, attachedFilesManifest, attributedFileName, missingAttachmentsNote, streamTurnWithBusyRetry, } from "../invoke-turn-kit.js";
+import { DEFAULT_BUSY_RETRY, attachedFilesManifest, attributedFileName, missingAttachmentsNote, streamTurnWithBusyRetry, } from "../kit/invoke-turn-kit.js";
 import { resolveFiles, resolveImages } from "./telegram-api.js";
 /** Appended to the prompt (not the system prompt): the channel owns Telegram-HTML formatting. */
 const HTML_INSTRUCTION = "\n\n(Format your reply in Telegram-supported HTML — <b> <i> <u> <s> <code> <pre> <a href> — not Markdown.)";
@@ -76,5 +76,5 @@ export async function* invokeTurn(agent, session, text, transport, attachments,
         return;
     }
     const prompt = { text: `${text}${resolved.promptSuffix}${HTML_INSTRUCTION}`, images: resolved.images };
-    yield* streamTurnWithBusyRetry(agent, session, prompt, { label: "[telegram]", onCompleted, busyRetry });
+    yield* streamTurnWithBusyRetry(agent, { session }, prompt, { label: "[telegram]", onCompleted, busyRetry });
 }

package/dist/channels/telegram/parse.js

@@ -5,8 +5,8 @@
  * "decide" and prompt-building half; telegram.ts wires it in and owns the stateful lifecycle. Kept
  * separate so this layer tests as plain functions and reads without the factory's noise.
  */
-import { BUFFER_LINE_MAX_CHARS } from "../context-buffer.js";
-import { REFERENT_MAX_CODE_POINTS, truncateCodePointPrefix } from "../text.js";
+import { BUFFER_LINE_MAX_CHARS } from "../kit/context-buffer.js";
+import { REFERENT_MAX_CODE_POINTS, truncateCodePointPrefix } from "../kit/text.js";
 /** The actionable message in an update (a fresh message or channel post). Edits (`edited_message` /
  *  `edited_channel_post`) are deliberately NOT actionable: answering them re-answers every typo fix (a
  *  duplicate reply per edit), so an edited message changes nothing — the standard bot behavior. The

package/dist/channels/telegram/preview.d.ts

@@ -6,7 +6,7 @@
  * message, works in groups and private (unlike sendMessageDraft, which is private/forum-topic only).
  */
 import type { AgentEvent } from "../../agent.ts";
-import { type ChannelFailure, defaultErrorMessage } from "../preview-kit.ts";
+import { type ChannelFailure, defaultErrorMessage } from "../kit/preview-kit.ts";
 import { type Target } from "./telegram-api.ts";
 /** A terminal failure, as the channel hands it to `onError` — the shared channel shape. */
 export type TelegramFailure = ChannelFailure;

package/dist/channels/telegram/preview.js

@@ -1,4 +1,4 @@
-import { RETRY_NOTICE, THINKING_PLACEHOLDER, applyTurnEvent, composeTurnBody, createPreviewPump, createTurnView, defaultErrorMessage, revealedAnswer, thinkingLine, toolLines, } from "../preview-kit.js";
+import { RETRY_NOTICE, THINKING_PLACEHOLDER, applyTurnEvent, composeTurnBody, createPreviewPump, createTurnView, defaultErrorMessage, revealedAnswer, thinkingLine, toolLines, } from "../kit/preview-kit.js";
 import { log } from "../../log.js";
 import { TELEGRAM_MAX_TEXT, callApi, editMessageText, sendMessage } from "./telegram-api.js";
 export { defaultErrorMessage };
@@ -120,7 +120,11 @@ export async function streamReply(events, api, botToken, target, formatError, pr
                 // below regardless.
                 finalized = true;
                 {
-                    const msg = formatError({ details: e.details, retryable: e.retryable }) ?? "";
+                    const msg = formatError({
+                        details: e.details,
+                        retryable: e.retryable,
+                        ...(e.code !== undefined ? { code: e.code } : {}),
+                    }) ?? "";
                     await finalize(api, botToken, target, messageId, msg).catch(() => { });
                 }
                 throw new Error(`agent failed: ${e.details} (retryable=${e.retryable})`);

package/dist/channels/telegram/telegram.d.ts

@@ -1,4 +1,4 @@
-import type { ChannelModule } from "../../host/node.ts";
+import type { ChannelModule } from "../../channel.ts";
 import { type TelegramMessage, type TelegramRoute, type TelegramUpdate, defaultTelegramRoute, telegramEnvelope } from "./parse.ts";
 import { type TelegramFailure } from "./preview.ts";
 export { defaultTelegramRoute, telegramEnvelope };

package/dist/channels/telegram/telegram.js

@@ -31,10 +31,10 @@ import { invokeTurn } from "./invoke-turn.js";
 import { collectAttachments, createContextBuffer } from "./context-buffer.js";
 import { attachmentSummary, defaultTelegramRoute, extractFiles, extractImages, fromLabel, messageText, ownFiles, ownImages, pickMessage, telegramEnvelope, } from "./parse.js";
 import { defaultErrorMessage, streamReply } from "./preview.js";
-import { ensureStateHome } from "../state.js";
-import { dispatchStop } from "../stop-command.js";
+import { ensureStateHome } from "../kit/state.js";
+import { dispatchStop } from "../kit/stop-command.js";
 import { callApi, editMessageText, sendMessage } from "./telegram-api.js";
-import { createTurnQueue } from "../turn-queue.js";
+import { createTurnQueue } from "../kit/turn-queue.js";
 import { createTurnStore } from "./turn-store.js";
 // Re-export the public surface authored elsewhere, so `@fastagent-sh/fastagent/telegram` keeps one entry point.
 export { defaultTelegramRoute, telegramEnvelope };

package/dist/channels/telegram/turn-store.d.ts

@@ -1,10 +1,10 @@
 /**
  * The telegram-shaped turn store: the channel's persisted record (what its runner needs to re-execute a
  * turn), its IO-boundary shape validator, and its arrival ordering, over the generic L1 turn store
- * (../turn-store.ts — the semantics live there: pre-ACK persist, replay on the next start, the poison-
+ * (../kit/turn-store.ts — the semantics live there: pre-ACK persist, replay on the next start, the poison-
  * turn execution ceiling, the fail-closed attempt bump).
  */
-import { type TurnStore } from "../turn-store.ts";
+import { type TurnStore } from "../kit/turn-store.ts";
 /** An accepted turn's persisted intent — the SOURCE for the fields a runner needs to re-execute it
  *  (telegram.ts's PendingTurn derives from this, so a new execution field added here propagates and
  *  cannot silently drop from the persisted record). Minus the live `previewId` (a restart's queue

package/dist/channels/telegram/turn-store.js

@@ -1,10 +1,10 @@
 /**
  * The telegram-shaped turn store: the channel's persisted record (what its runner needs to re-execute a
  * turn), its IO-boundary shape validator, and its arrival ordering, over the generic L1 turn store
- * (../turn-store.ts — the semantics live there: pre-ACK persist, replay on the next start, the poison-
+ * (../kit/turn-store.ts — the semantics live there: pre-ACK persist, replay on the next start, the poison-
  * turn execution ceiling, the fail-closed attempt bump).
  */
-import { createTurnStore as createGenericTurnStore } from "../turn-store.js";
+import { createTurnStore as createGenericTurnStore } from "../kit/turn-store.js";
 /** State files are an IO boundary: valid JSON of the WRONG SHAPE must degrade like a corrupt file
  *  (warn + empty), not flow in as trusted data (mirrors context-buffer's isBufferEntry). */
 function isStoredTurn(t) {

package/dist/cli/commands/add.js

@@ -11,7 +11,7 @@ import { dotEnvPath, loadDotEnv } from "../../env.js";
 import { resolveStateRoot } from "../../paths.js";
 import { SECRETS_DIRNAME } from "../../paths.js";
 import { detectRuntime, readPackageJson } from "../../runtime.js";
-import { isUnderDir } from "../../engines/pi/definition.js";
+import { isUnderDir } from "../../paths.js";
 import { displayPath } from "../../paths.js";
 import { appendChannelDotEnv, appendChannelEnv, assertChannelReady, channelExists, channelSetup, scaffoldChannel, } from "../../scaffold/add-channel.js";
 import { exists } from "../../paths.js";

package/dist/cli/commands/deploy.js

@@ -76,7 +76,7 @@ export async function runDeploy(host, dirArg, opts) {
         failStartup(new Error(`deploy stopped: ${pre.gate}`));
     for (const m of pre.messages)
         console.error(`[fastagent] ${m.level}: ${m.text}`);
-    const { channels, routeChannels, longConnectionChannels, hasTimeTriggers, modelAuth, authPath, container, port, extraSecrets, } = pre;
+    const { channels, routeChannels, longConnectionChannels, hasTimeTriggers, modelAuth, modelKeyInDefinition, authPath, container, port, extraSecrets, } = pre;
     const hasDeclaredChannels = routeChannels.length + longConnectionChannels.length > 0;
     // Docker: one app service + loopback port + state volume. `--tunnel` shapes the generated topology
     // with an optional Quick Tunnel service; `--run` alone decides whether Docker receives side effects.
@@ -126,6 +126,7 @@ export async function runDeploy(host, dirArg, opts) {
                 port,
                 requireTunnel: requestedTunnel,
                 modelAuth,
+                modelKeyInDefinition,
                 authPath,
                 channels,
                 longConnectionChannels,
@@ -176,6 +177,7 @@ export async function runDeploy(host, dirArg, opts) {
                 workspace,
                 name: serviceName,
                 modelAuth,
+                modelKeyInDefinition,
                 authPath,
                 channels,
                 longConnectionChannels,
@@ -278,6 +280,7 @@ export async function runDeploy(host, dirArg, opts) {
                 agentPrefix: container.agentPrefix,
                 name: acName,
                 modelAuth,
+                modelKeyInDefinition,
                 authPath,
                 channels,
                 extraSecrets,
@@ -371,6 +374,7 @@ export async function runDeploy(host, dirArg, opts) {
             agentPrefix: container.agentPrefix,
             appName,
             modelAuth,
+            modelKeyInDefinition,
             authPath,
             channels,
             longConnectionChannels,
@@ -468,9 +472,10 @@ function deployEnvironment(agentDir, channels) {
  * when present, yields an ephemeral URL that reuses the same webhook announcer as `dev --tunnel`.
  */
 async function runDeployDocker(params) {
-    const { agentDir, workspace, composeFile, port, requireTunnel, modelAuth, authPath, channels, longConnectionChannels, extraSecrets, } = params;
+    const { agentDir, workspace, composeFile, port, requireTunnel, modelAuth, modelKeyInDefinition, authPath, channels, longConnectionChannels, extraSecrets, } = params;
     const { secrets, missingSecrets, needsModelCredential } = assembleSecrets({
         modelAuth,
+        modelKeyInDefinition,
         authFile: (await exists(authPath)) ? await readFile(authPath) : undefined,
         channels,
         longConnectionChannels,
@@ -511,7 +516,7 @@ async function runDeployDocker(params) {
  * behind the shared {@link spawnRunner} seam (spawned `fly`, cwd = the workspace so the build context is the whole workspace).
  */
 async function runDeployFly(params) {
-    const { agentDir, workspace, agentPrefix, appName, modelAuth, authPath, channels, longConnectionChannels, flyTomlPath, extraSecrets, } = params;
+    const { agentDir, workspace, agentPrefix, appName, modelAuth, modelKeyInDefinition, authPath, channels, longConnectionChannels, flyTomlPath, extraSecrets, } = params;
     const fly = spawnRunner("fly", workspace);
     // Fail fast if flyctl is absent (spawn ENOENT → 127), with the install link — not a confusing auth gate.
     if ((await fly(["version"], { capture: true })).code === 127) {
@@ -520,6 +525,7 @@ async function runDeployFly(params) {
     const region = parseFlyRegion(await readFile(flyTomlPath, "utf8")) ?? "iad";
     const { secrets, missingSecrets, needsModelCredential } = assembleSecrets({
         modelAuth,
+        modelKeyInDefinition,
         authFile: (await exists(authPath)) ? await readFile(authPath) : undefined,
         channels,
         longConnectionChannels,
@@ -553,9 +559,10 @@ async function runDeployFly(params) {
  * file (secret values off argv) is created here — 0600, removed after the run either way.
  */
 async function runDeployAgentcore(params) {
-    const { agentDir, workspace, agentPrefix, name, modelAuth, authPath, channels, extraSecrets, selfSchedule } = params;
+    const { agentDir, workspace, agentPrefix, name, modelAuth, modelKeyInDefinition, authPath, channels, extraSecrets, selfSchedule, } = params;
     const { secrets, missingSecrets, needsModelCredential } = assembleSecrets({
         modelAuth,
+        modelKeyInDefinition,
         authFile: (await exists(authPath)) ? await readFile(authPath) : undefined,
         channels,
         extraSecrets,
@@ -627,7 +634,7 @@ async function runDeployAgentcore(params) {
  * webhook) lives in {@link deployRailwayRun}; see there for why Railway differs from Fly.
  */
 async function runDeployRailway(params) {
-    const { agentDir, workspace, name, modelAuth, authPath, channels, longConnectionChannels, extraSecrets, intoLinked, dockerfilePath, } = params;
+    const { agentDir, workspace, name, modelAuth, modelKeyInDefinition, authPath, channels, longConnectionChannels, extraSecrets, intoLinked, dockerfilePath, } = params;
     const railway = spawnRunner("railway", workspace);
     // Fail fast if the railway CLI is absent (spawn ENOENT → 127), with the install link.
     if ((await railway(["--version"], { capture: true })).code === 127) {
@@ -635,6 +642,7 @@ async function runDeployRailway(params) {
     }
     const { secrets, missingSecrets, needsModelCredential } = assembleSecrets({
         modelAuth,
+        modelKeyInDefinition,
         authFile: (await exists(authPath)) ? await readFile(authPath) : undefined,
         channels,
         longConnectionChannels,

package/dist/cli/commands/dev.js

@@ -6,15 +6,18 @@
 import { resolve } from "node:path";
 import { runDevSupervisor } from "../../dev-supervisor.js";
 import { loadDotEnv } from "../../env.js";
-import { reportFindingsIfChanged, reportModuleLoadFailures, reportToolCollisions } from "../../engines/pi/report.js";
+import { reportFindingsIfChanged, reportToolCollisions } from "../../engines/pi/report.js";
+import { reportModuleLoadFailures } from "../../log.js";
+import { CODING_TOOL_NAMES } from "../../engines/pi/create.js";
 import { createPiAgentFromDir } from "../../engines/pi/open.js";
+import { mountAgentService } from "../../service.js";
 import { setLogLevel } from "../../log.js";
 import { logAgentLoop } from "../../observe.js";
 import { installProxyFetch } from "../../proxy.js";
 import { workspaceHint } from "../../paths.js";
 import { bindAddress } from "../../bind.js";
 import { failStartup, placementOrExit } from "../fail.js";
-import { assertTunnelBindable, maybeTunnel, mountSessionControl, routesFor, serve, startSchedules } from "../serve.js";
+import { SHUTDOWN_GRACE_MS, assertTunnelBindable, maybeTunnel, reportServing, serve } from "../serve.js";
 import { parseBind, parsePort, reportAuth, reportLine, resolveFirstRunModel, reportWorkspaceHint } from "../shared.js";
 export async function runDev(dirArg, opts) {
     const dir = resolve(dirArg);
@@ -56,26 +59,34 @@ async function serveOnce(dir, opts) {
     reportWorkspaceHint(workspaceHint(a));
     reportLine("config", a.configPath ?? "(none)");
     reportLine("model", `${a.modelSpec}${a.config.thinkingLevel ? ` (thinking: ${a.config.thinkingLevel})` : ""}`);
-    await reportAuth(a.modelSpec, a.authPath);
+    await reportAuth(a.agentDir, a.modelSpec, a.authPath);
     reportAgentsSkillsTools(a);
     // Trace each turn's agent loop (tool calls + reply) to the log at debug level — shown in dev, gated
     // out in start (level info), keeping end-user content out of production logs. Wired in both postures.
-    const traced = logAgentLoop(a.agent);
-    const routed = await routesFor(a.agentDir, traced, a.stateRoot, a.sessionControl).catch(failStartup);
     // `http.host` enters here the way the flag enters `parseBind` — through `bindAddress`, so a
     // configured `localhost` is an ADDRESS by the time anything binds, renders or dials it.
     const configured = a.config.http?.host;
     const host = bindFlag ?? (configured === undefined ? undefined : bindAddress(configured));
     assertTunnelBindable(host, opts.tunnel ?? false, bindFlag ? "flag" : "config");
-    const withControl = mountSessionControl(routed.routes, a.sessionControl, a.stateRoot, {
-        tunnel: opts.tunnel ?? false,
-        agent: traced, // the remote data plane (POST /control/invoke) drives the SAME traced agent
-        host,
-    });
-    await startSchedules(a.agentDir, traced, a.stateRoot, a.config.selfSchedule ?? false);
-    serve({ ...routed, routes: withControl.routes }, { port: portFlag ?? a.config.http?.port ?? 8787, host }, (p) => {
-        withControl.announce(p);
-        maybeTunnel(a.agentDir, routed.routeChannels, p, opts.tunnel ?? false, a.stateRoot);
+    // The SAME assembly an embedder gets from `createAgentService` — channels, control plane,
+    // schedules, long connections. `dev` opens the directory itself only because its startup report
+    // prints the opened values before anything mounts.
+    const service = await mountAgentService(a, {
+        // Trace each turn's agent loop (tool calls + reply) to the log at debug level — shown in dev,
+        // gated out in start (level info), keeping end-user content out of production logs.
+        wrapAgent: logAgentLoop,
+        closeTimeoutMs: SHUTDOWN_GRACE_MS,
+        control: { tunnel: opts.tunnel ?? false, ...(host !== undefined ? { host } : {}) },
+        onChannelClosed: (name, error) => failStartup(new Error(`${name} ${error === undefined ? "closed unexpectedly" : `failed: ${String(error)}`}`)),
+    }).catch(failStartup);
+    serve(service.handler, { port: portFlag ?? a.config.http?.port ?? 8787, host }, {
+        ready: service.ready,
+        onListening: (p) => {
+            reportServing(service, host, p);
+            service.announce(p);
+            maybeTunnel(a.agentDir, service.channels.routes, p, opts.tunnel ?? false, a.stateRoot);
+        },
+        onShutdown: () => service.close(),
     });
 }
 /** The agents/skills/tools/collisions report lines. */
@@ -84,6 +95,7 @@ function reportAgentsSkillsTools(a) {
     if (a.definition.persona)
         reportLine("persona", "persona.md");
     reportLine("skills", a.definition.skills.map((s) => s.name).join(", ") || "(none)");
+    reportLine("codingTools", CODING_TOOL_NAMES.join(", "));
     if (a.toolNames.length > 0)
         reportLine("tools", a.toolNames.join(", "));
     if (a.deferredToolNames.length > 0) {

package/dist/cli/commands/fire.js

@@ -7,7 +7,7 @@
 import { join, resolve } from "node:path";
 import { loadDotEnv } from "../../env.js";
 import { displayPath } from "../../paths.js";
-import { reportModuleLoadFailures } from "../../engines/pi/report.js";
+import { reportModuleLoadFailures } from "../../log.js";
 import { createPiAgentFromDir } from "../../engines/pi/open.js";
 import { runInvokeStream } from "../invoke-stream.js";
 import { installProxyFetch } from "../../proxy.js";
@@ -37,7 +37,7 @@ export async function runFire(name, dirArg, opts) {
         authPath: opts.authPath, // flag > FASTAGENT_AUTH_PATH > default — resolved by the opener (one owner)
     }).catch(failStartup);
     console.error(`[fastagent] fire: ${name} (${modelSpec})`);
-    await reportAuth(modelSpec, authPath);
+    await reportAuth(placement.agentDir, modelSpec, authPath);
     const exitCode = await runInvokeStream(agent.invoke({ session: scheduleSession(name) }, { text: schedule.prompt }), (text) => process.stdout.write(text), (line) => console.error(line));
     process.stdout.write("\n");
     process.exit(exitCode);

package/dist/cli/commands/info.js

@@ -1,12 +1,14 @@
 /** `fastagent info [dir] [--json]`: print what the directory ASSEMBLES into, WITHOUT booting a server. Read-only. */
 import { resolve } from "node:path";
 import { loadDotEnv } from "../../env.js";
-import { discoverChannelFiles } from "../../engines/pi/channel.js";
-import { defaultSessionsDir, loadConfig, resolveAuthPath, resolveModelSpec, resolveSessionsDirOverride, } from "../../engines/pi/config.js";
+import { discoverChannelFiles } from "../../channels/discover.js";
+import { defaultSessionsDir, loadConfig, resolveAuthPath, resolveModel, resolveModelSpec, resolveSessionsDirOverride, } from "../../engines/pi/config.js";
+import { createPiModelRuntime } from "../../engines/pi/models.js";
 import { resolveStateRoot, workspaceHint } from "../../paths.js";
-import { resolveAgentTools } from "../../engines/pi/create.js";
+import { CODING_TOOL_NAMES, resolveAgentTools } from "../../engines/pi/create.js";
 import { loadAgentDefinition } from "../../engines/pi/definition.js";
-import { reportFindingsIfChanged, reportModuleLoadFailures, reportToolCollisions } from "../../engines/pi/report.js";
+import { reportFindingsIfChanged, reportToolCollisions } from "../../engines/pi/report.js";
+import { reportModuleLoadFailures } from "../../log.js";
 import { log } from "../../log.js";
 import { nextRun } from "../../schedule/cron.js";
 import { loadSchedules } from "../../schedule/discover.js";
@@ -24,7 +26,7 @@ export async function runInfo(dirArg, opts) {
     // tool), is isolated the same way everywhere (G2): info, dev, AND start report it and keep going with
     // the tools that loaded. The `error`/`.catch` below only fires for a whole-load fault (an unreadable
     // tools/ dir), not a single bad file.
-    const tools = await resolveAgentTools(config, agentDir)
+    const tools = await resolveAgentTools(config, agentDir, workspace)
         .then((r) => ({
         names: r.toolNames,
         deferred: r.deferredToolNames,
@@ -55,13 +57,29 @@ export async function runInfo(dirArg, opts) {
     const stateRoot = resolveStateRoot(agentDir);
     const sessionsDir = resolveSessionsDirOverride(opts.sessionsDir) ?? defaultSessionsDir(stateRoot);
     const authPath = resolveAuthPath(agentDir, opts.authPath); // flag > FASTAGENT_AUTH_PATH > default — the one owner
+    // RESOLVE the spec, do not just echo it: a spec is only real once its provider/model exist in the
+    // agent's own surface (built-ins + its models.json), which is exactly what a custom endpoint changes.
+    // Reporting a healthy-looking spec that `dev`/`start` then reject is the failure this pre-empts.
+    // Reported as DATA rather than thrown — a broken agent is what `info` is for — and read-only: the
+    // runtime reads models.json without creating anything (its catalog cache is written on refresh, and
+    // there is none here).
+    const modelError = modelSpec
+        ? await createPiModelRuntime({ agentDir, authPath })
+            .then((models) => {
+            resolveModel(models, modelSpec);
+            return undefined;
+        })
+            .catch((error) => error.message)
+        : undefined;
     if (opts.json) {
         console.log(JSON.stringify({
             agentDir,
             workspace,
             configPath: configPath ?? null,
             model: modelSpec ?? null,
+            modelError: modelError ?? null,
             thinkingLevel: config.thinkingLevel ?? null,
+            codingTools: [...CODING_TOOL_NAMES],
             context: definition.contextFiles.map((f) => f.path),
             persona: definition.persona !== undefined,
             skills: definition.skills.map((skill) => ({ name: skill.name, description: skill.description })),
@@ -85,6 +103,8 @@ export async function runInfo(dirArg, opts) {
     // One padded label writer: hand-spaced labels drifted out of alignment the moment a longer one
     // (agent/workspace/selfSchedule) joined the report.
     const line = (label, value) => console.log(`${`${label}:`.padEnd(13)} ${value}`);
+    /** A continuation under the previous line, aligned to the same column (no label, so no bare colon). */
+    const cont = (value) => console.log(`${"".padEnd(13)} ${value}`);
     line("agent", agentDir);
     line("workspace", workspace);
     const hint = workspaceHint({ agentDir, workspace });
@@ -92,8 +112,11 @@ export async function runInfo(dirArg, opts) {
         line("hint", hint);
     line("config", configPath ?? "(none)");
     line("model", modelSpec ?? "(not set — pass --model, set FASTAGENT_MODEL, or config.model)");
+    if (modelError)
+        cont(`⚠ does not resolve: ${modelError}`);
     if (config.thinkingLevel)
         line("thinking", config.thinkingLevel);
+    line("codingTools", CODING_TOOL_NAMES.join(", "));
     line("context", definition.contextFiles.map((f) => f.path).join(", ") || "(none)");
     line("persona", definition.persona ? "persona.md" : "(none)");
     line("skills", definition.skills.map((skill) => skill.name).join(", ") || "(none)");

package/dist/cli/commands/invoke.js

@@ -20,7 +20,7 @@ export async function runInvoke(message, dirArg, opts) {
     // BOTH directories, like dev/start: from the workspace, `placement.workspace` alone equals the dir you
     // typed, so it cannot tell you which agent actually ran.
     console.error(`[fastagent] invoke: ${placement.agentDir} (workspace ${placement.workspace}, ${modelSpec})`);
-    await reportAuth(modelSpec, authPath);
+    await reportAuth(placement.agentDir, modelSpec, authPath);
     // Fresh session per invoke (one-shot, no resume). runInvokeStream maps events→IO: reply→stdout,
     // tool/failure→stderr, exit 1 iff the turn failed (so CI can gate on it).
     const exitCode = await runInvokeStream(agent.invoke({ session: randomUUID() }, { text: message }), (text) => process.stdout.write(text), (line) => console.error(line));

package/dist/cli/commands/schedule.js

@@ -6,7 +6,7 @@
 import { resolve } from "node:path";
 import { loadDotEnv } from "../../env.js";
 import { resolveStateRoot } from "../../paths.js";
-import { reportModuleLoadFailures } from "../../engines/pi/report.js";
+import { reportModuleLoadFailures } from "../../log.js";
 import { readRuns } from "../../schedule/audit.js";
 import { nextRun } from "../../schedule/cron.js";
 import { loadSchedules } from "../../schedule/discover.js";