indusagi-coding-agent 0.2.3 → 0.2.4

package/dist/types/conductor/quota-error.d.ts

@@ -0,0 +1,35 @@
+/**
+ * quota-error.ts — maps the indus model-gateway's usage-limit response into a
+ * friendly, user-facing fault message.
+ *
+ * When a no-local-key, logged-in user runs a turn, the framework adapter is
+ * pointed at `${INDUS_SERVER_URL}/gateway/<provider>` (see the conductor's
+ * baseUrl rewrite). If that user is over their monthly token allowance, the
+ * server replies — *before* forwarding upstream — with:
+ *
+ *   HTTP/1.1 429 Too Many Requests
+ *   Content-Type: application/json
+ *
+ *   { "error": "quota_exceeded", "used": <number>, "limit": <number> }
+ *
+ * The provider SDK / raw-fetch adapter turns that 429 into a thrown error. By
+ * the time it reaches the conductor it may be wrapped (an SDK `APIError`, a
+ * generic `Error`, a nested `cause` chain, or a plain string), so detection must
+ * be tolerant and walk the whole error chain rather than trust a single shape.
+ *
+ * This module is intentionally transport-agnostic and dependency-free so it can
+ * be unit-tested in isolation and imported from the conductor's retry chokepoint
+ * without pulling in any network/runtime modules.
+ */
+/** Detects the gateway's 429 quota body anywhere in the error chain. */
+export declare function isQuotaFault(error: unknown): boolean;
+/**
+ * Friendly user-facing text; `undefined` if `error` is not a quota fault.
+ *
+ * Includes the `<used>/<limit>` parenthetical when both numbers are parseable,
+ * and otherwise falls back to the same sentence without it. The `indus signin
+ * <provider>` hint steers the user toward supplying their own key (which takes
+ * the direct, un-metered local-key path), and the upgrade hint covers raising
+ * the server-side allowance.
+ */
+export declare function quotaErrorMessage(error: unknown): string | undefined;

package/dist/types/console/auth-status.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared "does the user have a usable credential for this provider" probe.
+ *
+ * Used anywhere the console needs to know which providers are actually
+ * callable — the `/model` picker (only list authenticated providers) and the
+ * banner's Session panel (don't display an unauthenticated model as if it were
+ * ready to use) both need the exact same answer, so it lives here once.
+ */
+import type { OverlayServices } from "./contract";
+/**
+ * Load the set of provider ids the user has USABLE credentials for, live, so a
+ * mid-session `/login` (either a local vault sign-in or the "Indus Server"
+ * server-tier device flow) is reflected without a restart.
+ *
+ * Two independent sources count: (1) any saved account in the local vault for a
+ * provider `listLoginProviders()` names, and (2) a valid server session token,
+ * which makes every gateway-eligible provider (`serverTierProviders()` —
+ * minimax, sarvam) usable even though the server tier never writes into the
+ * vault. Returns `null` until the asynchronous probe settles.
+ *
+ * `refreshKey` re-runs the probe whenever it changes by reference/value — a
+ * short-lived overlay (the `/model` picker) can leave it at its default since
+ * it remounts fresh on every open anyway, but a component mounted once for the
+ * whole session (the banner, the status bar) MUST pass something that changes
+ * right when a sign-in completes (e.g. the console's current status toast),
+ * otherwise this only ever reflects whatever was true at session start.
+ */
+export declare function useAuthenticatedProviders(services: OverlayServices | undefined, refreshKey?: unknown): Set<string> | null;

package/dist/types/console/components/TerminalConsole.d.ts

@@ -24,9 +24,4 @@
  * `indusagi/react-ink`.
  */
 import type { ConsoleProps } from "../contract";
-/**
- * The interactive console surface.
- *
- * @param props the conductor to drive, the resolved theme, and the slash registry
- */
 export declare function TerminalConsole(props: ConsoleProps): JSX.Element;

package/dist/types/console/contract.d.ts

