@aexol/spectral 0.9.230 → 0.9.231

package/dist/sdk/coding-agent/core/compaction/tokens.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Token estimation utilities for compaction.
+ *
+ * Pure functions for estimating context tokens, message sizes, and compaction
+ * token metrics.
+ */
+import type { AgentMessage } from "../../../agent-core/index.js";
+import type { Usage } from "../../../ai/index.js";
+import type { SessionEntry } from "../session-manager.js";
+import type { CompactionPreparation, CompactionResult, CompactionSettings } from "./compaction.js";
+export interface CompactionTokenSourceBucket {
+    type: "role" | "tool" | "source";
+    name: string;
+    tokens: number;
+}
+/**
+ * Calculate total context tokens from usage.
+ * Uses the native totalTokens field when available, falls back to computing from components.
+ */
+export declare function calculateContextTokens(usage: Usage): number;
+/**
+ * Find the last non-aborted assistant message usage from session entries.
+ */
+export declare function getLastAssistantUsage(entries: SessionEntry[]): Usage | undefined;
+export interface ContextUsageEstimate {
+    tokens: number;
+    usageTokens: number;
+    trailingTokens: number;
+    lastUsageIndex: number | null;
+}
+/**
+ * Estimate context tokens from messages, using the last assistant usage when available.
+ * If there are messages after the last usage, estimate their tokens with estimateTokens.
+ */
+export declare function estimateContextTokens(messages: AgentMessage[]): ContextUsageEstimate;
+/**
+ * Check if compaction should trigger based on context usage.
+ */
+export declare function shouldCompact(contextTokens: number, contextWindow: number, settings: CompactionSettings): boolean;
+/**
+ * Estimate token count for a message using chars/4 heuristic.
+ * This is conservative (overestimates tokens).
+ */
+export declare function estimateTokens(message: AgentMessage): number;
+export declare function estimateTextTokens(text: string): number;
+export declare function estimateCompactionTokenMetrics(preparation: Pick<CompactionPreparation, "messagesToSummarize" | "turnPrefixMessages"> & Partial<Pick<CompactionPreparation, "compactionNumber">>, summary: string): Pick<CompactionResult, "tokensCompacted" | "tokensRemoved" | "summaryTokens" | "reductionPercent" | "compactionNumber" | "largestTokenSources">;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/sdk/coding-agent/core/compaction/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/coding-agent/core/compaction/tokens.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EAAoB,KAAK,EAAE,MAAM,sBAAsB,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAGnG,MAAM,WAAW,2BAA2B;IAC3C,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CACf;AAMD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAE3D;AAgBD;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,KAAK,GAAG,SAAS,CAShF;AAED,MAAM,WAAW,oBAAoB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAUD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,oBAAoB,CA4BpF;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAKjH;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CA0D5D;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGvD;AAUD,wBAAgB,8BAA8B,CAC7C,WAAW,EAAE,IAAI,CAAC,qBAAqB,EAAE,qBAAqB,GAAG,oBAAoB,CAAC,GACrF,OAAO,CAAC,IAAI,CAAC,qBAAqB,EAAE,kBAAkB,CAAC,CAAC,EACzD,OAAO,EAAE,MAAM,GACb,IAAI,CACN,gBAAgB,EAChB,iBAAiB,GAAG,eAAe,GAAG,eAAe,GAAG,kBAAkB,GAAG,kBAAkB,GAAG,qBAAqB,CACvH,CAgBA"}

package/dist/sdk/coding-agent/core/compaction/tokens.js

