indusagi-coding-agent 0.2.3 → 0.2.5

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

@@ -1,387 +0,0 @@
-/**
- * Launch contract — the FROZEN type surface of Phase 10 (command-line surface).
- *
- * This module is the single typed seam between a raw `argv` and a fully
- * configured run. It owns the *application* command line: the declarative flag
- * table, the parsed {@link Invocation} those flags fold into, the gathered
- * `@file` {@link Attachments}, and the typed {@link CredentialFault} the
- * api-key sign-in surface raises. It declares *only* shapes plus a few inert,
- * pure helpers — no parsing, no readline, no I/O, no React. The reader
- * ({@link readInvocation}), the usage renderer ({@link renderUsage}), the
- * attachment gatherer ({@link gatherAttachments}), the model-catalog printer
- * ({@link printModelCatalog}), the resume picker ({@link pickResumeTarget}),
- * the settings browser ({@link browseSettings}), and the credential command
- * ({@link runCredentialCommand}) are each written against the names declared
- * here, so the file is intentionally small, append-mostly, and stable.
- *
- * Design stance:
- *   - There is exactly **one declarative {@link FlagSpec} table** ({@link FLAGS}).
- *     The reader walks it to bind tokens; {@link renderUsage} generates the help
- *     text *from the same table*. Help and parsing cannot drift, because there
- *     is no second hand-maintained help string to drift against.
- *   - {@link Invocation} is a **superset of the boot-layer minimal invocation**:
- *     it keeps `mode` / `prompt` / `flags` / `positionals` and adds the resolved,
- *     strongly-typed launch fields the runtime reads (model, account, system
- *     prompt, thinking effort, the tool/extension/mcp rosters, the output
- *     toggles). Boot routes on the thin shape; the launch layer enriches it.
- *   - Sign-in is **api-key only**. {@link runCredentialCommand} validates and
- *     stores keys per named account through the framework credential vault and
- *     {@link getEnvApiKey}; there is no OAuth verb and no OAuth route. Failures
- *     are a single typed {@link CredentialFault} union, never string sentinels.
- *   - `@file` arguments expand to one {@link Attachments} value: inlined prose
- *     plus base64 media, with the framework path resolver doing the lookup.
- *
- * Framework anchors (all from the `indusagi` package — the sibling rebuilt
- * framework this app targets):
- *   - `ThinkingLevel`, `SessionInfo`, `SessionListProgress`, `resolveReadPath`
- *                                                            ← `indusagi/agent`
- *   - `ImageContent`, `KnownProvider`, `ModelRegistry`, `getEnvApiKey`
- *                                                            ← `indusagi/ai`
- *   - `Settings`                                             ← `indusagi/shell-app`
- *
- * The launch layer never re-declares these; it composes them. The credential
- * vault (`AuthVault`) is an app-owned forward declaration here because the
- * framework publishes no credential-store type; Phase 2 supplies the concrete
- * multi-account vault.
- */
-import type { SessionInfo as ResumeRef, SessionListProgress, ThinkingLevel } from "indusagi/agent";
-import type { ImageContent, KnownProvider, ModelRegistry, OAuthCredentials } from "indusagi/ai";
-import type { Settings } from "indusagi/shell-app";
-import type { RunnerId } from "../boot/contract";
-/**
- * Re-exported framework / boot vocabulary that launch consumers routinely need.
- *
- * {@link ResumeRef} is the launch-local alias for the framework session
- * descriptor surfaced by the resume picker.
- */
-export type { ResumeRef, ThinkingLevel, SessionListProgress, ImageContent, KnownProvider, ModelRegistry, OAuthCredentials, Settings, RunnerId, };
-/**
- * The three terminal output modes the launch layer can resolve to. These map
- * one-to-one onto the boot {@link RunnerId} the orchestrator dispatches on:
- *
- *   - `text` — interactive terminal or a single human-readable answer.
- *   - `json` — a single non-interactive request whose result is structured.
- *   - `rpc`  — the headless line protocol for a driving parent process.
- *
- * `text` is the interactive default; `json` is selected by `--print` together
- * with a structured output toggle, and `rpc` by `--json` / `--rpc`.
- */
-export type OutputMode = "text" | "json" | "rpc";
-/**
- * The ordered reasoning-effort vocabulary accepted by `--thinking`, re-derived
- * here as a single source of truth for the parser and the usage generator.
- *
- * `off` disables extended reasoning entirely; the remaining rungs ascend in
- * effort. The tuple is `readonly` and ordered so the usage text can enumerate it
- * and so {@link isThinkingEffort} can validate against it without a second list.
- * It is a superset-compatible widening of the framework {@link ThinkingLevel}
- * (which omits `off`); callers that hand a level to the framework drop `off`.
- */
-export declare const THINKING_EFFORTS: readonly ["off", "minimal", "low", "medium", "high", "xhigh"];
-/** One reasoning-effort rung from {@link THINKING_EFFORTS}. */
-export type ThinkingEffort = (typeof THINKING_EFFORTS)[number];
-/**
- * Narrow an arbitrary string to a {@link ThinkingEffort}.
- *
- * Pure membership test against {@link THINKING_EFFORTS}; the model resolver
- * reuses it to parse the `model:effort` shorthand without importing the parser.
- */
-export declare function isThinkingEffort(value: string): value is ThinkingEffort;
-/** Narrow an arbitrary string to an {@link OutputMode}. */
-export declare function isOutputMode(value: string): value is OutputMode;
-/**
- * The closed roster of built-in tool names the `--tools` / `--no-tools` flags
- * select against. A literal tuple (rather than the live tool map) so the launch
- * layer can validate a `--tools` list before any tool module is constructed.
- */
-export declare const TOOL_NAMES: readonly ["read", "write", "edit", "bash", "grep", "find", "ls", "task", "todo_read", "todo_write", "web_fetch", "web_search", "composio"];
-/** One built-in tool identifier from {@link TOOL_NAMES}. */
-export type ToolName = (typeof TOOL_NAMES)[number];
-/** Narrow an arbitrary string to a known {@link ToolName}. */
-export declare function isToolName(value: string): value is ToolName;
-/**
- * The value vocabulary a flag binds to its target field.
- *
- *   - `boolean` — a bare switch; presence sets it true (e.g. `--print`).
- *   - `string`  — consumes the following token as text (e.g. `--model`).
- *   - `number`  — consumes the following token and coerces to a finite number.
- *   - `list`    — accumulates; either repeated or one comma-separated token
- *                 (e.g. `--mcp a --mcp b`, or `--tools read,bash`).
- */
-export type FlagKind = "boolean" | "string" | "number" | "list";
-/**
- * The default value attached to a {@link FlagSpec}, narrowed by {@link FlagKind}:
- * a boolean default for switches, a string for value flags, a number for numeric
- * flags, and a string array for lists.
- */
-export type FlagDefault = boolean | string | number | readonly string[];
-/**
- * One row of the single declarative flag table.
- *
- * Every recognised option is described here exactly once. The reader indexes the
- * table by {@link name} and {@link aliases} to bind tokens to
- * {@link Invocation.flags}; the usage generator walks the same rows to render the
- * option reference. There is no second source of truth for either side.
- */
-export interface FlagSpec {
-    /**
-     * Canonical long spelling, leading dashes included (e.g. `"--model"`). This is
-     * also the key the parsed value lands under in {@link Invocation.flags}, sans
-     * the leading dashes.
-     */
-    readonly name: string;
-    /**
-     * Accepted alternate spellings — short forms (`"-m"`) and synonyms
-     * (`"--rpc"` for `"--json"`). All alias hits normalise to {@link name}.
-     */
-    readonly aliases?: readonly string[];
-    /** The value vocabulary this flag binds (see {@link FlagKind}). */
-    readonly kind: FlagKind;
-    /** One-line description rendered verbatim in the generated usage text. */
-    readonly describe: string;
-    /**
-     * Optional default folded into {@link Invocation.flags} when the flag is
-     * absent. Its runtime type must match {@link kind}.
-     */
-    readonly default?: FlagDefault;
-}
-/**
- * The fully parsed command line — the launch layer's enrichment of the thin
- * boot {@link RunnerId}-routing shape into the complete, strongly-typed surface
- * the runtime reads.
- *
- * The first four members ({@link mode}, {@link prompt}, {@link flags},
- * {@link positionals}) are the superset of the boot-layer minimal invocation
- * (`positionals` is the renamed `rest`); everything below is the resolved launch
- * configuration. {@link flags} retains the loosely-typed bag for extension flags
- * and round-tripping, while the named fields below give consumers a precise,
- * pre-coerced view of the options that matter to the runtime. Treat every field
- * as read-only.
- */
-export interface Invocation {
-    /** Resolved terminal output mode; selects the boot runner. */
-    readonly mode: OutputMode;
-    /** First user message assembled from positionals, stdin, and attachments. */
-    readonly prompt?: string;
-    /** All parsed switches, keyed by canonical flag name (extension-flag escape hatch). */
-    readonly flags: Record<string, FlagValue>;
-    /** Positional tokens not consumed as flags (the boot layer's `rest`, renamed). */
-    readonly positionals: string[];
-    /** `@file` arguments expanded to inline prose plus base64 media, if any. */
-    readonly attachments?: Attachments;
-    /** Explicit model selector (`--model` / `-m`), provider-qualified or bare. */
-    readonly model?: string;
-    /** Model to fall back to when the selected model is overloaded mid-turn (`--fallback-model`). */
-    readonly fallbackModel?: string;
-    /** Named credential account to authenticate the run with (`--account`). */
-    readonly account?: string;
-    /** Working directory the run is scoped to (`--cwd`); absent means process cwd. */
-    readonly cwd?: string;
-    /** Replacement system prompt (`--system`); absent keeps the built-in. */
-    readonly system?: string;
-    /** Extra text appended after the system prompt (`--append-system`). */
-    readonly appendSystem?: string;
-    /** Reasoning-effort rung requested via `--thinking`. */
-    readonly thinking?: ThinkingEffort;
-    /** Explicit tool allow-list (`--tools`); absent means every built-in tool. */
-    readonly tools?: ToolName[];
-    /** Disable all tools for this run (`--no-tools`). */
-    readonly noTools: boolean;
-    /** External MCP server endpoints to attach (`--mcp`, repeatable / comma-joined). */
-    readonly mcp: string[];
-    /** Run a single request and exit, printing only the result (`--print` / `-p`). */
-    readonly print: boolean;
-    /** Force the interactive REPL even alongside a prompt (`--interactive` / `-i`). */
-    readonly interactive: boolean;
-    /** Asking for the usage banner (`--help` / `-h`). */
-    readonly help: boolean;
-    /** Asking for the version string (`--version` / `-v`). */
-    readonly version: boolean;
-}
-/**
- * The runtime value a parsed flag can carry in {@link Invocation.flags}: a
- * boolean switch, a scalar value, a numeric value, or an accumulated list.
- */
-export type FlagValue = boolean | string | number | string[];
-/**
- * The result of expanding the `@file` arguments collected on the command line.
- *
- * Text files are inlined into {@link prose} (each wrapped in a delimited block
- * keyed by its path); image files are decoded to framework {@link ImageContent}
- * and collected in {@link media}. Both are concatenated onto the first user
- * message. An invocation with no `@file` arguments has no {@link Attachments} at
- * all rather than an empty one.
- */
-export interface Attachments {
-    /** Concatenated text of every inlined file, each wrapped with its path. */
-    readonly prose: string;
-    /** Base64 image content decoded from every image `@file` argument. */
-    readonly media: ImageContent[];
-}
-/**
- * Options for {@link gatherAttachments}: the cwd the framework path resolver
- * resolves `@file` references against, and an optional progress sink.
- */
-export interface AttachmentOptions {
-    /** Working directory `@file` references are resolved relative to. */
-    readonly cwd: string;
-}
-/**
- * The two verbs the credential command recognises as the first positional
- * token. Anything else means the command does not own this invocation and the
- * caller proceeds to normal launch.
- *
- *   - `signin`  — validate and store an api key for a provider / account.
- *   - `signout` — remove a stored credential for a provider / account.
- */
-export type CredentialVerb = "signin" | "signout";
-/**
- * A provider entry in the credential directory — the facts the sign-in prompts
- * print and validate against. {@link envKey} is the conventional environment
- * variable {@link getEnvApiKey} reads; {@link docsUrl} is where the user obtains
- * a key. These are external provider conventions, not derived data.
- */
-export interface ProviderEntry {
-    /** Stable provider id matching the framework {@link KnownProvider} vocabulary. */
-    readonly id: KnownProvider | string;
-    /** Human-facing provider label for menus and prompts. */
-    readonly label: string;
-    /** Conventional api-key environment variable for this provider. */
-    readonly envKey: string;
-    /** Page where a user obtains an api key for this provider. */
-    readonly docsUrl: string;
-}
-/**
- * The closed set of failure categories the credential command can raise.
- * A consumer switches on {@link CredentialFault.kind}, never on message text:
- *
- *   - `unknown-provider` — the named provider is not in the directory.
- *   - `invalid-key`      — the supplied key failed format validation.
- *   - `invalid-account`  — the account name failed the naming rules.
- *   - `name-collision`   — the account name already exists for that provider.
- *   - `not-found`        — sign-out targeted a credential that is not stored.
- *   - `vault`            — the underlying credential store read/write failed.
- *   - `aborted`          — the user cancelled an interactive prompt.
- */
-export type CredentialFaultKind = "unknown-provider" | "invalid-key" | "invalid-account" | "name-collision" | "not-found" | "vault" | "aborted";
-/**
- * A typed credential failure. {@link kind} drives recovery; {@link hint} carries
- * a single actionable next step for the human (e.g. the env-var to set), and
- * {@link cause} preserves any wrapped error for diagnostics.
- */
-export interface CredentialFault {
-    /** The failure category (the discriminant). */
-    readonly kind: CredentialFaultKind;
-    /** Human-readable summary of what failed. */
-    readonly message: string;
-    /** Optional single actionable suggestion for resolving the fault. */
-    readonly hint?: string;
-    /** Optional wrapped underlying error. */
-    readonly cause?: unknown;
-}
-/**
- * Construct a {@link CredentialFault}. A tiny inert helper so call sites raise a
- * well-formed typed fault without re-spelling the shape.
- */
-export declare function credentialFault(kind: CredentialFaultKind, message: string, extra?: {
-    hint?: string;
-    cause?: unknown;
-}): CredentialFault;
-/**
- * The credential-vault surface the credential command depends on.
- *
- * The framework publishes no credential-store type, so the launch contract
- * forward-declares the slice it needs: per-provider, per-account records keyed by
- * an account name. A record stores *either* an api key or a set of
- * browser-sign-in credentials; the vault refreshes an expired browser token
- * before yielding a usable key. Phase 2 supplies the concrete multi-account
- * vault; this interface lets the credential command compile and be unit-tested
- * against an in-memory stand-in before then.
- */
-export interface AuthVault {
-    /** Stored account names for a provider, in insertion order. */
-    listAccounts(provider: string): Promise<string[]>;
-    /** The default account name for a provider, if one is set. */
-    defaultAccount(provider: string): Promise<string | undefined>;
-    /** Persist an api key under a provider / account, optionally as the default. */
-    putApiKey(provider: string, account: string, apiKey: string, makeDefault?: boolean): Promise<void>;
-    /**
-     * Persist browser-sign-in credentials under a provider / account, optionally
-     * as the default.
-     */
-    putOAuth(provider: string, account: string, credentials: OAuthCredentials, makeDefault?: boolean): Promise<void>;
-    /**
-     * Report whether a stored account holds an api key or browser-sign-in
-     * credentials, or `undefined` when nothing is stored there.
-     */
-    authKind(provider: string, account: string): Promise<"apiKey" | "oauth" | undefined>;
-    /**
-     * Resolve a stored account to a live api-key string. An api-key record yields
-     * its key verbatim; a browser-sign-in record is refreshed through the
-     * framework (persisting any rotated token) before its usable key is returned.
-     * Resolves `undefined` when nothing usable is stored.
-     */
-    readUsableKey(provider: string, account: string): Promise<string | undefined>;
-    /** Remove a stored credential; resolves false when nothing was removed. */
-    remove(provider: string, account?: string): Promise<boolean>;
-}
-/**
- * Options for {@link runCredentialCommand}: the resolved vault and the directory
- * the vault persists to. Injected so tests drive the command over an in-memory
- * vault with no real disk writes.
- */
-export interface CredentialCommandOptions {
-    /** The credential store to read and write. */
-    readonly vault: AuthVault;
-    /** Absolute directory the vault persists credentials under. */
-    readonly profileDir: string;
-}
-/**
- * The filter applied when rendering the `--list-models` table. Every field is
- * optional; an absent field matches everything. {@link search} is a plain
- * case-insensitive substring test over the provider/model identifier — no fuzzy
- * matcher and no external ranking.
- */
-export interface CatalogFilter {
-    /** Restrict to a single provider id. */
-    readonly provider?: KnownProvider | string;
-    /** Keep only models that advertise a reasoning budget. */
-    readonly thinkingOnly?: boolean;
-    /** Keep only models that accept image input. */
-    readonly imagesOnly?: boolean;
-    /** Case-insensitive substring filter over the model identifier. */
-    readonly search?: string;
-}
-/**
- * A function that loads a set of resumable sessions, reporting incremental
- * progress. The resume picker takes two: one for the current working
- * directory and one for every directory, both shaped like the framework
- * session lister.
- */
-export type SessionLoader = (onProgress?: SessionListProgress) => Promise<ResumeRef[]>;
-/**
- * A launch-time error from the resume flow (the React-Ink picker failing to
- * mount, or a session store read fault). Typed so the orchestrator can fall back
- * to a fresh session rather than crash.
- */
-export interface ResumeFault {
-    /** Human-readable summary of what failed. */
-    readonly message: string;
-    /** Optional wrapped underlying error. */
-    readonly cause?: unknown;
-}
-/**
- * Options for {@link browseSettings}: the resolved settings, the directories of
- * user-authored resources to enumerate, the active cwd, and the profile
- * directory. The browser renders a plain console listing of these — no TUI.
- */
-export interface SettingsBrowseOptions {
-    /** The merged, resolved user settings. */
-    readonly settings: Settings;
-    /** Resolved absolute paths of discovered resources, grouped by category. */
-    readonly resolvedPaths: Readonly<Record<string, readonly string[]>>;
-    /** The active working directory. */
-    readonly cwd: string;
-    /** The profile directory the settings were loaded from. */
-    readonly profileDir: string;
-}

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