@@ -359,6 +359,12 @@ export type ConsoleEvent = {
 } | {
     readonly type: "buffer:insert";
     readonly text: string;
+}
+/** Swap the first occurrence of `find` for `replaceWith` (paste-marker growth). */
+ | {
+    readonly type: "buffer:replaceSpan";
+    readonly find: string;
+    readonly replaceWith: string;
 } | {
     readonly type: "buffer:erasePrev";
 } | {
@@ -548,6 +554,13 @@ export interface OverlayServices {
     readonly openLoginUrl: (url: string) => Promise<boolean>;
     /** The credential store sign-in / sign-out overlays read and write. */
     readonly vault: AuthVault;
+    /**
+     * Recompute the server-tier gateway routing map from current vault/token
+     * state and push it onto the live conductor, so a sign-in that happens
+     * mid-session (the "Indus Server" entry in `/login`) takes effect on the
+     * NEXT turn without needing a session restart.
+     */
+    readonly refreshGatewayRouting: () => Promise<void>;
 }
 /**
  * What the root `TerminalConsole` surface receives at mount.

package/dist/types/console/input/index.d.ts

@@ -18,7 +18,7 @@
 export type { KeyChord, ConsoleVerb, ConsoleIntent, ChordOutcome, ChordLatch, ChordStep, } from "./keymap";
 export { NO_INTENT, readKey, NO_CHORD, advanceChord } from "./keymap";
 export type { PasteThresholds, PasteVault, PasteCapture, } from "./paste";
-export { PASTE_THRESHOLDS, PASTE_BURST_GAP_MS, EMPTY_PASTE_VAULT, pasteMarker, classifyPaste, coalescePaste, expandMarkers, hasMarkers, } from "./paste";
+export { PASTE_THRESHOLDS, PASTE_BURST_GAP_MS, PASTE_CONTINUATION_MS, PASTE_MARKER_LINE_CAP, EMPTY_PASTE_VAULT, pasteMarker, classifyPaste, coalescePaste, appendToPaste, pasteLines, expandMarkers, hasMarkers, } from "./paste";
 export type { CompletionKind, Suggestion, TokenSpan, CompletionResult, DirEntry, DirReader, } from "./complete";
 export { completeAt, applySuggestion } from "./complete";
 export { createDirReader } from "./dir-reader";

package/dist/types/console/input/keymap.d.ts

@@ -115,7 +115,7 @@ export interface KeyChord {
  *   Inert
  *     - `none`             — the keystroke carries no console meaning.
  */
-export type ConsoleVerb = "text:type" | "text:newline" | "edit:erasePrev" | "edit:eraseNext" | "edit:clearLine" | "nav:left" | "nav:right" | "nav:home" | "nav:end" | "nav:up" | "nav:down" | "flow:submit" | "flow:dismiss" | "flow:accept" | "flow:interrupt" | "flow:suspend" | "flow:cycleModel" | "model:cycleThinking" | "mode:cyclePermission" | "mode:togglePlan" | "queue:dequeue" | "input:pasteImage" | "input:externalEditor" | "overlay:open" | "view:expandTools" | "view:toggleReasoning" | "none";
+export type ConsoleVerb = "text:type" | "text:newline" | "edit:erasePrev" | "edit:eraseNext" | "edit:clearLine" | "nav:left" | "nav:right" | "nav:home" | "nav:end" | "nav:up" | "nav:down" | "flow:submit" | "flow:dismiss" | "flow:accept" | "flow:interrupt" | "flow:suspend" | "flow:cycleModel" | "model:cycleThinking" | "mode:cyclePermission" | "mode:togglePlan" | "queue:dequeue" | "queue:steer" | "input:pasteImage" | "input:externalEditor" | "overlay:open" | "view:expandTools" | "view:toggleReasoning" | "none";
 /**
  * A classified keystroke: a {@link ConsoleVerb} plus the small payload a verb
  * may carry — the literal text for a `text:type` insert, or the target overlay

package/dist/types/console/input/paste.d.ts

@@ -41,7 +41,14 @@ export interface PasteThresholds {
     /** Minimum character count to treat a chunk as a large paste. */
     readonly chars: number;
 }
-/** The default cut-offs above which a paste is coalesced into a marker. */
+/**
+ * The default cut-offs above which a paste is coalesced into a marker.
+ *
+ * Matched to the reference agent: a paste of MORE than 10 lines (i.e. ≥10
+ * newlines) or more than 1000 characters hides behind a marker; anything
+ * smaller — including the common 8-line snippet — splices inline and renders
+ * as visible multi-line text in the composer.
+ */
 export declare const PASTE_THRESHOLDS: PasteThresholds;
 /**
  * The maximum gap, in milliseconds, between per-character events still treated
@@ -53,6 +60,30 @@ export declare const PASTE_THRESHOLDS: PasteThresholds;
  * it. Exposed as data so the coalescing timer and any test share one value.
  */
 export declare const PASTE_BURST_GAP_MS = 24;