@@ -0,0 +1,224 @@
+/**
+ * Token estimation utilities for compaction.
+ *
+ * Pure functions for estimating context tokens, message sizes, and compaction
+ * token metrics.
+ */
+import { CONTEXT_LIMIT_RATIO } from "./policy.js";
+// ============================================================================
+// Token calculation
+// ============================================================================
+/**
+ * Calculate total context tokens from usage.
+ * Uses the native totalTokens field when available, falls back to computing from components.
+ */
+export function calculateContextTokens(usage) {
+    return usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}
+/**
+ * Get usage from an assistant message if available.
+ * Skips aborted and error messages as they don't have valid usage data.
+ */
+function getAssistantUsage(msg) {
+    if (msg.role === "assistant" && "usage" in msg) {
+        const assistantMsg = msg;
+        if (assistantMsg.stopReason !== "aborted" && assistantMsg.stopReason !== "error" && assistantMsg.usage) {
+            return assistantMsg.usage;
+        }
+    }
+    return undefined;
+}
+/**
+ * Find the last non-aborted assistant message usage from session entries.
+ */
+export function getLastAssistantUsage(entries) {
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        if (entry.type === "message") {
+            const usage = getAssistantUsage(entry.message);
+            if (usage)
+                return usage;
+        }
+    }
+    return undefined;
+}
+function getLastAssistantUsageInfo(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const usage = getAssistantUsage(messages[i]);
+        if (usage)
+            return { usage, index: i };
+    }
+    return undefined;
+}
+/**
+ * Estimate context tokens from messages, using the last assistant usage when available.
+ * If there are messages after the last usage, estimate their tokens with estimateTokens.
+ */
+export function estimateContextTokens(messages) {
+    const usageInfo = getLastAssistantUsageInfo(messages);
+    if (!usageInfo) {
+        let estimated = 0;
+        for (const message of messages) {
+            estimated += estimateTokens(message);
+        }
+        return {
+            tokens: estimated,
+            usageTokens: 0,
+            trailingTokens: estimated,
+            lastUsageIndex: null,
+        };
+    }
+    const usageTokens = calculateContextTokens(usageInfo.usage);
+    let trailingTokens = 0;
+    for (let i = usageInfo.index + 1; i < messages.length; i++) {
+        trailingTokens += estimateTokens(messages[i]);
+    }
+    return {
+        tokens: usageTokens + trailingTokens,
+        usageTokens,
+        trailingTokens,
+        lastUsageIndex: usageInfo.index,
+    };
+}
+/**
+ * Check if compaction should trigger based on context usage.
+ */
+export function shouldCompact(contextTokens, contextWindow, settings) {
+    if (!settings.enabled)
+        return false;
+    if (!Number.isFinite(contextWindow) || contextWindow <= 0)
+        return false;
+    if (!Number.isFinite(contextTokens) || contextTokens < 0)
+        return false;
+    return contextTokens >= contextWindow * CONTEXT_LIMIT_RATIO;
+}
+/**
+ * Estimate token count for a message using chars/4 heuristic.
+ * This is conservative (overestimates tokens).
+ */
+export function estimateTokens(message) {
+    let chars = 0;
+    switch (message.role) {
+        case "user": {
+            const content = message.content;
+            if (typeof content === "string") {
+                chars = content.length;
+            }
+            else if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block.type === "text" && block.text) {
+                        chars += block.text.length;
+                    }
+                }
+            }
+            return Math.ceil(chars / 4);
+        }
+        case "assistant": {
+            const assistant = message;
+            for (const block of assistant.content) {
+                if (block.type === "text") {
+                    chars += block.text.length;
+                }
+                else if (block.type === "thinking") {
+                    chars += block.thinking.length;
+                }
+                else if (block.type === "toolCall") {
+                    chars += block.name.length + JSON.stringify(block.arguments).length;
+                }
+            }
+            return Math.ceil(chars / 4);
+        }
+        case "custom":
+        case "toolResult": {
+            if (typeof message.content === "string") {
+                chars = message.content.length;
+            }
+            else {
+                for (const block of message.content) {
+                    if (block.type === "text" && block.text) {
+                        chars += block.text.length;
+                    }
+                    if (block.type === "image") {
+                        chars += 4800; // Estimate images as 4000 chars, or 1200 tokens
+                    }
+                }
+            }
+            return Math.ceil(chars / 4);
+        }
+        case "bashExecution": {
+            chars = message.command.length + message.output.length;
+            return Math.ceil(chars / 4);
+        }
+        case "branchSummary":
+        case "compactionSummary": {
+            chars = message.summary.length;
+            return Math.ceil(chars / 4);
+        }
+    }
+    return 0;
+}
+export function estimateTextTokens(text) {
+    if (!text.trim())
+        return 0;
+    return Math.ceil(text.length / 4);
+}
+function estimateMessagesTokens(messages) {
+    let tokens = 0;
+    for (const message of messages) {
+        tokens += estimateTokens(message);
+    }
+    return tokens;
+}
+export function estimateCompactionTokenMetrics(preparation, summary) {
+    const tokensCompacted = estimateMessagesTokens(preparation.messagesToSummarize) +
+        estimateMessagesTokens(preparation.turnPrefixMessages);
+    const summaryTokens = estimateTextTokens(summary);
+    const tokensRemoved = Math.max(0, tokensCompacted - summaryTokens);
+    const reductionPercent = tokensCompacted > 0
+        ? Math.round((tokensRemoved / tokensCompacted) * 10_000) / 100
+        : 0;
+    return {
+        tokensCompacted,
+        tokensRemoved,
+        summaryTokens,
+        reductionPercent,
+        compactionNumber: preparation.compactionNumber,
+        largestTokenSources: collectLargestTokenSources(preparation.messagesToSummarize, preparation.turnPrefixMessages),
+    };
+}
+function addBucket(buckets, bucket) {
+    const key = `${bucket.type}:${bucket.name}`;
+    const previous = buckets.get(key);
+    buckets.set(key, {
+        ...bucket,
+        tokens: (previous?.tokens ?? 0) + bucket.tokens,
+    });
+}
+function collectLargestTokenSources(messagesToSummarize, turnPrefixMessages) {
+    const buckets = new Map();
+    const collect = (messages, source) => {
+        for (const message of messages) {
+            const messageTokens = estimateTokens(message);
+            addBucket(buckets, { type: "source", name: source, tokens: messageTokens });
+            addBucket(buckets, { type: "role", name: message.role, tokens: messageTokens });
+            if (message.role === "toolResult") {
+                addBucket(buckets, { type: "tool", name: message.toolName, tokens: messageTokens });
+                continue;
+            }
+            if (message.role === "assistant") {
+                for (const block of message.content) {
+                    if (block.type !== "toolCall")
+                        continue;
+                    const toolTokens = estimateTextTokens(`${block.name} ${JSON.stringify(block.arguments)}`);
+                    addBucket(buckets, { type: "tool", name: block.name, tokens: toolTokens });
+                }
+            }
+        }
+    };
+    collect(messagesToSummarize, "history");
+    collect(turnPrefixMessages, "turn_prefix");
+    return [...buckets.values()]
+        .filter((bucket) => bucket.tokens > 0)
+        .sort((a, b) => b.tokens - a.tokens || a.type.localeCompare(b.type) || a.name.localeCompare(b.name))
+        .slice(0, 5);
+}