@@ -1,112 +0,0 @@
-/**
- * Credential command — `runCredentialCommand`.
- *
- * The top-level `signin` / `signout` surface. Sign-in supports two methods: a
- * browser sign-in (OAuth) for the providers the framework registry exposes, and
- * an api-key flow for every provider in the directory. When a provider is
- * sign-in-capable the command prefers the browser flow but still lets the user
- * pick an api key; for the rest it stores a key directly. The env-var override is
- * consulted first via the framework {@link getEnvApiKey}, so a user who already
- * exported (e.g.) `ANTHROPIC_API_KEY` can sign in without re-typing the secret.
- *
- * The command owns the first positional token only: it returns `handled: false`
- * when that token is neither {@link CredentialVerb} so the caller falls through
- * to a normal launch. Every failure is a typed {@link CredentialFault}; nothing
- * is signalled by a string sentinel or a bare `process.exit`.
- *
- * I/O is injected. The default {@link CredentialIo} wraps `process.stdout` plus a
- * `node:readline/promises` interface, but tests drive the whole flow over an
- * in-memory stand-in with no real terminal and an in-memory vault.
- */
-import { type CredentialCommandOptions, type CredentialFault, type CredentialVerb, type ProviderEntry } from "./contract";
-/**
- * The console seam the credential command reads and writes through.
- *
- * Pinned to the three operations the flow actually needs — emit a line, read a
- * line of input, and read a secret line — so a test can capture output into an
- * array and feed scripted answers without a real TTY.
- */
-export interface CredentialIo {
-    /** Emit one line of human-facing text. */
-    print(line: string): void;
-    /** Prompt for and read one line of visible input. */
-    ask(prompt: string): Promise<string>;
-    /** Prompt for and read one line of secret input (key entry). */
-    askSecret(prompt: string): Promise<string>;
-}
-/**
- * The default {@link CredentialIo} backed by `process.stdout` and a
- * `node:readline/promises` interface. Secret entry mutes echo while the line is
- * typed by suppressing the terminal write of each keystroke.
- */
-export declare function defaultCredentialIo(): CredentialIo;
-/**
- * The api-key provider directory: every provider the sign-in surface can store a
- * key for, with its conventional env var and the page a user obtains a key from.
- * These are external provider facts; {@link envKey} is the variable
- * {@link getEnvApiKey} reads for the env-first shortcut.
- */
-export declare const PROVIDER_DIRECTORY: readonly ProviderEntry[];
-/** Look up a provider entry by id (case-insensitive over the directory). */
-export declare function findProvider(id: string): ProviderEntry | undefined;
-/**
- * The two ways a provider can be signed in to.
- *
- *   - `oauth`   — a browser sign-in driven by the framework registry.
- *   - `api-key` — paste / store a provider api key.
- */
-export type SigninMethod = "oauth" | "api-key";
-/** Narrow a `--method` value to a {@link SigninMethod}. */
-export declare function asSigninMethod(value: string | undefined): SigninMethod | undefined;
-/** Whether a provider id can be signed in to through the browser registry. */
-export declare function isOAuthCapable(id: string): boolean;
-/**
- * Validate an api key against the format rules: non-empty, at least
- * {@link MIN_KEY_LENGTH} characters, and free of placeholder markers. Returns a
- * typed {@link CredentialFault} on rejection, or `undefined` when the key passes.
- */
-export declare function validateApiKey(key: string): CredentialFault | undefined;
-/**
- * Validate an account name: at most {@link MAX_ACCOUNT_LENGTH} characters and
- * matching {@link ACCOUNT_PATTERN}. Returns a typed fault on rejection, or
- * `undefined` when the name is acceptable.
- */
-export declare function validateAccountName(name: string): CredentialFault | undefined;
-/**
- * The outcome of {@link runCredentialCommand}.
- *
- * {@link handled} reports whether the first positional token was a recognised
- * {@link CredentialVerb}; when `false`, the caller proceeds to a normal launch
- * unchanged. {@link fault} carries a typed failure when the command was handled
- * but did not complete.
- */
-export interface CredentialResult {
-    /** Whether this invocation was a `signin` / `signout` command. */
-    readonly handled: boolean;
-    /** The verb that ran, when {@link handled} is true. */
-    readonly verb?: CredentialVerb;
-    /** The provider id the verb acted on, when one was resolved. */
-    readonly provider?: string;
-    /** A typed failure, present only when the handled command did not complete. */
-    readonly fault?: CredentialFault;
-}
-/**
- * Run the api-key sign-in / sign-out command.
- *
- * Returns `{ handled: false }` immediately when `argv[0]` is neither verb, so the
- * orchestrator can call this first and fall through on a miss. Otherwise it
- * resolves the provider (prompting from the directory when none is named), runs
- * the verb, and resolves a {@link CredentialResult} — never throwing for an
- * expected failure, which surfaces as {@link CredentialResult.fault}.
- *
- * @param argv the raw token list following the program name
- * @param opts the injected vault, profile directory, and (optionally) the io seam
- */
-export declare function runCredentialCommand(argv: readonly string[], opts: CredentialCommandOptions & {
-    io?: CredentialIo;
-}): Promise<CredentialResult>;
-/**
- * Render a {@link CredentialFault} as the single human-facing message the caller
- * prints before exiting non-zero. Pure; no I/O.
- */
-export declare function formatCredentialFault(fault: CredentialFault): string;

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