+/**
+ * How long, after a coalesced flush, a paste stays "active" — a further
+ * multi-character chunk landing within this window APPENDS to the active
+ * marker instead of minting a new one.
+ *
+ * Terminals deliver a big paste as a series of ~1KB stdin reads whose gaps can
+ * exceed any reasonable per-chunk debounce, so timing alone shreds one paste
+ * into many markers (`[Pasted #11][Pasted #12]…`, issue #18's second form).
+ * Sized GENEROUSLY: a very long paste (the spec case is 1000 lines) must
+ * survive mid-stream read hiccups as ONE marker, and the failure mode of a
+ * too-long window is mild — two lightning-fast deliberate pastes merge into
+ * one marker whose expansion is still the correct concatenated text — while a
+ * too-short window re-creates the shredding this exists to fix. Two human
+ * paste chords are >300ms apart in practice; single characters (real typing)
+ * never extend the window.
+ */
+export declare const PASTE_CONTINUATION_MS = 250;
+/**
+ * Ceiling on the line count a single marker absorbs via continuation. One
+ * user paste stays ONE marker up to this many lines; a paste that keeps
+ * streaming past it rolls over into a fresh marker ("one more paste") so a
+ * runaway multi-megabyte paste can't grow a single unbounded vault body.
+ */
+export declare const PASTE_MARKER_LINE_CAP = 1000;
 /** The console's own placeholder format for a hidden paste body. */
 export declare function pasteMarker(ordinal: number, lineCount: number): string;
 /**
@@ -106,6 +137,27 @@ export interface PasteCapture {
  * @param body  the full pasted text to hide
  */
 export declare function coalescePaste(body: string, vault?: PasteVault): PasteCapture;
+/**
+ * Grow an existing paste body with a follow-on chunk, reminting its marker.
+ *
+ * The continuation path for a paste the terminal split across reads: the extra
+ * text is appended to `ordinal`'s stored body and a fresh marker (same ordinal,
+ * updated line count) is returned so the surface can swap the token already
+ * spliced into the buffer. `minted` is unchanged — no new ordinal is consumed.
+ * An unknown ordinal starts from an empty body, so the call never throws.
+ *
+ * @param ordinal the marker ordinal to grow
+ * @param extra   the follow-on pasted text to append
+ * @param vault   the store holding the ordinal's current body
+ */
+export declare function appendToPaste(ordinal: number, extra: string, vault: PasteVault): PasteCapture;
+/**
+ * The line count of an ordinal's stored body — the surface consults this
+ * against {@link PASTE_MARKER_LINE_CAP} to decide whether a continuation chunk
+ * may still append or must roll over into a fresh marker. Zero for an unknown
+ * ordinal or an empty body.
+ */
+export declare function pasteLines(vault: PasteVault, ordinal: number): number;
 /**
  * Rewrite every paste marker in a buffer back to the text it stands for.
  *

package/dist/types/console/overlays/approval-queue.d.ts

@@ -15,7 +15,7 @@
  * abort/clear settles every outstanding entry with `"deny"` so a cancelled turn
  * never hangs on a pending prompt.
  */
