@mafdet/cli 0.3.0

package/dist/api/http.js

@@ -0,0 +1,207 @@
+import { randomUUID } from "node:crypto";
+import { ExitCode } from "../output/exit-codes.js";
+import { ApiError, errorForResponse } from "./errors.js";
+export const DEFAULT_TIMEOUT_MS = 120_000;
+/** A JSON answer this large is a bug or an attack, not a model reply. */
+export const DEFAULT_MAX_BYTES = 32 * 1024 * 1024;
+/**
+ * The one place that talks to the network.
+ *
+ * It deliberately does NOT retry. Only an explicit 429 is even retryable, and
+ * the decision belongs to the caller that knows whether replaying is safe —
+ * a timeout or a 5xx may mean the model already started generating, and
+ * generation is already billed (plan §7.5).
+ */
+export class HttpClient {
+    baseUrl;
+    apiKey;
+    userAgent;
+    timeoutMs;
+    maxBytes;
+    fetchImpl;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+        this.apiKey = options.apiKey;
+        this.userAgent = options.userAgent;
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+        this.fetchImpl = options.fetchImpl ?? fetch;
+    }
+    async getJson(path, options = {}) {
+        const response = await this.send("GET", path, undefined, options);
+        return this.readJson(response, options);
+    }
+    async postJson(path, body, options = {}) {
+        const response = await this.send("POST", path, body, options);
+        return this.readJson(response, options);
+    }
+    /** For `/v1/audio/speech`, which answers with audio bytes. */
+    async postBinary(path, body, options = {}) {
+        const response = await this.send("POST", path, body, options);
+        const requestId = requestIdOf(response.headers);
+        if (!response.ok)
+            throw await this.errorFrom(response, requestId, options);
+        const bytes = await readCapped(response, options.maxBytes ?? this.maxBytes, requestId);
+        return {
+            data: bytes,
+            status: response.status,
+            headers: response.headers,
+            requestId,
+        };
+    }
+    /** Raw streaming response, for the SSE reader to consume. */
+    async postStream(path, body, options = {}) {
+        const response = await this.send("POST", path, body, options, {
+            accept: "text/event-stream",
+        });
+        const requestId = requestIdOf(response.headers);
+        if (!response.ok)
+            throw await this.errorFrom(response, requestId, options);
+        return { response, requestId };
+    }
+    async send(method, path, body, options, extraHeaders = {}) {
+        const url = `${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+        const timeoutMs = options.timeoutMs ?? this.timeoutMs;
+        const timeoutController = new AbortController();
+        const timer = setTimeout(() => timeoutController.abort(), timeoutMs);
+        // Two independent reasons to stop, and they must stay distinguishable:
+        // "we gave up" and "the user pressed Ctrl+C" are different exit codes.
+        const signal = options.signal
+            ? AbortSignal.any([options.signal, timeoutController.signal])
+            : timeoutController.signal;
+        const headers = {
+            accept: "application/json",
+            "user-agent": this.userAgent,
+            "x-request-id": randomUUID(),
+            ...extraHeaders,
+            ...options.headers,
+        };
+        if (this.apiKey)
+            headers.authorization = `Bearer ${this.apiKey}`;
+        if (body !== undefined)
+            headers["content-type"] = "application/json";
+        try {
+            return await this.fetchImpl(url, {
+                method,
+                headers,
+                body: body === undefined ? undefined : JSON.stringify(body),
+                signal,
+            });
+        }
+        catch (error) {
+            if (options.signal?.aborted) {
+                throw new ApiError({
+                    kind: "cancelled",
+                    exitCode: ExitCode.Cancelled,
+                    message: "cancelled",
+                });
+            }
+            if (timeoutController.signal.aborted) {
+                throw new ApiError({
+                    kind: "timeout",
+                    exitCode: ExitCode.Unavailable,
+                    message: `request timed out after ${timeoutMs}ms`,
+                });
+            }
+            throw new ApiError({
+                kind: "network",
+                exitCode: ExitCode.Unavailable,
+                message: `network error: ${error.message}`,
+            });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async readJson(response, options) {
+        const requestId = requestIdOf(response.headers);
+        const maxBytes = options.maxBytes ?? this.maxBytes;
+        const text = new TextDecoder().decode(await readCapped(response, maxBytes, requestId));
+        if (!response.ok) {
+            throw errorForResponse(response.status, safeParse(text), response.headers, requestId);
+        }
+        let data;
+        try {
+            data = JSON.parse(text);
+        }
+        catch {
+            throw new ApiError({
+                kind: "server",
+                exitCode: ExitCode.Unavailable,
+                status: response.status,
+                requestId,
+                message: "the API returned a body that is not valid JSON",
+            });
+        }
+        return {
+            data,
+            status: response.status,
+            headers: response.headers,
+            requestId,
+        };
+    }
+    async errorFrom(response, requestId, options) {
+        const text = new TextDecoder().decode(await readCapped(response, options.maxBytes ?? this.maxBytes, requestId));
+        return errorForResponse(response.status, safeParse(text), response.headers, requestId);
+    }
+}
+/**
+ * Read a body while counting bytes, so an endless or oversized response is cut
+ * off rather than filling memory. Content-Length is checked first when it is
+ * present, but the running count is what actually enforces the cap — a
+ * streaming body may not declare a length.
+ */
+export async function readCapped(response, maxBytes, requestId) {
+    const declared = Number(response.headers.get("content-length"));
+    if (Number.isFinite(declared) && declared > maxBytes) {
+        throw tooLarge(maxBytes, requestId);
+    }
+    const body = response.body;
+    if (!body)
+        return new Uint8Array(0);
+    const reader = body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            total += value.byteLength;
+            if (total > maxBytes) {
+                await reader.cancel();
+                throw tooLarge(maxBytes, requestId);
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return out;
+}
+function tooLarge(maxBytes, requestId) {
+    return new ApiError({
+        kind: "too_large",
+        exitCode: ExitCode.Unavailable,
+        requestId,
+        message: `response exceeded the ${maxBytes} byte limit`,
+    });
+}
+function requestIdOf(headers) {
+    return (headers.get("x-litellm-call-id") ?? headers.get("x-request-id") ?? undefined);
+}
+function safeParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { error: { message: text.slice(0, 500) } };
+    }
+}

package/dist/api/models.d.ts

@@ -0,0 +1,68 @@
+import type { HttpClient } from "./http.js";
+/** What the data plane says: an id this key may call. Metadata is unreliable. */
+export interface DataPlaneModel {
+    id: string;
+}
+/** What the catalogue says a model is. */
+export interface CatalogModel {
+    modelId: string;
+    displayName?: string;
+    provider?: string;
+    capabilities?: string[];
+    apiSurface?: string;
+    contextLength?: number;
+    inputPricePer1mMicroUsd?: string;
+    outputPricePer1mMicroUsd?: string;
+    accessTier?: string;
+    deprecated?: boolean;
+    retires_at?: string | null;
+    replacement_model_id?: string | null;
+}
+export interface ResolvedModel extends CatalogModel {
+    agentEligible: boolean;
+}
+export interface ModelSets {
+    /** Callable AND described: what the CLI offers. */
+    available: ResolvedModel[];
+    /** Callable but undescribed — usable with an explicit --model, never by the agent. */
+    unlisted: string[];
+    /** Described but not callable with this key. */
+    inaccessible: string[];
+}
+/**
+ * Agent admission. Every condition is something the catalogue states outright;
+ * nothing is inferred from the model id, the provider or the display name —
+ * that inference is exactly what CLI-000C removed from the server.
+ */
+export declare function isAgentEligible(model: CatalogModel | undefined): boolean;
+/**
+ * Combine the two sources.
+ *
+ *   data plane  → proof of ACCESS for this key (the only surface that knows
+ *                 the key's allowlist), but its metadata is LiteLLM
+ *                 boilerplate: it reports a 1M context window for a 128K
+ *                 model and openai as the owner of a DeepSeek route.
+ *   catalogue   → the TRUTH about what each model is.
+ *
+ * Anything callable but undescribed stays usable, never agent-eligible:
+ * fail closed rather than guess (plan §4.2).
+ */
+export declare function intersectModels(dataPlane: readonly DataPlaneModel[], catalog: readonly CatalogModel[]): ModelSets;
+/** GET /v1/models — the key's access list. */
+export declare function fetchAccessibleModels(client: HttpClient): Promise<DataPlaneModel[]>;
+/** GET /models on the business API — public catalogue, no key required. */
+export declare function fetchCatalog(client: HttpClient): Promise<CatalogModel[]>;
+/**
+ * Check the model serves the endpoint the command needs, before spending a
+ * request on it. The gateway does answer 400 `model_api_surface_mismatch`, but
+ * it buries the code inside a stringified JSON message (CLI-001), and a local
+ * check turns that into a usage error the user can act on.
+ */
+export declare function assertSurface(catalog: readonly CatalogModel[], modelId: string, expected: string): CatalogModel | undefined;
+export declare class SurfaceMismatchError extends Error {
+    readonly modelId: string;
+    readonly actual: string;
+    readonly expected: string;
+    constructor(modelId: string, actual: string, expected: string);
+}
+//# sourceMappingURL=models.d.ts.map

package/dist/api/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../src/api/models.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,0CAA0C;AAC1C,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,oBAAoB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACtC;AAED,MAAM,WAAW,aAAc,SAAQ,YAAY;IACjD,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,SAAS;IACxB,mDAAmD;IACnD,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,sFAAsF;IACtF,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,gDAAgD;IAChD,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,YAAY,GAAG,SAAS,GAAG,OAAO,CAQxE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,SAAS,cAAc,EAAE,EACpC,OAAO,EAAE,SAAS,YAAY,EAAE,GAC/B,SAAS,CAuBX;AAED,8CAA8C;AAC9C,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,UAAU,GACjB,OAAO,CAAC,cAAc,EAAE,CAAC,CAG3B;AAED,2EAA2E;AAC3E,wBAAsB,YAAY,CAChC,MAAM,EAAE,UAAU,GACjB,OAAO,CAAC,YAAY,EAAE,CAAC,CAGzB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,YAAY,GAAG,SAAS,CAY1B;AAED,qBAAa,oBAAqB,SAAQ,KAAK;IAE3C,QAAQ,CAAC,OAAO,EAAE,MAAM;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM;gBAFhB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM;CAO5B"}

package/dist/api/models.js

@@ -0,0 +1,91 @@
+/**
+ * Agent admission. Every condition is something the catalogue states outright;
+ * nothing is inferred from the model id, the provider or the display name —
+ * that inference is exactly what CLI-000C removed from the server.
+ */
+export function isAgentEligible(model) {
+    if (!model)
+        return false;
+    if (!(model.capabilities ?? []).includes("tool_use"))
+        return false;
+    if ((model.apiSurface ?? "CHAT_COMPLETIONS") !== "CHAT_COMPLETIONS")
+        return false;
+    // A model on its way out is not a new default; an explicit --model still works.
+    if (model.deprecated === true)
+        return false;
+    return true;
+}
+/**
+ * Combine the two sources.
+ *
+ *   data plane  → proof of ACCESS for this key (the only surface that knows
+ *                 the key's allowlist), but its metadata is LiteLLM
+ *                 boilerplate: it reports a 1M context window for a 128K
+ *                 model and openai as the owner of a DeepSeek route.
+ *   catalogue   → the TRUTH about what each model is.
+ *
+ * Anything callable but undescribed stays usable, never agent-eligible:
+ * fail closed rather than guess (plan §4.2).
+ */
+export function intersectModels(dataPlane, catalog) {
+    const byId = new Map(catalog.map((model) => [model.modelId, model]));
+    const accessible = dataPlane.map((model) => model.id);
+    const available = [];
+    const unlisted = [];
+    for (const id of accessible) {
+        const meta = byId.get(id);
+        if (!meta) {
+            unlisted.push(id);
+            continue;
+        }
+        available.push({ ...meta, agentEligible: isAgentEligible(meta) });
+    }
+    return {
+        available: available.sort((a, b) => a.modelId.localeCompare(b.modelId)),
+        unlisted: unlisted.sort(),
+        inaccessible: [...byId.keys()]
+            .filter((id) => !accessible.includes(id))
+            .sort(),
+    };
+}
+/** GET /v1/models — the key's access list. */
+export async function fetchAccessibleModels(client) {
+    const { data } = await client.getJson("/models");
+    return data.data ?? [];
+}
+/** GET /models on the business API — public catalogue, no key required. */
+export async function fetchCatalog(client) {
+    const { data } = await client.getJson("/models");
+    return data.data ?? [];
+}
+/**
+ * Check the model serves the endpoint the command needs, before spending a
+ * request on it. The gateway does answer 400 `model_api_surface_mismatch`, but
+ * it buries the code inside a stringified JSON message (CLI-001), and a local
+ * check turns that into a usage error the user can act on.
+ */
+export function assertSurface(catalog, modelId, expected) {
+    const model = catalog.find((m) => m.modelId === modelId);
+    // Unknown to the catalogue: let the request through rather than block a
+    // model the data plane may well accept (fail open for direct calls, closed
+    // only for agent admission).
+    if (!model)
+        return undefined;
+    const actual = model.apiSurface ?? "CHAT_COMPLETIONS";
+    if (actual !== expected) {
+        throw new SurfaceMismatchError(modelId, actual, expected);
+    }
+    return model;
+}
+export class SurfaceMismatchError extends Error {
+    modelId;
+    actual;
+    expected;
+    constructor(modelId, actual, expected) {
+        super(`${modelId} serves ${actual}, not ${expected} - pick a model for this command (mafdet models list --surface ...)`);
+        this.modelId = modelId;
+        this.actual = actual;
+        this.expected = expected;
+        this.name = "SurfaceMismatchError";
+    }
+}

package/dist/api/sse-parser.d.ts

@@ -0,0 +1,72 @@
+/**
+ * SSE reader for the chat data plane.
+ *
+ * Every rule here is a fact measured in Phase 0 against real transcripts from
+ * DeepSeek, Kimi, Qwen and Vertex Gemini (tests/fixtures/cli-000*), not an
+ * assumption about how streaming "usually" works:
+ *
+ *   - `id` and `name` arrive exactly once, so tool calls merge by `index`.
+ *   - Qwen sends `"id": ""` on continuation frames; `??` would overwrite the
+ *     real id with an empty string and the tool result would be rejected.
+ *   - Gemini packs a thought signature into the id (700+ chars) and delivers a
+ *     whole call in one frame, where Kimi takes nine — fragment counts mean
+ *     nothing.
+ *   - `finish_reason` arrives in its own frame with an empty delta; `[DONE]`
+ *     ends the stream.
+ *   - With `stream_options.include_usage`, usage arrives AFTER finish_reason
+ *     in a frame whose `choices` is non-empty but whose delta is empty. A
+ *     parser that only reads usage when `choices` is empty reports zero cost.
+ */
+export interface StreamedToolCall {
+    index: number;
+    id?: string;
+    name?: string;
+    /** Raw JSON text; parse only once the stream is complete. */
+    arguments: string;
+}
+export interface StreamUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}
+export interface StreamEvents {
+    /** Assistant text as it arrives. */
+    onText?: (delta: string) => void;
+}
+export interface StreamResult {
+    text: string;
+    toolCalls: StreamedToolCall[];
+    finishReason?: string;
+    usage?: StreamUsage;
+    done: boolean;
+}
+/** Split a byte stream into SSE `data:` payloads across arbitrary chunking. */
+export declare class SseFramer {
+    private buffer;
+    private readonly decoder;
+    push(chunk: Uint8Array): string[];
+    /** Flush whatever a closed stream left behind. */
+    end(): string[];
+    private drain;
+}
+/** Accumulates frames into a final answer plus tool calls. */
+export declare class ChatStreamAssembler {
+    private readonly events;
+    private readonly calls;
+    private text;
+    private finishReason?;
+    private usage?;
+    private done;
+    constructor(events?: StreamEvents);
+    /** @returns true when the stream is complete (`[DONE]`). */
+    push(payload: string): boolean;
+    result(): StreamResult;
+}
+/**
+ * Read a streaming response to completion.
+ *
+ * `signal` is the user's Ctrl+C: aborting stops reading AND closes the
+ * connection, which is what actually tells the gateway to stop generating.
+ */
+export declare function readChatStream(response: Response, events?: StreamEvents, signal?: AbortSignal): Promise<StreamResult>;
+//# sourceMappingURL=sse-parser.d.ts.map

package/dist/api/sse-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse-parser.d.ts","sourceRoot":"","sources":["../../src/api/sse-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,YAAY;IAC3B,oCAAoC;IACpC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,gBAAgB,EAAE,CAAC;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;CACf;AAWD,+EAA+E;AAC/E,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAE7C,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE;IAMjC,kDAAkD;IAClD,GAAG,IAAI,MAAM,EAAE;IASf,OAAO,CAAC,KAAK;CAYd;AAED,8DAA8D;AAC9D,qBAAa,mBAAmB;IAOlB,OAAO,CAAC,QAAQ,CAAC,MAAM;IANnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuC;IAC7D,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,YAAY,CAAC,CAAS;IAC9B,OAAO,CAAC,KAAK,CAAC,CAAc;IAC5B,OAAO,CAAC,IAAI,CAAS;gBAEQ,MAAM,GAAE,YAAiB;IAEtD,4DAA4D;IAC5D,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAgD9B,MAAM,IAAI,YAAY;CASvB;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,QAAQ,EAClB,MAAM,GAAE,YAAiB,EACzB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,YAAY,CAAC,CAkCvB"}

package/dist/api/sse-parser.js

@@ -0,0 +1,163 @@
+/**
+ * SSE reader for the chat data plane.
+ *
+ * Every rule here is a fact measured in Phase 0 against real transcripts from
+ * DeepSeek, Kimi, Qwen and Vertex Gemini (tests/fixtures/cli-000*), not an
+ * assumption about how streaming "usually" works:
+ *
+ *   - `id` and `name` arrive exactly once, so tool calls merge by `index`.
+ *   - Qwen sends `"id": ""` on continuation frames; `??` would overwrite the
+ *     real id with an empty string and the tool result would be rejected.
+ *   - Gemini packs a thought signature into the id (700+ chars) and delivers a
+ *     whole call in one frame, where Kimi takes nine — fragment counts mean
+ *     nothing.
+ *   - `finish_reason` arrives in its own frame with an empty delta; `[DONE]`
+ *     ends the stream.
+ *   - With `stream_options.include_usage`, usage arrives AFTER finish_reason
+ *     in a frame whose `choices` is non-empty but whose delta is empty. A
+ *     parser that only reads usage when `choices` is empty reports zero cost.
+ */
+/** Split a byte stream into SSE `data:` payloads across arbitrary chunking. */
+export class SseFramer {
+    buffer = "";
+    decoder = new TextDecoder();
+    push(chunk) {
+        // stream: true keeps a multi-byte character split across chunks intact.
+        this.buffer += this.decoder.decode(chunk, { stream: true });
+        return this.drain();
+    }
+    /** Flush whatever a closed stream left behind. */
+    end() {
+        this.buffer += this.decoder.decode();
+        const rest = this.drain();
+        const tail = this.buffer.trim();
+        this.buffer = "";
+        if (tail.startsWith("data:"))
+            rest.push(tail.slice("data:".length).trim());
+        return rest;
+    }
+    drain() {
+        const payloads = [];
+        let newline = this.buffer.indexOf("\n");
+        while (newline !== -1) {
+            const line = this.buffer.slice(0, newline).trim();
+            this.buffer = this.buffer.slice(newline + 1);
+            if (line.startsWith("data:"))
+                payloads.push(line.slice("data:".length).trim());
+            newline = this.buffer.indexOf("\n");
+        }
+        return payloads;
+    }
+}
+/** Accumulates frames into a final answer plus tool calls. */
+export class ChatStreamAssembler {
+    events;
+    calls = new Map();
+    text = "";
+    finishReason;
+    usage;
+    done = false;
+    constructor(events = {}) {
+        this.events = events;
+    }
+    /** @returns true when the stream is complete (`[DONE]`). */
+    push(payload) {
+        if (payload === "[DONE]") {
+            this.done = true;
+            return true;
+        }
+        if (payload.length === 0)
+            return false;
+        let chunk;
+        try {
+            chunk = JSON.parse(payload);
+        }
+        catch {
+            // A malformed frame must not kill a stream that is otherwise fine.
+            return false;
+        }
+        // Read usage wherever it appears — it rides a frame that still has a
+        // (empty-delta) choice on this gateway.
+        if (chunk.usage)
+            this.usage = chunk.usage;
+        const choice = chunk.choices?.[0];
+        if (!choice)
+            return false;
+        if (choice.finish_reason)
+            this.finishReason = choice.finish_reason;
+        const delta = choice.delta;
+        if (!delta)
+            return false;
+        if (typeof delta.content === "string" && delta.content.length > 0) {
+            this.text += delta.content;
+            this.events.onText?.(delta.content);
+        }
+        for (const part of delta.tool_calls ?? []) {
+            const index = part.index ?? 0;
+            const call = this.calls.get(index) ?? { index, arguments: "" };
+            // Non-empty only: Qwen's "" on continuation frames must not win.
+            if (part.id)
+                call.id = part.id;
+            if (part.function?.name)
+                call.name = part.function.name;
+            if (typeof part.function?.arguments === "string") {
+                call.arguments += part.function.arguments;
+            }
+            this.calls.set(index, call);
+        }
+        return false;
+    }
+    result() {
+        return {
+            text: this.text,
+            toolCalls: [...this.calls.values()].sort((a, b) => a.index - b.index),
+            finishReason: this.finishReason,
+            usage: this.usage,
+            done: this.done,
+        };
+    }
+}
+/**
+ * Read a streaming response to completion.
+ *
+ * `signal` is the user's Ctrl+C: aborting stops reading AND closes the
+ * connection, which is what actually tells the gateway to stop generating.
+ */
+export async function readChatStream(response, events = {}, signal) {
+    const framer = new SseFramer();
+    const assembler = new ChatStreamAssembler(events);
+    const body = response.body;
+    if (!body)
+        return assembler.result();
+    const reader = body.getReader();
+    const onAbort = () => void reader.cancel();
+    // Attaching a listener is not enough: a signal that aborted between the
+    // request and here would never fire one, and the read below would hang
+    // forever on a stream nobody is going to close.
+    if (signal?.aborted) {
+        await reader.cancel();
+        reader.releaseLock();
+        return assembler.result();
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+        for (;;) {
+            if (signal?.aborted)
+                break;
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            for (const payload of framer.push(value)) {
+                if (assembler.push(payload))
+                    return assembler.result();
+            }
+        }
+        for (const payload of framer.end())
+            assembler.push(payload);
+    }
+    finally {
+        signal?.removeEventListener("abort", onAbort);
+        reader.releaseLock();
+    }
+    return assembler.result();
+}

package/dist/commands/account.d.ts

@@ -0,0 +1,4 @@
+import { ExitCode } from "../output/exit-codes.js";
+import { type CommandIo } from "./runtime.js";
+export declare function accountCommand(argv: readonly string[], io: CommandIo): Promise<ExitCode>;
+//# sourceMappingURL=account.d.ts.map

package/dist/commands/account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../src/commands/account.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAOnD,OAAO,EAIL,KAAK,SAAS,EACf,MAAM,cAAc,CAAC;AAUtB,wBAAsB,cAAc,CAClC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,EAAE,EAAE,SAAS,GACZ,OAAO,CAAC,QAAQ,CAAC,CAmGnB"}