@blade-hq/agent-client 1.1.1

package/dist/shared/projection/builder.d.ts

@@ -0,0 +1,59 @@
+import type { TurnProjection } from "../../schemas/projection";
+export interface RawEvent {
+    type: string;
+    payload: Record<string, unknown>;
+}
+export type ProjectionUpdate = {
+    kind: "upsert";
+    turn: TurnProjection;
+} | {
+    kind: "workspace_changed";
+    loopId: string;
+    toolCallId?: string;
+    toolName?: string;
+};
+export declare class ClientProjectionBuilder {
+    private activeTurns;
+    private lastTurnIds;
+    private latestTurns;
+    private loopDescriptions;
+    private pendingChildPauses;
+    private pendingMemoryRefs;
+    private activeCompactions;
+    private seq;
+    private syntheticCounter;
+    private displayNameResolver;
+    constructor(displayNameResolver?: (name: string) => string);
+    processBatch(events: RawEvent[]): ProjectionUpdate[];
+    processEvent(event: RawEvent): ProjectionUpdate[] | null;
+    reset(): void;
+    seedSequence(maxSeq: number): void;
+    private onMemoryInject;
+    private onLoopTurn;
+    private onModeChange;
+    private onPlanStatusUpdate;
+    private onWorkspaceChanged;
+    private onAgentStart;
+    private onBgStarted;
+    private onBgTasksCompleted;
+    private onAskUserAnswer;
+    private onUserMessage;
+    private onDelta;
+    private onToolCallCreated;
+    private onResponseDone;
+    private onToolResultDone;
+    private onToolResultDelta;
+    private onToolUi;
+    private onToolBridge;
+    private onToolApprovalRequired;
+    private onChildPause;
+    private onChatEnd;
+    private onAgentEnd;
+    private onCompaction;
+    private syncPatch;
+    private finalize;
+    private shouldFinalizeAfterToolResults;
+    private collectLoopUpdates;
+    private nextSeq;
+    private nextTurnId;
+}

package/dist/shared/projection/helpers.d.ts

@@ -0,0 +1,34 @@
+import type { ContentBlock, PendingQuestionRef, ToolCallProjection, TurnProjection } from "../../schemas/projection";
+import type { TurnState } from "./state";
+export declare function upsertToolCall(state: TurnState, toolCallId: string, toolName: string, displayName: string, args: string): void;
+export declare function applyToolResult(state: TurnState, toolCallId: string, result: unknown, status: ToolCallProjection["status"], durationMs: number | null, sourceLoop: {
+    loop_name: string;
+    description: string;
+} | null): void;
+export declare function appendToolResultDelta(state: TurnState, toolCallId: string, delta: string): void;
+export declare function appendTextBlock(state: TurnState, blockType: ContentBlock["type"], content: unknown): void;
+export declare function appendToolCallArguments(state: TurnState, toolCallId: string, delta: string): void;
+export declare function buildSystemNotificationTurn(sequence: number, turnId: string, loopId: string, notificationType: string, status: string, title: string, detail: string | null, metadata: Record<string, unknown>): TurnProjection;
+export declare function buildSystemNotificationBlock(notificationType: string, status: string, title: string, detail: string | null, metadata: Record<string, unknown>): ContentBlock;
+export declare function buildMarkerTurn(sequence: number, turnId: string, loopId: string, blockType: ContentBlock["type"], content: unknown): TurnProjection;
+export declare function buildCompactionTurn(sequence: number, compactionId: string, loopId: string, status: TurnProjection["status"], data: Record<string, unknown>): TurnProjection;
+export interface ChildPauseInfo {
+    parentLoopName: string;
+    parentToolCallId: string;
+    childLoopName: string;
+    childToolCallId: string;
+    description: string;
+}
+export declare function setToolCallStatus(turn: TurnState | TurnProjection | null | undefined, toolCallId: string, status: ToolCallProjection["status"], result: unknown, pendingQuestionRef: PendingQuestionRef | null): void;
+export declare function applyAskUserPauseToTurn(turn: TurnState | TurnProjection | null | undefined, pauseToolData: Record<string, unknown>, toolCallId: string, childLoopName: string, description: string, displayNameResolver: (name: string) => string): void;
+export declare function applyChildPauseToParent(parentTurn: TurnState | TurnProjection | null | undefined, parentToolCallId: string, childLoopName: string, childToolCallId: string, description: string, displayNameResolver: (name: string) => string): void;
+export declare function sourceLoopFor(loopId: string, loopDescriptions: Map<string, string>): {
+    loop_name: string;
+    description: string;
+} | null;
+export declare function normalizeChildPause(pausePayload: Record<string, unknown>): {
+    pauseToolData: Record<string, unknown>;
+    childLoopName: string;
+    childToolCallId: string;
+    description: string;
+};

