@womp/spark-agent 6.3.0 → 6.5.0

package/CHANGELOG.md

@@ -4,6 +4,87 @@ Notable changes to `@womp/spark-agent`, newest first. Versions follow
 [Semantic Versioning](https://semver.org/). Add an entry with each version bump; describe what
 changed for hosts and users, and how to migrate across breaking changes.
 
+## 6.5.0 — 2026-10-12
+
+The agent proposes a goal during its turn, instead of the host asking a separate model call to
+read every message before it is sent. Ordinary messages start at once, the proposal shares the
+run's prompt cache, and when to propose is decided in one place: the tool's description.
+
+### Added
+
+- The `propose_goal({ title, conditions })` tool, declared only when the host can ask the user.
+  The run waits in `requires_action` for the answer, so nothing is built before it. The tool
+  result tells the agent to build toward the goal, to carry on as a single try, or to stop and
+  wait.
+- The `data-goal-proposal` part (`sparkGoalProposalPartSchema`) stores the proposal on the
+  assistant message that made it: `title`, `conditions`, the `toolCallId`, and the `outcome` once
+  there is one. Hosts render it as the confirmation while its run waits and as the goal once it
+  started; the model does not read it.
+- `SparkAgentServiceOptions.confirmGoal` shows a proposal and resolves a `SparkGoalDecision`
+  (`sparkGoalDecisionSchema`): a goal with its caps, a single try, or unanswered. A confirmed goal
+  starts with the run that proposed it as its first try, with the run's request as its objective.
+- `SparkAgentServiceOptions.onGoalStart`, called when a confirmed goal is stored and before the
+  agent continues. A goal it rejects does not start.
+- `SparkRunExecutionContext.proposeGoal` and `SparkAgentOptions.proposeGoal` (`SparkGoalOffer`)
+  carry the offer to the agent. A custom `executeRun` that drops it leaves the tool undeclared.
+
+### Removed
+
+- `createSparkGoalProposer`, `SparkGoalProposer`, `SparkAgentService.proposeGoal`,
+  `SparkAgentServiceOptions.proposeGoal`, `POST /conversations/:id/goal/proposal` and
+  `SparkChatTransport.proposeGoal`.
+- `title` and `conditions` on the goal `set` command, and the `data-goal` part with its
+  `sparkDataPartSchemas.goal` schema: conditions now come only from a proposal the user confirmed.
+  A conversation that holds a `data-goal` part, written by 6.3.0 or 6.4.0, no longer validates.
+- `SparkChatTransport.sendMessages` no longer forwards `body.goal`.
+- `MAX_GOAL_LENGTH` from `@womp/spark-agent/ui`.
+
+### Migration
+
+- Replace the pre-send proposal call and the `set` command that followed it with `confirmGoal`:
+  show the proposal when asked, resolve the user's answer, and send every message as an ordinary
+  one. Render the `data-goal-proposal` part as the confirmation while its run waits.
+- A host that billed a goal from the `set` command starts counting in `onGoalStart`; the first
+  try's run began before the goal existed.
+- A host that stores tool calls by name must accept `propose_goal`, and must offer the tool again
+  when it replays that history, so the earlier call reads as it did live.
+- A host that validates stored messages against `sparkDataPartSchemas` must be on this version
+  before it reads a conversation that holds a `data-goal-proposal` part.
+
+## 6.4.0 — 2026-10-12
+
+### Added
+
+- Conversation compaction. Once a conversation reaches 256k tokens (by the provider's count for its
+  last step, or an estimate), the run's own model summarizes everything before the most recent
+  16k tokens of whole turns, before the turn's first step. Later requests send the summary, the
+  current text of the skills read in the summarized messages, and the newest four images the user
+  attached to them (`COMPACTION_USER_IMAGES`), in their place. The summary is
+  recorded as a `data-compaction` part (`SparkCompaction`) on the turn's assistant message, so
+  hosts store it with the message; the chat still has every message. A summary that fails leaves
+  the turn uncompacted, and context trimming still applies.
+- `SparkAgentOptions.history`: the stored conversation, converted and compacted by the run. Pass it
+  instead of `messages` to get compaction; `createSparkRunExecutor` now does.
+- `convertSparkMessages` takes `{ compaction, skills }` and applies the latest compaction in the
+  messages it is given.
+- `SparkAgentOptions.compaction` and `SparkRunExecutorOptions.compaction` (`SparkCompactionLimits`)
+  lower the threshold and the recent tail kept, for a host that exercises compaction without a
+  production-sized conversation, such as local development. Absent, the defaults apply.
+
+### Changed
+
+- Goal evaluation attaches the newest `GOAL_REFERENCE_IMAGES` images the user attached to the
+  conversation, however far back, as the reference, ahead of the inspection screenshots. It reads
+  them only from `data:` URLs, so a host that stores them elsewhere passes `messages` with those
+  images inline; others are listed as unavailable.
+- When a conversation is over its context window, trimming omits the agent's older screenshots
+  before the older images the user attached.
+
+### Migration
+
+- Hosts that validate stored messages with `sparkDataPartSchemas` must take this version before any
+  host writing compactions reads the same conversations, or the new part fails validation.
+
 ## 6.3.0 — 2026-10-09
 
 ### Added

package/README.md

@@ -35,8 +35,8 @@ Kakapo, Express, or React at runtime.
 
 ## Running in a host application
 
-`runSparkAgent` accepts a configured model, model messages, an executor, a capability composition,
-and an artifact resolver. It exposes exactly `read_skill` and `execute_javascript` to the model.
+`runSparkAgent` accepts a configured model, the stored conversation (`history`, compacted once it
+is long) or model messages, an executor, a capability composition, and an artifact resolver. It exposes exactly `read_skill` and `execute_javascript` to the model.
 Skills carry instructions, declarations, and JavaScript examples. Kakapo skill declarations are
 generated from its typed API at build time and packaged as JavaScript strings.
 
@@ -138,7 +138,6 @@ Closing or reloading the page only detaches the SSE subscriber. It does not canc
 POST  /agent/conversations/:conversationId/messages
 PATCH /agent/conversations/:conversationId/settings
 POST  /agent/conversations/:conversationId/goal
-POST  /agent/conversations/:conversationId/goal/proposal
 GET   /agent/runs/:runId/stream?after=0
 POST  /agent/runs/:runId/cancel
 ```
@@ -147,14 +146,17 @@ Conversation settings contain `modelId` and `reasoningEffort`; save them with
 `transport.saveConversationSettings(id, settings)`. The goal endpoint accepts `set`, `pause`,
 `resume`, `clear`, and `update_budget` commands.
 
-A goal starts from an ordinary message. `transport.proposeGoal(id, message, settings)` returns a
-title and the success conditions read from the message, each marked `measurable` or left to the
-user's review; it stores and starts nothing. After the user confirms them with a tries cap
-(`maxTurns`) and a credit cap, send the message with `body.goal` set to a `set` command carrying
-`title`, `conditions`, `maxTurns` and `creditBudget`. The service attaches the confirmed conditions
-to that message as a `data-goal` part, evaluates each measurable condition after every try, and
-records the result on `goal.conditions`. Send the message without `body.goal` to try once. Hosts
-enable proposals with `SparkAgentServiceOptions.proposeGoal`, such as `createSparkGoalProposer`.
+A goal starts from an ordinary message, when the agent proposes one. A host that sets
+`SparkAgentServiceOptions.confirmGoal` (with `evaluateGoal`) gives the agent the `propose_goal`
+tool: it calls it before building when the request sets constraints a result can be measured
+against, with a title and the conditions, each marked `measurable` or left to the user's review.
+The run then waits in `requires_action` while `confirmGoal` shows the proposal, which the
+assistant message stores as a `data-goal-proposal` part, and resolves the user's answer: `{ kind: "goal", maxTurns,
+creditBudget }`, `{ kind: "once" }`, or `{ kind: "unanswered" }` when the host stops waiting. A
+confirmed goal starts with that run as its first try; the service evaluates each measurable
+condition after every try and records the result on `goal.conditions`. Any other answer leaves an
+ordinary turn. The part then carries the `outcome`: `started`, `declined`, `unanswered`, or `active`
+when a goal was already running. `onGoalStart` tells a host that counts a goal's spending when one starts.
 
 The SSE response contains ordered persistence envelopes around standard AI SDK chunks:
 

package/dist/agent-tools.d.ts

@@ -1,12 +1,21 @@
 import { type Tool } from "ai";
 import type { ExecutionReceipt, SparkArtifactResolver, SparkCapabilities } from "./capabilities.js";
 import type { JavaScriptExecutor } from "./executor.js";
+import { type SparkGoalOutcome, type SparkGoalProposal } from "./goals.js";
 import type { SparkUIMessage, SparkUIMessageChunk, SparkUITools } from "./ui.js";
 export type SparkToolCall = {
     id: string;
-    name: "read_skill" | "execute_javascript";
+    name: "read_skill" | "execute_javascript" | "propose_goal";
     input: unknown;
 };
+/**
+ * Shows the user a goal the model proposed and waits for their answer, starting
+ * the goal for this run when they confirm it.
+ */
+export type SparkGoalOffer = (proposal: SparkGoalProposal, call: {
+    toolCallId: string;
+    signal: AbortSignal;
+}) => Promise<SparkGoalOutcome>;
 export interface SparkPersistence {
     beforeToolCall(call: SparkToolCall): Promise<void>;
     recordReceipt(callId: string, receipt: ExecutionReceipt): Promise<void>;
@@ -22,9 +31,16 @@ export type SparkToolOptions = {
     controller: AbortController;
     persistence?: SparkPersistence;
     executionTimeoutMs?: number;
+    /** Present when the host can ask the user: the model then has `propose_goal`. */
+    proposeGoal?: SparkGoalOffer;
     write(chunk: SparkUIMessageChunk): void;
 };
-export type SparkTools = {
-    [Name in keyof SparkUITools]: Tool<SparkUITools[Name]["input"], SparkUITools[Name]["output"]>;
+type SparkTool<Name extends keyof SparkUITools> = Tool<SparkUITools[Name]["input"], SparkUITools[Name]["output"]>;
+type SparkCoreTools = {
+    [Name in "read_skill" | "execute_javascript"]: SparkTool<Name>;
 };
+export type SparkTools = SparkCoreTools | (SparkCoreTools & {
+    propose_goal: SparkTool<"propose_goal">;
+});
 export declare function createSparkTools(options: SparkToolOptions): SparkTools;
+export {};

package/dist/agent-tools.js

@@ -3,6 +3,7 @@ import { z } from "zod";
 import { boundedResultText, canonicalJsonValue } from "./bounded-output.js";
 import { completedInputString } from "./tool-input-label.js";
 import { UserWait } from "./execution-lifetime.js";
+import { sparkGoalProposalSchema } from "./goals.js";
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -21,6 +22,13 @@ const artifactRefSchema = z.object({
     mediaType: z.string().min(1),
     name: z.string().optional(),
 });
+/** What the model is told a proposal came to, and so what to do next. */
+const GOAL_OUTCOMES = {
+    started: "The user confirmed the goal. Build it now, and verify every measurable condition with tool results before you finish. An independent check follows each try and sends back what is still unmet.",
+    declined: "The user chose a single try. Carry out the request as usual and do not propose a goal for it again.",
+    unanswered: "The user has not answered. Build nothing: say that you are waiting for their answer, and stop.",
+    active: "A goal is already running in this conversation. Keep working toward it.",
+};
 export function createSparkTools(options) {
     const { controller, persistence } = options;
     const executionTimeoutMs = options.executionTimeoutMs ?? 60_000;
@@ -76,7 +84,37 @@ export function createSparkTools(options) {
             onInputAvailable: ({ toolCallId }) => { inputs.delete(toolCallId); },
         };
     };
+    const { proposeGoal } = options;
     return {
+        ...(proposeGoal === undefined ? {} : {
+            propose_goal: tool({
+                description: "Offer to run the user's request as a goal: work that repeats until an independent check verifies its conditions. Call it once, before building or generating anything, when the request sets a constraint the finished result passes or fails by measurement: a size, a count, a limit, a fit to something real, a clearance, an angle, a weight, a price, or a physical requirement such as being one piece, resting on the ground or parts not intersecting. Do not call it for a question, a small direct edit, a request that only describes what to make, or while a goal is running. It shows the user the conditions and waits for their answer.",
+                inputSchema: sparkGoalProposalSchema.extend({
+                    title: sparkGoalProposalSchema.shape.title.describe("Two to four words in sentence case naming what is being made."),
+                    conditions: sparkGoalProposalSchema.shape.conditions.describe("Only constraints the user stated or directly implied, never your own, each marked measurable. The description of what to make is not a list of constraints: leave out its parts and features, and any instruction about how to work, what to check or what to render. State each as a fact about the finished result in a few words of the user's language, with its number and unit: \"Height is 120 mm\", not \"Make it 120 mm tall\". Split compound constraints. If the user asked for a look, style, feel or quality that takes judgement, add it as one condition that is not measurable, left to their review."),
+                }),
+                execute: (input, { toolCallId }) => execute({ id: toolCallId, name: "propose_goal", input }, async () => {
+                    const status = (status, label) => options.write({ type: "data-run-status", data: { runId: options.runId, status, label } });
+                    // The message keeps the proposal, and then what became of it, under one id.
+                    const store = (outcome) => options.write({
+                        type: "data-goal-proposal", id: `goal-proposal-${toolCallId}`,
+                        data: { ...input, toolCallId, ...(outcome ? { outcome } : {}) },
+                    });
+                    store();
+                    status("requires_action", "Waiting for your answer");
+                    try {
+                        const goal = await proposeGoal(input, { toolCallId, signal: controller.signal });
+                        store(goal);
+                        return { goal };
+                    }
+                    finally {
+                        if (!controller.signal.aborted)
+                            status("running", "Continuing after user input");
+                    }
+                }),
+                toModelOutput: ({ output }) => ({ type: "text", value: GOAL_OUTCOMES[output.goal] }),
+            }),
+        }),
         read_skill: tool({
             ...inputLabels("name"),
             description: "Read the skills listed in names. Returns instructions, TypeScript API declarations, and JavaScript examples from the available directory.",

package/dist/agent.d.ts

@@ -1,9 +1,10 @@
 import { streamText, type LanguageModel, type ModelMessage } from "ai";
-import { type SparkPersistence } from "./agent-tools.js";
+import { type SparkGoalOffer, type SparkPersistence } from "./agent-tools.js";
 import type { SparkArtifactResolver, SparkCapabilities } from "./capabilities.js";
 import type { JavaScriptExecutor } from "./executor.js";
 import { type ContextBudgetReport } from "./context-budget.js";
-import type { SparkUIMessageChunk } from "./ui.js";
+import { type SparkCompactionLimits } from "./compaction.js";
+import type { SparkUIMessage, SparkUIMessageChunk } from "./ui.js";
 export type SparkAgentResult = {
     text: string;
     steps: number;
@@ -12,7 +13,14 @@ export type SparkAgentResult = {
     finishReason: string;
 };
 export type SparkAgentOptions = {
-    messages: ModelMessage[];
+    /** The conversation as model messages, sent as given. Pass `history` instead to have long conversations compacted. */
+    messages?: ModelMessage[];
+    /**
+     * The stored conversation. It is converted with `convertSparkMessages`, and
+     * compacted first once it is long enough (./compaction.ts); the new
+     * compaction is written to this run's message as a `data-compaction` part.
+     */
+    history?: SparkUIMessage[];
     model: LanguageModel;
     modelId: string;
     providerOptions?: Parameters<typeof streamText>[0]["providerOptions"];
@@ -27,9 +35,13 @@ export type SparkAgentOptions = {
     maxOutputTokens?: number;
     executionTimeoutMs?: number;
     persistence?: SparkPersistence;
+    /** Gives the model `propose_goal`; absent, it has no way to offer a goal. */
+    proposeGoal?: SparkGoalOffer;
     prepareMessages?(messages: ModelMessage[]): Promise<ModelMessage[]>;
     /** The model's context window. Absent: `contextWindowFor(modelId)`. */
     contextWindow?: number;
+    /** When `history` is compacted. Absent: the defaults in ./compaction.ts. */
+    compaction?: SparkCompactionLimits;
     /** Called when a step's messages had to be trimmed to fit, or still do not fit. */
     onContextBudget?(report: ContextBudgetReport): void;
 };

package/dist/agent.js

@@ -5,6 +5,8 @@ import { createSparkTools } from "./agent-tools.js";
 import { sparkSystemPrompt } from "./prompt.js";
 import { calculateStepCost } from "./pricing.js";
 import { contextWindowFor, fitMessagesToContext } from "./context-budget.js";
+import { compactSparkHistory } from "./compaction.js";
+import { convertSparkMessages } from "./model-history.js";
 function errorMessage(error) {
     return sparkErrorDiagnostics(error).message;
 }
@@ -37,6 +39,9 @@ export function runSparkAgent(options) {
     if (Number.isInteger(maxSteps) === false || maxSteps < 1) {
         throw new Error("maxSteps must be a positive integer.");
     }
+    if ((options.messages === undefined) === (options.history === undefined)) {
+        throw new Error("Pass either messages or history.");
+    }
     const startedAt = Date.now();
     const controller = new AbortController();
     const onAbort = () => controller.abort(options.signal?.reason);
@@ -125,10 +130,36 @@ export function runSparkAgent(options) {
                     write: (chunk) => writer.write(chunk),
                 });
                 const readSystem = () => sparkSystemPrompt(options.capabilities.skills, options.instructions);
+                let messages = options.messages ?? [];
+                if (options.history !== undefined) {
+                    const history = options.history;
+                    const compacted = await compactSparkHistory({
+                        history,
+                        convert: (compaction) => convertSparkMessages(history, tools, { compaction, skills: options.capabilities.skills }),
+                        model: options.model,
+                        modelId: options.modelId,
+                        system: readSystem(),
+                        tools,
+                        providerOptions: options.providerOptions,
+                        maxOutputTokens: options.maxOutputTokens,
+                        contextWindow,
+                        signal: controller.signal,
+                        limits: options.compaction,
+                        onCompacting: () => writer.write({
+                            type: "data-run-status",
+                            data: { runId: options.runId, status: "running", label: "Making room so we can keep talking" },
+                        }),
+                    });
+                    messages = compacted.messages;
+                    if (compacted.compaction !== undefined) {
+                        writer.write({ type: "data-compaction", id: `compaction-${options.messageId}`, data: compacted.compaction });
+                    }
+                    controller.signal.throwIfAborted();
+                }
                 const generation = streamText({
                     model: options.model,
                     system: readSystem(),
-                    messages: options.messages,
+                    messages,
                     tools,
                     toolChoice: "auto",
                     abortSignal: controller.signal,

package/dist/client.d.ts

@@ -1,7 +1,7 @@
 import type { ChatRequestOptions, ChatTransport, UIMessageChunk } from "ai";
 import type { SparkRunSettings } from "./server/types.js";
-import type { SparkGoal, SparkGoalCommand, SparkGoalProposal } from "./goals.js";
-export type { SparkGoal, SparkGoalCommand, SparkGoalCondition, SparkGoalProposal, SparkGoalTry } from "./goals.js";
+import type { SparkGoal, SparkGoalCommand } from "./goals.js";
+export type { SparkGoal, SparkGoalCommand, SparkGoalCondition, SparkGoalDecision, SparkGoalProposal, SparkGoalTry } from "./goals.js";
 import type { SparkConversation, SparkConversationSummary, SparkRun } from "./server/types.js";
 import type { SparkUIMessage } from "./ui.js";
 export type { SparkConversation, SparkConversationSummary, SparkRun, SparkRunSettings, } from "./server/types.js";
@@ -44,8 +44,6 @@ export declare class SparkChatTransport implements ChatTransport<SparkUIMessage>
         goal?: SparkGoal;
         run?: SparkRun;
     }>;
-    /** The success conditions read from a message, to confirm before sending it as a goal. */
-    proposeGoal(id: string, message: SparkUIMessage, settings: SparkRunSettings, signal?: AbortSignal): Promise<SparkGoalProposal>;
     getGoal(id: string): Promise<SparkGoal | undefined>;
     getRun(id: string): Promise<SparkRun>;
     saveConversationSettings(id: string, settings: SparkRunSettings): Promise<void>;

package/dist/client.js

@@ -60,8 +60,6 @@ export class SparkChatTransport {
                 message,
                 messageId: options.messageId,
                 settings,
-                // A confirmed goal: the message starts it, and the run is its first try.
-                ...(requestBody?.goal === undefined ? {} : { goal: requestBody.goal }),
             }),
             signal: options.abortSignal,
         }, options.headers);
@@ -129,15 +127,6 @@ export class SparkChatTransport {
             throw await responseError(response);
         return response.json();
     }
-    /** The success conditions read from a message, to confirm before sending it as a goal. */
-    async proposeGoal(id, message, settings, signal) {
-        const response = await this.request(`/conversations/${encodeURIComponent(id)}/goal/proposal`, {
-            method: "POST", body: JSON.stringify({ message, settings }), signal,
-        });
-        if (!response.ok)
-            throw await responseError(response);
-        return (await response.json()).proposal;
-    }
     async getGoal(id) {
         const response = await this.request(`/conversations/${encodeURIComponent(id)}/goal`, { method: "GET" });
         if (!response.ok)

package/dist/compaction.d.ts

@@ -0,0 +1,64 @@
+import { generateText, type LanguageModel, type ModelMessage, type ToolSet } from "ai";
+import type { SparkSkill } from "./capabilities.js";
+import { type SparkCompaction, type SparkUIMessage } from "./ui.js";
+/** Compact once the conversation reaches this many tokens. */
+export declare const COMPACTION_THRESHOLD_TOKENS = 256000;
+/** Recent whole turns kept verbatim, up to this many tokens, besides the current turn. */
+export declare const COMPACTION_KEEP_RECENT_TOKENS = 16000;
+/** The user's newest images from the summarized messages that the summary message carries. */
+export declare const COMPACTION_USER_IMAGES = 4;
+/**
+ * When a conversation is compacted, for a host that exercises compaction
+ * without filling a production-sized conversation, such as local development.
+ */
+export type SparkCompactionLimits = {
+    /** Default COMPACTION_THRESHOLD_TOKENS. */
+    thresholdTokens?: number;
+    /** Default COMPACTION_KEEP_RECENT_TOKENS. */
+    keepRecentTokens?: number;
+};
+export declare const COMPACTION_PROMPT = "Write a checkpoint summary of this conversation so far. It replaces the earlier messages in your context, so the work must be able to continue from it alone. Reply with the summary only, without calling tools. This request is not part of the conversation: leave it out of the summary.\nIf the conversation begins with an earlier summary, carry its content forward and update it.\nUse these sections:\n## Goal\n## User preferences and constraints\n## Decisions and current scene state (objects with their names and IDs)\n## Done\n## Open and next steps\n## Artifacts and images (each artifact ID, and what each image the user attached shows)\n## Errors and approaches to avoid\nKeep exact names, IDs, numbers and the user's own wording for requirements. Stay under 1,500 words.";
+export declare const COMPACTION_NOTE = "[Earlier messages in this conversation were replaced by the summary below. The scene itself is unchanged; inspect it for its exact state.]";
+/** The latest compaction in the conversation whose kept message is still in it. */
+export declare function latestCompaction(history: SparkUIMessage[]): {
+    compaction: SparkCompaction;
+    carrier: number;
+    firstKept: number;
+} | undefined;
+/**
+ * The conversation as the model reads it: the messages before the compaction's
+ * kept message replaced by its summary, with the newest COMPACTION_USER_IMAGES
+ * images the user attached to them. `compaction` defaults to the latest one in `history`; `skills` are the
+ * host's, to send the current text of the skills it names. Without a
+ * compaction, `history` is returned as it is.
+ */
+export declare function applyCompaction(history: SparkUIMessage[], options?: {
+    compaction?: SparkCompaction;
+    skills?: readonly SparkSkill[];
+}): SparkUIMessage[];
+export type CompactSparkHistoryOptions = {
+    history: SparkUIMessage[];
+    /** `history` as model messages, with `compaction` applied when given. */
+    convert(compaction?: SparkCompaction): Promise<ModelMessage[]>;
+    model: LanguageModel;
+    modelId: string;
+    system: string;
+    /** The run's tools; the summary request sends their definitions without `execute`. */
+    tools: ToolSet;
+    providerOptions?: Parameters<typeof generateText>[0]["providerOptions"];
+    maxOutputTokens?: number;
+    contextWindow?: number;
+    signal?: AbortSignal;
+    /** Called just before the summary request, which can take a while. */
+    onCompacting?(): void;
+    limits?: SparkCompactionLimits;
+};
+/**
+ * The turn's model messages, compacted first when the conversation has reached
+ * the threshold. `compaction` is the new one, for the host to record; it is
+ * absent when nothing was compacted, including when the summary failed.
+ */
+export declare function compactSparkHistory(options: CompactSparkHistoryOptions): Promise<{
+    messages: ModelMessage[];
+    compaction?: SparkCompaction;
+}>;