package/dist/sdk/coding-agent/core/extensions/session-events.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Session and tool call/result event types for the extension system.
+ */
+import type { ImageContent, TextContent } from "../../../ai/index.js";
+import type { CompactionPreparation } from "../compaction/index.js";
+import type { BranchSummaryEntry, CompactionEntry, SessionEntry } from "../session-manager.js";
+import type { BashToolDetails, BashToolInput, ReadToolDetails, ReadToolInput } from "../tools/index.js";
+/** Fired when a session is started, loaded, or reloaded */
+export interface SessionStartEvent {
+    type: "session_start";
+    /** Why this session start happened. */
+    reason: "startup" | "reload" | "new" | "resume" | "fork";
+    /** Previously active session file. Present for "new", "resume", and "fork". */
+    previousSessionFile?: string;
+}
+/** Fired before switching to another session (can be cancelled) */
+export interface SessionBeforeSwitchEvent {
+    type: "session_before_switch";
+    reason: "new" | "resume";
+    targetSessionFile?: string;
+}
+/** Fired before forking a session (can be cancelled) */
+export interface SessionBeforeForkEvent {
+    type: "session_before_fork";
+    entryId: string;
+    position: "before" | "at";
+}
+/** Fired before context compaction (can be cancelled or customized) */
+export interface SessionBeforeCompactEvent {
+    type: "session_before_compact";
+    preparation: CompactionPreparation;
+    branchEntries: SessionEntry[];
+    customInstructions?: string;
+    signal: AbortSignal;
+    /**
+     * Emit live compaction progress to the host UI. Extensions that provide a
+     * custom compaction result should call this while building it so the browser
+     * does not appear idle until the final compaction object is returned.
+     */
+    emitProgress?: (delta: string, content?: string) => void;
+}
+/** Fired after context compaction */
+export interface SessionCompactEvent {
+    type: "session_compact";
+    compactionEntry: CompactionEntry;
+    fromExtension: boolean;
+}
+/** Fired before an extension runtime is torn down due to quit, reload, or session replacement. */
+export interface SessionShutdownEvent {
+    type: "session_shutdown";
+    reason: "quit" | "reload" | "new" | "resume" | "fork";
+    /** Destination session file when shutting down due to session replacement. */
+    targetSessionFile?: string;
+}
+/** Preparation data for tree navigation */
+export interface TreePreparation {
+    targetId: string;
+    oldLeafId: string | null;
+    commonAncestorId: string | null;
+    entriesToSummarize: SessionEntry[];
+    userWantsSummary: boolean;
+    /** Custom instructions for summarization */
+    customInstructions?: string;
+    /** If true, customInstructions replaces the default prompt instead of being appended */
+    replaceInstructions?: boolean;
+    /** Label to attach to the branch summary entry */
+    label?: string;
+}
+/** Fired before navigating in the session tree (can be cancelled) */
+export interface SessionBeforeTreeEvent {
+    type: "session_before_tree";
+    preparation: TreePreparation;
+    signal: AbortSignal;
+}
+/** Fired after navigating in the session tree */
+export interface SessionTreeEvent {
+    type: "session_tree";
+    newLeafId: string | null;
+    oldLeafId: string | null;
+    summaryEntry?: BranchSummaryEntry;
+    fromExtension?: boolean;
+}
+export type SessionEvent = SessionStartEvent | SessionBeforeSwitchEvent | SessionBeforeForkEvent | SessionBeforeCompactEvent | SessionCompactEvent | SessionShutdownEvent | SessionBeforeTreeEvent | SessionTreeEvent;
+interface ToolCallEventBase {
+    type: "tool_call";
+    toolCallId: string;
+}
+export interface BashToolCallEvent extends ToolCallEventBase {
+    toolName: "bash";
+    input: BashToolInput;
+}
+export interface ReadToolCallEvent extends ToolCallEventBase {
+    toolName: "read";
+    input: ReadToolInput;
+}
+export interface CustomToolCallEvent extends ToolCallEventBase {
+    toolName: string;
+    input: Record<string, unknown>;
+}
+/**
+ * Fired before a tool executes. Can block.
+ *
+ * `event.input` is mutable. Mutate it in place to patch tool arguments before execution.
+ * Later `tool_call` handlers see earlier mutations. No re-validation is performed after mutation.
+ */
+export type ToolCallEvent = BashToolCallEvent | ReadToolCallEvent | CustomToolCallEvent;
+interface ToolResultEventBase {
+    type: "tool_result";
+    toolCallId: string;
+    input: Record<string, unknown>;
+    content: (TextContent | ImageContent)[];
+    isError: boolean;
+}
+export interface BashToolResultEvent extends ToolResultEventBase {
+    toolName: "bash";
+    details: BashToolDetails | undefined;
+}
+export interface ReadToolResultEvent extends ToolResultEventBase {
+    toolName: "read";
+    details: ReadToolDetails | undefined;
+}
+export interface CustomToolResultEvent extends ToolResultEventBase {
+    toolName: string;
+    details: unknown;
+}
+/** Fired after a tool executes. Can modify result. */
+export type ToolResultEvent = BashToolResultEvent | ReadToolResultEvent | CustomToolResultEvent;
+export declare function isBashToolResult(e: ToolResultEvent): e is BashToolResultEvent;
+export declare function isReadToolResult(e: ToolResultEvent): e is ReadToolResultEvent;
+/**
+ * Type guard for narrowing ToolCallEvent by tool name.
+ *
+ * Built-in tools narrow automatically (no type params needed):
+ * ```ts
+ * if (isToolCallEventType("bash", event)) {
+ *   event.input.command;  // string
+ * }
+ * ```
+ *
+ * Custom tools require explicit type parameters:
+ * ```ts
+ * if (isToolCallEventType<"my_tool", MyToolInput>("my_tool", event)) {
+ *   event.input.action;  // typed
+ * }
+ * ```
+ *
+ * Note: Direct narrowing via `event.toolName === "bash"` doesn't work because
+ * CustomToolCallEvent.toolName is `string` which overlaps with all literals.
+ */
+export declare function isToolCallEventType(toolName: "bash", event: ToolCallEvent): event is BashToolCallEvent;
+export declare function isToolCallEventType(toolName: "read", event: ToolCallEvent): event is ReadToolCallEvent;
+export declare function isToolCallEventType<TName extends string, TInput extends Record<string, unknown>>(toolName: TName, event: ToolCallEvent): event is ToolCallEvent & {
+    toolName: TName;
+    input: TInput;
+};
+export {};
+//# sourceMappingURL=session-events.d.ts.map

package/dist/sdk/coding-agent/core/extensions/session-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-events.d.ts","sourceRoot":"","sources":["../../../../../src/sdk/coding-agent/core/extensions/session-events.ts"],"names":[],"mappings":"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"}

package/dist/sdk/coding-agent/core/extensions/session-events.js

@@ -0,0 +1,13 @@
+/**
+ * Session and tool call/result event types for the extension system.
+ */
+// Type guards for ToolResultEvent
+export function isBashToolResult(e) {
+    return e.toolName === "bash";
+}
+export function isReadToolResult(e) {
+    return e.toolName === "read";
+}
+export function isToolCallEventType(toolName, event) {
+    return event.toolName === toolName;
+}