@@ -1,28 +0,0 @@
-/**
- * Launch subsystem — public barrel.
- *
- * Re-exports the frozen Phase-10 contract surface: the parsed
- * {@link Invocation} and its {@link OutputMode} / {@link ThinkingEffort} /
- * {@link ToolName} vocabularies, the declarative {@link FlagSpec} table types,
- * the gathered {@link Attachments} shape, the typed {@link CredentialFault}
- * union and its {@link AuthVault} seam, the model-catalog filter, and the resume
- * / settings-browser option shapes. Behavior modules (the reader, the usage
- * renderer, the credential command, the attachment gatherer, the catalog
- * printer, the resume picker, the settings browser) attach their exports here as
- * they land, so consumers import the launch surface from `src/launch` rather
- * than reaching into individual modules.
- */
-export type { OutputMode, ThinkingEffort, ToolName, FlagKind, FlagDefault, FlagSpec, Invocation, FlagValue, Attachments, AttachmentOptions, CredentialVerb, ProviderEntry, CredentialFaultKind, CredentialFault, AuthVault, CredentialCommandOptions, CatalogFilter, SessionLoader, ResumeFault, SettingsBrowseOptions, ResumeRef, ThinkingLevel, SessionListProgress, ImageContent, KnownProvider, ModelRegistry, OAuthCredentials, Settings, RunnerId, } from "./contract";
-export { THINKING_EFFORTS, TOOL_NAMES, isThinkingEffort, isOutputMode, isToolName, credentialFault, } from "./contract";
-export { FLAG_SPECS, FLAG_GROUPS, readInvocation, readFileReferences, renderUsage, gatherAttachments, AttachmentError, } from "./invocation";
-export type { FlagGroup, GroupedFlagSpec, AttachmentErrorKind, } from "./invocation";
-export { runPackageCommand, defaultPackageIo, PACKAGE_COMMANDS, } from "./packages";
-export type { PackageCommand, PackageIo, PackageCommandOptions, PackageResult, } from "./packages";
-export { runCredentialCommand, defaultCredentialIo, formatCredentialFault, validateApiKey, validateAccountName, findProvider, isOAuthCapable, asSigninMethod, PROVIDER_DIRECTORY, } from "./credentials";
-export type { CredentialIo, CredentialResult, SigninMethod } from "./credentials";
-export { registerBuiltInOAuthProviders, listLoginProviders, startOAuthLogin, openLoginUrl, hasRegisteredOAuthClientId, } from "./oauth";
-export type { AuthKind, LoginProvider, OAuthLoginResult, } from "./oauth";
-export { printModelCatalog, defaultCatalogIo, registrySource } from "./catalog";
-export type { CatalogIo, CatalogModelSource } from "./catalog";
-export { pickResumeTarget, browseSettings, mergeSessions, renderSettingsListing, defaultResumeDeps, defaultSettingsBrowseIo, } from "./pickers";
-export type { ResumeDeps, ResumeOutcome, SettingsBrowseIo, } from "./pickers";