-import type { ApprovalChoice } from "../../conductor";
+import type { ApprovalChoice, PermissionMode } from "../../conductor";
 import type { ApprovalRequest } from "./approval";
 /** One parked approval request awaiting the user's choice. */
 export interface ApprovalEntry {
@@ -69,3 +69,20 @@ export declare function approvalQueueReducer(state: ApprovalQueueState, event: A
  * @param state the queue state
  */
 export declare function activeApproval(state: ApprovalQueueState): ApprovalEntry | undefined;
+/**
+ * Whether switching INTO `mode` mid-prompt should release (auto-allow) every
+ * PARKED approval request.
+ *
+ * Only `bypass` qualifies: a parked entry already passed the deny-rule and
+ * catastrophic-blocklist scans before it reached `ask`, and under bypass the
+ * engine allows everything not denied — so settling the parked prompts with
+ * `allow-once` matches exactly what the mode now means, and the run resumes
+ * instead of idling behind a prompt the user just declared moot. Every other
+ * mode keeps the prompts parked: `default`/`acceptEdits` still want the answer,
+ * and `plan` must not auto-ALLOW a mutating call (the user can still deny).
+ *
+ * Pure; the component wires it to the actual settle.
+ *
+ * @param mode the permission mode just switched into
+ */
+export declare function modeReleasesApprovals(mode: PermissionMode): boolean;

package/dist/types/console/overlays/index.d.ts

@@ -12,4 +12,4 @@ export { PickerOverlays, type OverlayGroupProps } from "./pickers";
 export { SessionOverlays } from "./sessions";
 export { AuthOverlays } from "./auth";
 export { ApprovalOverlays, choiceFromId, readApprovalPayload, summarizeInput, APPROVAL_CHOICES, DISMISS_CHOICE, type ApprovalRequest, type ApprovalPayload, } from "./approval";
-export { approvalQueueReducer, activeApproval, EMPTY_APPROVAL_QUEUE, type ApprovalEntry, type ApprovalQueueState, type ApprovalQueueEvent, } from "./approval-queue";
+export { approvalQueueReducer, activeApproval, modeReleasesApprovals, EMPTY_APPROVAL_QUEUE, type ApprovalEntry, type ApprovalQueueState, type ApprovalQueueEvent, } from "./approval-queue";

package/dist/types/launch/login.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Login command — `runLogin`.
+ *
+ * The top-level `login` / `logout` / `whoami` surface that authenticates the CLI
+ * against the indus-server so a user with **no local provider key** can still run
+ * model turns through the server gateway (the session token is vended as the
+ * provider key downstream — see `src/boot/runners/server-mode.ts`).
+ *
+ * `login` drives the OAuth 2.0 **device-authorization** flow (RFC 8628) against
+ * the server's better-auth endpoints under `${INDUS_SERVER_URL}/api/auth`:
+ *
+ *   1. POST `/api/auth/device/code` → a `user_code` + verification URL.
+ *   2. The user opens the URL in a browser and approves the device.
+ *   3. We poll POST `/api/auth/device/token` until it returns an `access_token`.
+ *   4. The token is persisted via {@link storeServerToken} (A1's token store).
+ *
+ * This is a **pre-pipeline router**, not a runner: a no-key user cannot build a
+ * session, so login must short-circuit before the stage pipeline. {@link runLogin}
+ * therefore mirrors `runCredential` in `boot.ts` — it owns the first positional
+ * token only and returns `undefined` (fall through to a normal launch) when that
+ * token is not one of its verbs.
+ *
+ * The app does not depend on `better-auth/client`, `open`, or a spinner library,
+ * so the device flow is implemented over raw `fetch` and the console is driven
+ * with `chalk` to match the rest of the launch surface. `--server-url` and
+ * `--client-id` are parsed from the argv tail here (the declarative flag table is
+ * for the launch invocation, not these auth-only verbs).
+ */
+import type { OAuthLoginCallbacks } from "indusagi/ai";
+import type { BootContext } from "../boot/contract";
+/**
+ * The sign-in directory id for the indus-server session (as opposed to a
+ * per-model-provider credential). Used by `src/launch/oauth.ts` to special-case
+ * this entry in `listLoginProviders` / `startOAuthLogin` so the interactive
+ * `/login` picker can drive the same device-authorization flow as the `indus
+ * login` CLI verb.
+ */
+export declare const SERVER_TIER_PROVIDER_ID = "indus-server";
+/**
+ * Drive the indus-server device-authorization flow through the framework's
+ * generic {@link OAuthLoginCallbacks} shape, so the interactive `/login` picker
+ * (`src/console/overlays/auth.tsx`'s `OAuthFlowDialog`) can establish a
+ * server-tier session the same way the `indus login` CLI verb does.
+ *
+ * Reuses the private {@link requestDeviceCode} / {@link pollForToken} helpers
+ * above rather than duplicating the request+poll sequence, and reports the
+ * verification URL / code through `callbacks.onAuth` exactly once, mirroring
+ * how `doLogin` renders them to the console. On success the token is persisted
+ * via {@link storeServerToken}; any thrown error (network failure, denial,
+ * expiry, timeout) propagates to the caller unchanged — `startOAuthLogin`'s
+ * caller (the dialog's try/catch) already renders a generic failure state.
+ *
+ * @param callbacks the framework's OAuth login callbacks (url + progress)
+ * @param serverUrl the indus-server base url (defaults to {@link INDUS_SERVER_URL})
+ * @param clientId  the device-flow client id (defaults to {@link INDUS_CLIENT_ID})
+ */
+export declare function runServerTierLogin(callbacks: OAuthLoginCallbacks, serverUrl?: string, clientId?: string): Promise<void>;
+/**
+ * Route a `login` / `logout` / `whoami` verb, if this invocation is one.
+ *
+ * Inspects `ctx.argv[0]`: returns a numeric exit code when it handled one of the
+ * auth verbs, or `undefined` when the leading token is something else so the
+ * caller falls through to a normal launch. Modeled on `runCredential` in
+ * `boot.ts`; `--server-url` / `--client-id` are parsed from the argv tail.
+ *
+ * @param ctx the seeded boot context (carries the raw argv)
+ */
+export declare function runLogin(ctx: BootContext): Promise<number | undefined>;

package/dist/types/launch/oauth.test.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `src/launch/oauth.ts` — unit tests for the indus-server bridge added to the
+ * merged sign-in directory and `startOAuthLogin`.
+ *
+ * Covers:
+ *   1. {@link listLoginProviders} includes the `indus-server` entry
+ *      (`SERVER_TIER_PROVIDER_ID`, `authKind: "oauth"`).
+ *   2. {@link startOAuthLogin} for `SERVER_TIER_PROVIDER_ID` drives the device
+ *      flow over a mocked `fetch`, reports `onAuth` exactly once with the right
+ *      shape, reports progress, never touches the vault, and resolves.
+ *   3. {@link startOAuthLogin} for an unregistered id still throws the
+ *      pre-existing "No browser sign-in is available" error (regression check).
+ *   4. A device/token failure (`access_denied`) propagates out of
+ *      `startOAuthLogin` unchanged rather than being swallowed.
+ *
+ * `storeServerToken` is mocked (partial mock of `../boot/server-token`) so the
+ * success-path test never touches the real `~/.indusagi/agent/server-token.json`
+ * file on the machine running the suite.
+ */
+export {};

package/dist/types/window-budget/summarize/condense.d.ts

@@ -38,6 +38,12 @@ export interface SummarizeDeps {
     readonly priorDigest?: string;
     /** Cancellation signal forwarded to the completer. */
     readonly signal?: AbortSignal;
+    /**
+     * Credential for the summarization model's provider, forwarded to the
+     * completer. Required in practice for sessions whose key is resolved
+     * per-call (server tier) rather than from an environment variable.
+     */
+    readonly apiKey?: string;
     /**
      * Optional cap on the digest size, in tokens, forwarded to the completer's
      * `maxTokens`. A modest ceiling keeps the summary itself from eating the

package/dist/types/workflow-engine/agent-runner.d.ts

@@ -34,7 +34,7 @@
  * test seam — a unit test drives the runner with an in-memory fake instead of a
  * real network round-trip.
  */
-import { type AgentMessage } from "../conductor";
+import { type AgentMessage, type SessionPermissionPolicy } from "../conductor";
 import { type AgentTool } from "../capability-deck";
 import { type AgentEvent } from "indusagi/agent";
 import type { WorkflowAgentRunner } from "./engine";
@@ -89,6 +89,25 @@ export interface WorkflowAgentRunnerOptions {
      * `Agent`. When omitted the runner uses `new Agent`.
      */
     readonly spawn?: (prompt: string, context: WorkflowSpawnContext) => WorkflowSubAgent;
+    /**
+     * Resolve the current server-tier gateway routing map (provider -> gateway
+     * base url). Called FRESH on every `run()` — never cached — so a mid-session
+     * `/login` (to "Indus Server") is always picked up on the very next subagent
+     * call. Mirrors {@link getApiKey}, which is likewise invoked per-request
+     * rather than resolved once at construction.
+     */
+    readonly getGatewayBaseUrls?: () => Promise<Record<string, string>>;
+    /**
+     * The parent session's live permission policy: the SAME mutable rule list the
+     * parent gate reads plus a live getter onto the conductor's current mode. When
+     * present, every spawned workflow subagent runs under a RESOLVER-LESS gate
+     * built from it — deny/ask rules, plan-mode enforcement, and the
+     * catastrophic-bash blocklist apply per inner tool call, and a mid-run mode
+     * switch (Shift+Tab) retargets the very next subagent tool call. A subagent
+     * cannot prompt, so an `ask` decision deterministically denies. Absent (a bare
+     * test construction), the subagent runs ungated as before.
+     */
+    readonly permissionPolicy?: SessionPermissionPolicy;
 }
 /**
  * Build a live {@link WorkflowAgentRunner} the host wires into the deck context.

package/dist/types/workspace/brand.d.ts

@@ -23,4 +23,4 @@ export declare const BRAND: Brand;
  * Single source of truth: bump this one line per release. Co-located with the
  * brand so `boot` reads it without importing the index barrel.
  */
-export declare const VERSION = "0.2.3";
+export declare const VERSION = "0.2.4";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "indusagi-coding-agent",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Indusagi coding agent — a terminal-first AI coding agent, built from scratch on the indusagi framework.",
   "author": "Varun Israni",
   "license": "MIT",
@@ -57,7 +57,7 @@
     "@sinclair/typebox": "^0.34.49",
     "chalk": "^5.6.2",
     "highlight.js": "^11.11.1",
-    "indusagi": "^0.13.2",
+    "indusagi": "^0.13.3",
     "ink": "^5.2.1",
     "jiti": "^2.7.0",
     "marked": "^18.0.4",