package/dist/shared/projection/history.d.ts

@@ -0,0 +1,12 @@
+import type { TurnProjection } from "../../schemas/projection";
+export interface RawHistoryEntry {
+    id?: string;
+    kind?: string;
+    loop_name?: string;
+    message?: Record<string, unknown>;
+    data?: Record<string, unknown>;
+    timestamp?: string;
+    [key: string]: unknown;
+}
+/** Rebuild completed UI turns from raw persisted history entries. */
+export declare function projectHistory(entries: RawHistoryEntry[]): TurnProjection[];

package/dist/shared/projection/index.d.ts

@@ -0,0 +1,3 @@
+export { ClientProjectionBuilder, type RawEvent, type ProjectionUpdate } from "./builder";
+export { type TurnState, createTurnState, snapshot, PAUSE_TOOL_NAMES } from "./state";
+export { projectHistory, type RawHistoryEntry } from "./history";

package/dist/shared/projection/state.d.ts

@@ -0,0 +1,22 @@
+import type { ContentBlock, MemoryRef, ToolCallProjection, TurnProjection } from "../../schemas/projection";
+export interface TurnState {
+    turnId: string;
+    loopId: string;
+    role: "user" | "assistant" | "system";
+    model: string | null;
+    startedAt: number;
+    contextWindow: number;
+    blocks: ContentBlock[];
+    toolCalls: ToolCallProjection[];
+    usage: Record<string, unknown> | null;
+    memoryRefs: MemoryRef[] | null;
+    parentForkToolCallId: string | null;
+}
+export declare function createTurnState(turnId: string, loopId: string, opts?: {
+    model?: string | null;
+    contextWindow?: number;
+    memoryRefs?: MemoryRef[] | null;
+}): TurnState;
+export declare function snapshot(state: TurnState, sequence: number, status: TurnProjection["status"]): TurnProjection;
+export declare const PAUSE_TOOL_NAMES: Set<string>;
+export declare function toolStatusFromResult(result: unknown): ToolCallProjection["status"];

package/dist/socket.d.ts

@@ -0,0 +1,9 @@
+import { type Socket } from "socket.io-client";
+import { type AuthOptions } from "./auth";
+import type { ClientToServerEvents, ServerToClientEvents } from "./types/socket-events";
+export type TypedSocket = Socket<ServerToClientEvents, ClientToServerEvents>;
+export interface CreateSocketOptions extends AuthOptions {
+    baseUrl: string;
+    path?: string;
+}
+export declare function createSocket(options: CreateSocketOptions): TypedSocket;

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+import type { components, paths } from "./rest";
+import type { ChatEndPayload, ChatSendPayload, ClientToServerEvents, ServerToClientEvents, SessionUpdatedPayload, SystemErrorPayload, SystemNotificationPayload } from "./socket-events";
+export type RestPaths = paths;
+export type RestComponents = components;
+export type Session = paths["/api/sessions/{session_id}"]["get"]["responses"]["200"]["content"]["application/json"];
+export type SessionList = paths["/api/sessions"]["get"]["responses"]["200"]["content"]["application/json"];
+export type SkillList = paths["/api/skills"]["get"]["responses"]["200"]["content"]["application/json"];
+export type { ChatEndPayload, ChatSendPayload, ClientToServerEvents, ServerToClientEvents, SessionUpdatedPayload, SystemErrorPayload, SystemNotificationPayload, };