package/dist/types/launch/invocation/attachments.d.ts

@@ -1,72 +0,0 @@
-/**
- * The attachment gatherer — expands `@file` references into one
- * {@link Attachments} value.
- *
- * Each `@file` token collected by the reader is resolved through the framework
- * path resolver ({@link resolveReadPath}, which handles `~` expansion and the
- * cwd), classified by extension, and folded into the result:
- *
- *   - **text files** are read as UTF-8 and inlined into {@link Attachments.prose}
- *     wrapped in a delimited block keyed by the resolved path, so the model sees
- *     which file each block came from;
- *   - **image files** are read as bytes, base64-encoded, and collected as
- *     framework {@link ImageContent} in {@link Attachments.media}.
- *
- * Guard rails:
- *   - an unknown extension, an oversized file, a missing file, or a read error
- *     raises a typed {@link AttachmentError} (with a {@link AttachmentErrorKind}
- *     discriminant) rather than a string or a process exit;
- *   - size caps bound the inlined text and the decoded image before either is
- *     materialised onto the message;
- *   - an empty file is skipped silently — it contributes neither prose nor media.
- *
- * The `@file` syntax, the extension classification, and base64 image attachment
- * are kept behaviours; only the typed-error model and the explicit caps are
- * owned here.
- */
-import type { Attachments, AttachmentOptions } from "../contract";
-/**
- * The closed set of attachment failure categories. A consumer switches on
- * {@link AttachmentError.kind}, never on message text:
- *
- *   - `unsupported`  — the file extension is neither text nor image.
- *   - `too-large`    — the file exceeds its kind's size cap.
- *   - `not-found`    — the resolved path does not exist.
- *   - `read-failed`  — the file could not be read or stat-ed.
- */
-export type AttachmentErrorKind = "unsupported" | "too-large" | "not-found" | "read-failed";
-/**
- * A typed `@file` expansion failure. Carries the offending reference and the
- * resolved path for diagnostics; {@link cause} preserves any wrapped error.
- */
-export declare class AttachmentError extends Error {
-    /** The failure category (the discriminant). */
-    readonly kind: AttachmentErrorKind;
-    /** The raw `@file` reference as supplied on the command line. */
-    readonly reference: string;
-    /** The resolved absolute path, when resolution succeeded. */
-    readonly resolvedPath?: string;
-    /** The wrapped underlying error, if any. */
-    readonly cause?: unknown;
-    constructor(kind: AttachmentErrorKind, message: string, detail: {
-        reference: string;
-        resolvedPath?: string;
-        cause?: unknown;
-    });
-}
-/**
- * Expand the `@file` references into a single {@link Attachments} value.
- *
- * Resolves each reference against {@link AttachmentOptions.cwd} via the framework
- * resolver, classifies it by extension, enforces the per-kind size cap, and
- * appends either a text block to the prose or an {@link ImageContent} to the
- * media. References list is taken in order; the prose blocks are joined with a
- * blank line between them. An empty references list yields an empty
- * {@link Attachments} (the caller decides whether to attach it at all).
- *
- * @param references the raw `@file` paths (without the leading `@`)
- * @param options    the cwd the references resolve against
- * @throws AttachmentError on an unsupported extension, an oversized file, a
- *         missing file, or a read failure
- */
-export declare function gatherAttachments(references: readonly string[], options: AttachmentOptions): Promise<Attachments>;

