billion-context-pi 0.1.26 → 0.1.28

package/dist/delegate-events.d.ts

@@ -0,0 +1,69 @@
+export interface ToolStartEvent {
+    kind: "tool-start";
+    toolName: string;
+    argsText: string;
+}
+export interface ToolUpdateEvent {
+    kind: "tool-update";
+    toolCallId: string;
+    text: string;
+}
+export interface ToolEndEvent {
+    kind: "tool-end";
+    toolName: string;
+    isError: boolean;
+}
+export interface ReplyDeltaEvent {
+    kind: "reply-delta";
+    delta: string;
+}
+export interface ReplyCompleteEvent {
+    kind: "reply-complete";
+    content: string;
+}
+export interface ThinkingDeltaEvent {
+    kind: "thinking-delta";
+    delta: string;
+}
+export type ParsedEvent = ToolStartEvent | ToolUpdateEvent | ToolEndEvent | ReplyDeltaEvent | ReplyCompleteEvent | ThinkingDeltaEvent | ThinkingEndEvent | RetryStartEvent | RetryEndEvent;
+export interface ThinkingEndEvent {
+    kind: "thinking-end";
+}
+/**
+ * Accumulates thinking_delta tokens and emits one human-readable line per
+ * thinking segment (a segment ends at thinking_end / text_start). Nothing is
+ * emitted when showThinking is off.
+ */
+export declare class ThinkingCollector {
+    private readonly showThinking;
+    private buf;
+    constructor(showThinking: boolean);
+    push(delta: string): void;
+    /** Return the segment line to write ("" when empty or disabled), resetting. */
+    flush(): string;
+}
+export interface RetryStartEvent {
+    kind: "retry-start";
+    attempt: number;
+    maxAttempts: number;
+    delayMs: number;
+    errorMessage: string;
+}
+export interface RetryEndEvent {
+    kind: "retry-end";
+    success: boolean;
+    attempt: number;
+}
+export declare function parseEventLine(line: string): ParsedEvent | null;
+/** Join `content[].text` blocks from a tool result / partialResult payload. */
+export declare function extractContentText(payload: unknown): string;
+/** Format a parsed event as human-readable activity file lines (each with a
+ *  trailing newline; empty when none). */
+export declare function activityLines(ev: ParsedEvent, opts: {
+    showThinking: boolean;
+}): string[];
+/**
+ * partialResult is an accumulated snapshot (not a delta), so each update
+ * carries everything so far. Return only the newly-appended portion.
+ */
+export declare function newPortion(text: string, prev: string): string;

package/dist/delegate-tool.d.ts

@@ -13,6 +13,7 @@ declare const DelegateParams: Type.TObject<{
     cwd: Type.TOptional<Type.TString>;
     model: Type.TOptional<Type.TString>;
     async: Type.TOptional<Type.TBoolean>;
+    showThinking: Type.TOptional<Type.TBoolean>;
 }>;
 type DelegateArgs = Static<typeof DelegateParams>;
 declare const CancelParams: Type.TObject<{
@@ -40,5 +41,7 @@ export declare function makeDelegateCancelTool(_pi: ExtensionAPI): ToolDefinitio
 export declare function buildChildArgs(args: DelegateArgs, rolePrompt: string, ctx: ExtensionContext): Promise<{
     cliArgs: string[];
     tmpDir: string;
+    isAsync: boolean;
+    useJsonStream: boolean;
 }>;
 export {};

package/dist/delegate-watchdog.d.ts

@@ -0,0 +1,31 @@
+import type { Readable } from "node:stream";
+export interface WatchdogOptions {
+    eofGraceMs: number;
+    idleMs: number;
+    timeoutMs: number;
+    killGraceMs: number;
+}
+export interface WatchdogHooks {
+    /** True once the run is finalized; watchdogs stop firing. */
+    isSettled(): boolean;
+    /** The child is about to be killed (SIGTERM). reason explains why. */
+    onKill(reason: string): void;
+    /** stdout EOF passed without the process exiting; force-finalize now. */
+    onEofGrace(): void;
+}
+export interface WatchdogHandle {
+    /** Re-arm the idle timer (call on every stdout data). */
+    poke(): void;
+    /** Stop all timers (call on finalize). */
+    dispose(): void;
+}
+/**
+ * Guarantees a hung child process gets killed. A stuck child holds its stdout
+ * fd open, so stdout EOF never fires — hence the idle timer (no output for
+ * idleMs) is the main defense; the hard time limit and the EOF grace period
+ * cover the rest. Kill is SIGTERM, escalated to SIGKILL after killGraceMs.
+ */
+export declare function attachWatchdogs(child: {
+    kill(signal: NodeJS.Signals): boolean;
+    stdout: Readable | null;
+}, hooks: WatchdogHooks, opts: WatchdogOptions): WatchdogHandle;