package/dist/types/launch/invocation/flags.d.ts

@@ -1,59 +0,0 @@
-/**
- * The single declarative flag table.
- *
- * Every recognised command-line option is described here exactly once, as one
- * {@link FlagSpec} row. Two consumers walk this same table:
- *
- *   - the reader ({@link readInvocation}) indexes it by canonical name and alias
- *     to bind raw tokens into the parsed {@link Invocation}; and
- *   - the usage generator ({@link renderUsage}) enumerates it to render the
- *     option reference — there is no second, hand-maintained help string for it
- *     to drift against.
- *
- * Because both sides read the same rows, the help text and the parser cannot
- * disagree about which flags exist, what they take, or what they mean. The order
- * of the rows is the order options appear in the generated usage, grouped by the
- * {@link FlagGroup} sidecar map below; keeping that order intentional is the only
- * editorial concern when a row is added.
- *
- * Flag names and their semantics are a stable product contract (and largely an
- * industry convention), so they are kept as-is; only the table that declares
- * them and the code that reads it are owned here.
- */
-import type { FlagSpec } from "../contract";
-/**
- * The heading a flag is filed under in the generated usage. Purely an editorial
- * grouping for {@link renderUsage}; it has no effect on parsing.
- */
-export type FlagGroup = "output" | "model" | "context" | "tools" | "meta";
-/**
- * A {@link FlagSpec} carrying its usage section. The extra {@link group} field is
- * inert at parse time; the reader ignores it and only the renderer reads it.
- */
-export interface GroupedFlagSpec extends FlagSpec {
-    /** The usage section this row is rendered under. */
-    readonly group: FlagGroup;
-}
-/**
- * Human-readable titles for each {@link FlagGroup}, in render order. The usage
- * generator walks this list, then within each group emits the matching rows from
- * {@link FLAG_SPECS} in declaration order.
- */
-export declare const FLAG_GROUPS: readonly {
-    readonly id: FlagGroup;
-    readonly title: string;
-}[];
-/**
- * The one declarative option table. Every recognised flag is one row; the reader
- * and the usage generator both index this and nothing else.
- *
- * Conventions:
- *   - {@link FlagSpec.name} is the canonical long spelling (leading dashes
- *     included) and also the key the parsed value lands under in
- *     {@link Invocation.flags} (sans the dashes).
- *   - {@link FlagSpec.aliases} hold short forms and synonyms; every alias hit
- *     normalises to {@link FlagSpec.name}.
- *   - {@link FlagSpec.kind} fixes the value vocabulary: `boolean` switches,
- *     `string` / `number` value flags, and accumulating `list` flags.
- */
-export declare const FLAG_SPECS: readonly GroupedFlagSpec[];