omk-agent-core 0.98.0 → 0.98.1

package/dist/harness/agent-harness.js

@@ -1,111 +1,15 @@
-import { streamSimple } from "omk-ai";
-import { runAgentLoop } from "../agent-loop.js";
+import { isContextOverflow, streamSimple, } from "omk-ai";
+import { runAgentLoop, runAgentLoopContinue } from "../agent-loop.js";
 import { collectEntriesForBranchSummary, generateBranchSummary } from "./compaction/branch-summarization.js";
-import { compact, DEFAULT_COMPACTION_SETTINGS, prepareCompaction } from "./compaction/compaction.js";
-import { convertToLlm } from "./messages.js";
+import { compact, DEFAULT_COMPACTION_SETTINGS, estimateContextTokens, prepareCompaction, shouldCompact, } from "./compaction/compaction.js";
+import { HarnessSessionFacade } from "./harness-session.js";
+import { convertToLlm, createFailureMessage, createUserMessage } from "./messages.js";
+import { findDuplicateNames } from "./name-validation.js";
 import { formatPromptTemplateInvocation } from "./prompt-templates.js";
 import { formatSkillInvocation } from "./skills.js";
+import { applyStreamOptionsPatch, cloneStreamOptions, mergeHeaders } from "./stream-options.js";
+import { createSummarizationRetry } from "./summarization-retry.js";
 import { AgentHarnessError, BranchSummaryError, CompactionError, SessionError, toError } from "./types.js";
-function createUserMessage(text, images) {
-    const content = [{ type: "text", text }];
-    if (images)
-        content.push(...images);
-    return { role: "user", content, timestamp: Date.now() };
-}
-function createFailureMessage(model, error, aborted) {
-    return {
-        role: "assistant",
-        content: [{ type: "text", text: "" }],
-        api: model.api,
-        provider: model.provider,
-        model: model.id,
-        stopReason: aborted ? "aborted" : "error",
-        errorMessage: error instanceof Error ? error.message : String(error),
-        timestamp: Date.now(),
-        usage: {
-            input: 0,
-            output: 0,
-            cacheRead: 0,
-            cacheWrite: 0,
-            totalTokens: 0,
-            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-        },
-    };
-}
-function cloneStreamOptions(streamOptions) {
-    return {
-        ...streamOptions,
-        headers: streamOptions?.headers ? { ...streamOptions.headers } : undefined,
-        metadata: streamOptions?.metadata ? { ...streamOptions.metadata } : undefined,
-    };
-}
-function mergeHeaders(...headers) {
-    const merged = {};
-    let hasHeaders = false;
-    for (const entry of headers) {
-        if (!entry)
-            continue;
-        Object.assign(merged, entry);
-        hasHeaders = true;
-    }
-    return hasHeaders ? merged : undefined;
-}
-function findDuplicateNames(names) {
-    const seen = new Set();
-    const duplicates = new Set();
-    for (const name of names) {
-        if (seen.has(name))
-            duplicates.add(name);
-        seen.add(name);
-    }
-    return [...duplicates];
-}
-function applyStreamOptionsPatch(base, patch) {
-    const result = cloneStreamOptions(base);
-    if (!patch)
-        return result;
-    if (Object.hasOwn(patch, "transport"))
-        result.transport = patch.transport;
-    if (Object.hasOwn(patch, "timeoutMs"))
-        result.timeoutMs = patch.timeoutMs;
-    if (Object.hasOwn(patch, "maxRetries"))
-        result.maxRetries = patch.maxRetries;
-    if (Object.hasOwn(patch, "maxRetryDelayMs"))
-        result.maxRetryDelayMs = patch.maxRetryDelayMs;
-    if (Object.hasOwn(patch, "cacheRetention"))
-        result.cacheRetention = patch.cacheRetention;
-    if (Object.hasOwn(patch, "headers")) {
-        if (patch.headers === undefined) {
-            result.headers = undefined;
-        }
-        else {
-            const headers = { ...(result.headers ?? {}) };
-            for (const [key, value] of Object.entries(patch.headers)) {
-                if (value === undefined)
-                    delete headers[key];
-                else
-                    headers[key] = value;
-            }
-            result.headers = Object.keys(headers).length > 0 ? headers : undefined;
-        }
-    }
-    if (Object.hasOwn(patch, "metadata")) {
-        if (patch.metadata === undefined) {
-            result.metadata = undefined;
-        }
-        else {
-            const metadata = { ...(result.metadata ?? {}) };
-            for (const [key, value] of Object.entries(patch.metadata)) {
-                if (value === undefined)
-                    delete metadata[key];
-                else
-                    metadata[key] = value;
-            }
-            result.metadata = Object.keys(metadata).length > 0 ? metadata : undefined;
-        }
-    }
-    return result;
-}
 const SUBSCRIBER_EVENT_TYPE = "*";
 function normalizeHarnessError(error, fallbackCode) {
     if (error instanceof AgentHarnessError)
@@ -119,12 +23,10 @@ function normalizeHarnessError(error, fallbackCode) {
         return new AgentHarnessError("branch_summary", cause.message, cause);
     return new AgentHarnessError(fallbackCode, cause.message, cause);
 }
-function normalizeHookError(error) {
-    return normalizeHarnessError(error, "hook");
-}
 export class AgentHarness {
     env;
     session;
+    sessionFacade;
     phase = "idle";
     runAbortController;
     runPromise;
@@ -133,6 +35,7 @@ export class AgentHarness {
     thinkingLevel;
     systemPrompt;
     streamOptions;
+    compactionSettings;
     getApiKeyAndHeaders;
     resources;
     tools = new Map();
@@ -146,8 +49,10 @@ export class AgentHarness {
     constructor(options) {
         this.env = options.env;
         this.session = options.session;
+        this.sessionFacade = new HarnessSessionFacade(this.session, () => this.phase, this.pendingSessionWrites);
         this.resources = options.resources ?? {};
         this.streamOptions = cloneStreamOptions(options.streamOptions);
+        this.compactionSettings = { ...DEFAULT_COMPACTION_SETTINGS, ...options.compaction };
         this.systemPrompt = options.systemPrompt;
         this.getApiKeyAndHeaders = options.getApiKeyAndHeaders;
         this.validateUniqueNames((options.tools ?? []).map((tool) => tool.name), "Duplicate tool name(s)");
@@ -164,31 +69,28 @@ export class AgentHarness {
         this.steeringQueueMode = options.steeringMode ?? "one-at-a-time";
         this.followUpQueueMode = options.followUpMode ?? "one-at-a-time";
     }
-    getHandlers(type) {
-        return this.handlers.get(type);
-    }
     async emitOwn(event, signal) {
-        for (const listener of this.getHandlers(SUBSCRIBER_EVENT_TYPE) ?? []) {
+        for (const listener of this.handlers.get(SUBSCRIBER_EVENT_TYPE) ?? []) {
             try {
                 await listener(event, signal);
             }
             catch (error) {
-                throw normalizeHookError(error);
+                throw normalizeHarnessError(error, "hook");
             }
         }
     }
     async emitAny(event, signal) {
-        for (const listener of this.getHandlers(SUBSCRIBER_EVENT_TYPE) ?? []) {
+        for (const listener of this.handlers.get(SUBSCRIBER_EVENT_TYPE) ?? []) {
             try {
                 await listener(event, signal);
             }
             catch (error) {
-                throw normalizeHookError(error);
+                throw normalizeHarnessError(error, "hook");
             }
         }
     }
     async emitHook(event) {
-        const handlers = this.getHandlers(event.type);
+        const handlers = this.handlers.get(event.type);
         if (!handlers || handlers.size === 0)
             return undefined;
         let lastResult;
@@ -200,13 +102,13 @@ export class AgentHarness {
                 }
             }
             catch (error) {
-                throw normalizeHookError(error);
+                throw normalizeHarnessError(error, "hook");
             }
         }
         return lastResult;
     }
     async emitBeforeProviderRequest(model, sessionId, streamOptions) {
-        const handlers = this.getHandlers("before_provider_request");
+        const handlers = this.handlers.get("before_provider_request");
         let current = cloneStreamOptions(streamOptions);
         if (!handlers || handlers.size === 0)
             return current;
@@ -223,13 +125,13 @@ export class AgentHarness {
                 }
             }
             catch (error) {
-                throw normalizeHookError(error);
+                throw normalizeHarnessError(error, "hook");
             }
         }
         return current;
     }
     async emitBeforeProviderPayload(model, payload) {
-        const handlers = this.getHandlers("before_provider_payload");
+        const handlers = this.handlers.get("before_provider_payload");
         let current = payload;
         if (!handlers || handlers.size === 0)
             return current;
@@ -241,7 +143,7 @@ export class AgentHarness {
                 }
             }
             catch (error) {
-                throw normalizeHookError(error);
+                throw normalizeHarnessError(error, "hook");
             }
         }
         return current;
@@ -316,13 +218,14 @@ export class AgentHarness {
     createStreamFn(getTurnState) {
         return async (model, context, streamOptions) => {
             const turnState = getTurnState();
+            const requestContext = await this.maybeAutoCompact(model, context, streamOptions?.signal);
             const auth = await this.getApiKeyAndHeaders?.(model);
             const snapshotOptions = {
                 ...turnState.streamOptions,
                 headers: mergeHeaders(turnState.streamOptions.headers, auth?.headers),
             };
             const requestOptions = await this.emitBeforeProviderRequest(model, turnState.sessionId, snapshotOptions);
-            return streamSimple(model, context, {
+            return streamSimple(model, requestContext, {
                 cacheRetention: requestOptions.cacheRetention,
                 headers: requestOptions.headers,
                 maxRetries: requestOptions.maxRetries,
@@ -352,7 +255,7 @@ export class AgentHarness {
         }
         catch (error) {
             queue.unshift(...messages);
-            throw normalizeHookError(error);
+            throw normalizeHarnessError(error, "hook");
         }
     }
     createLoopConfig(getTurnState, setTurnState) {
@@ -492,7 +395,7 @@ export class AgentHarness {
         return messages;
     }
     async executeTurn(turnState, text, options) {
-        let activeTurnState = turnState;
+        const runOwner = this.runPromise;
         let messages = [createUserMessage(text, options?.images)];
         if (this.nextTurnQueue.length > 0) {
             const queuedMessages = this.nextTurnQueue.splice(0);
@@ -501,7 +404,7 @@ export class AgentHarness {
             }
             catch (error) {
                 this.nextTurnQueue.unshift(...queuedMessages);
-                throw normalizeHookError(error);
+                throw normalizeHarnessError(error, "hook");
             }
             messages = [...queuedMessages, messages[0]];
         }
@@ -514,6 +417,11 @@ export class AgentHarness {
         });
         if (beforeResult?.messages)
             messages = [...messages, ...beforeResult.messages];
+        const result = await this.executeAgentRun(turnState, this.createContext(turnState, beforeResult?.systemPrompt), messages);
+        return await this.recoverContextOverflow(result, runOwner);
+    }
+    async executeAgentRun(turnState, context, initialMessages) {
+        let activeTurnState = turnState;
         const abortController = new AbortController();
         const getTurnState = () => activeTurnState;
         const setTurnState = (nextTurnState) => {
@@ -521,13 +429,18 @@ export class AgentHarness {
         };
         this.runAbortController = abortController;
         const completedMessages = [];
+        const emit = async (event) => {
+            if (event.type === "message_end")
+                completedMessages.push(event.message);
+            await this.handleAgentEvent(event, abortController.signal);
+        };
         const runResultPromise = (async () => {
             try {
-                return await runAgentLoop(messages, this.createContext(turnState, beforeResult?.systemPrompt), this.createLoopConfig(getTurnState, setTurnState), async (event) => {
-                    if (event.type === "message_end")
-                        completedMessages.push(event.message);
-                    await this.handleAgentEvent(event, abortController.signal);
-                }, abortController.signal, this.createStreamFn(getTurnState));
+                const loopConfig = this.createLoopConfig(getTurnState, setTurnState);
+                const streamFn = this.createStreamFn(getTurnState);
+                return initialMessages
+                    ? await runAgentLoop(initialMessages, context, loopConfig, emit, abortController.signal, streamFn)
+                    : await runAgentLoopContinue(context, loopConfig, emit, abortController.signal, streamFn);
             }
             catch (error) {
                 try {
@@ -543,9 +456,8 @@ export class AgentHarness {
             const newMessages = await runResultPromise;
             for (let i = newMessages.length - 1; i >= 0; i--) {
                 const message = newMessages[i];
-                if (message.role === "assistant") {
+                if (message.role === "assistant")
                     return message;
-                }
             }
             throw new AgentHarnessError("invalid_state", "AgentHarness prompt completed without an assistant message");
         }
@@ -554,14 +466,47 @@ export class AgentHarness {
                 await this.flushPendingSessionWrites();
             }
             finally {
-                // Ownership check: a re-entrant run started from a settled/agent_end
-                // listener may have installed its own controller already.
-                if (this.runAbortController === abortController) {
+                if (this.runAbortController === abortController)
                     this.runAbortController = undefined;
-                }
             }
         }
     }
+    async recoverContextOverflow(message, runOwner) {
+        if (this.runPromise !== runOwner ||
+            this.phase !== "idle" ||
+            !this.compactionSettings.enabled ||
+            !isContextOverflow(message, this.model.contextWindow)) {
+            return message;
+        }
+        if (!this.getApiKeyAndHeaders)
+            return message;
+        const leafId = await this.session.getLeafId();
+        if (!leafId)
+            return message;
+        const leaf = await this.session.getEntry(leafId);
+        if (leaf?.type !== "message" ||
+            leaf.message.role !== "assistant" ||
+            leaf.message.timestamp !== message.timestamp ||
+            !isContextOverflow(leaf.message, this.model.contextWindow)) {
+            return message;
+        }
+        await this.session.moveTo(leaf.parentId);
+        this.phase = "retry";
+        try {
+            const compacted = await this.runCompaction({ automatic: true });
+            if (!compacted) {
+                await this.session.moveTo(leafId);
+                this.phase = "idle";
+                return message;
+            }
+            const turnState = await this.createTurnState();
+            return await this.executeAgentRun(turnState, this.createContext(turnState));
+        }
+        catch (error) {
+            await this.session.moveTo(leafId);
+            throw error;
+        }
+    }
     async prompt(text, options) {
         if (this.phase !== "idle")
             throw new AgentHarnessError("busy", "AgentHarness is busy");
@@ -640,58 +585,75 @@ export class AgentHarness {
         this.nextTurnQueue.push(createUserMessage(text, options?.images));
         await this.emitQueueUpdate();
     }
+    getSession() {
+        return this.sessionFacade;
+    }
     async appendMessage(message) {
-        try {
-            if (this.phase === "idle") {
-                await this.session.appendMessage(message);
-            }
-            else {
-                this.pendingSessionWrites.push({ type: "message", message });
-            }
-        }
-        catch (error) {
-            throw normalizeHarnessError(error, "session");
+        await this.sessionFacade.appendMessage(message);
+    }
+    async runCompaction(options) {
+        const model = this.model;
+        const auth = await this.getApiKeyAndHeaders?.(model);
+        if (!auth) {
+            if (options.automatic)
+                return undefined;
+            throw new AgentHarnessError("auth", "No auth available for compaction");
+        }
+        const branchEntries = await this.session.getBranch();
+        const preparationResult = prepareCompaction(branchEntries, this.compactionSettings);
+        if (!preparationResult.ok)
+            throw preparationResult.error;
+        const preparation = preparationResult.value;
+        if (!preparation) {
+            if (options.automatic)
+                return undefined;
+            throw new AgentHarnessError("compaction", "Nothing to compact");
+        }
+        const signal = options.signal ?? new AbortController().signal;
+        const hookResult = await this.emitHook({
+            type: "session_before_compact",
+            preparation,
+            branchEntries,
+            customInstructions: options.customInstructions,
+            signal,
+        });
+        if (hookResult?.cancel) {
+            if (options.automatic)
+                return undefined;
+            throw new AgentHarnessError("compaction", "Compaction cancelled");
+        }
+        const provided = hookResult?.compaction;
+        const compactResult = provided
+            ? { ok: true, value: provided }
+            : await compact(preparation, model, auth.apiKey, auth.headers, options.customInstructions, signal, this.thinkingLevel, createSummarizationRetry("compaction", this.streamOptions.summarizationRetry, (event) => this.emitOwn(event)));
+        if (!compactResult.ok)
+            throw compactResult.error;
+        const result = compactResult.value;
+        const entryId = await this.session.appendCompaction(result.summary, result.firstKeptEntryId, result.tokensBefore, result.details, provided !== undefined);
+        const entry = await this.session.getEntry(entryId);
+        if (entry?.type === "compaction") {
+            await this.emitOwn({ type: "session_compact", compactionEntry: entry, fromHook: provided !== undefined });
         }
+        return result;
+    }
+    async maybeAutoCompact(model, context, signal) {
+        const projected = estimateContextTokens(context.messages).tokens;
+        if (!shouldCompact(projected, model.contextWindow ?? 0, this.compactionSettings))
+            return context;
+        const result = await this.runCompaction({ automatic: true, signal });
+        if (!result)
+            return context;
+        const persisted = await this.session.buildContext();
+        return { ...context, messages: convertToLlm(persisted.messages) };
     }
     async compact(customInstructions) {
         if (this.phase !== "idle")
             throw new AgentHarnessError("busy", "compact() requires idle harness");
         this.phase = "compaction";
         try {
-            const model = this.model;
-            if (!model)
-                throw new AgentHarnessError("invalid_state", "No model set for compaction");
-            const auth = await this.getApiKeyAndHeaders?.(model);
-            if (!auth)
-                throw new AgentHarnessError("auth", "No auth available for compaction");
-            const branchEntries = await this.session.getBranch();
-            const preparationResult = prepareCompaction(branchEntries, DEFAULT_COMPACTION_SETTINGS);
-            if (!preparationResult.ok)
-                throw preparationResult.error;
-            const preparation = preparationResult.value;
-            if (!preparation)
+            const result = await this.runCompaction({ automatic: false, customInstructions });
+            if (!result)
                 throw new AgentHarnessError("compaction", "Nothing to compact");
-            const hookResult = await this.emitHook({
-                type: "session_before_compact",
-                preparation,
-                branchEntries,
-                customInstructions,
-                signal: new AbortController().signal,
-            });
-            if (hookResult?.cancel)
-                throw new AgentHarnessError("compaction", "Compaction cancelled");
-            const provided = hookResult?.compaction;
-            const compactResult = provided
-                ? { ok: true, value: provided }
-                : await compact(preparation, model, auth.apiKey, auth.headers, customInstructions, undefined, this.thinkingLevel);
-            if (!compactResult.ok)
-                throw compactResult.error;
-            const result = compactResult.value;
-            const entryId = await this.session.appendCompaction(result.summary, result.firstKeptEntryId, result.tokensBefore, result.details, provided !== undefined);
-            const entry = await this.session.getEntry(entryId);
-            if (entry?.type === "compaction") {
-                await this.emitOwn({ type: "session_compact", compactionEntry: entry, fromHook: provided !== undefined });
-            }
             return result;
         }
         catch (error) {
@@ -744,6 +706,7 @@ export class AgentHarness {
                     signal: new AbortController().signal,
                     customInstructions: hookResult?.customInstructions ?? options?.customInstructions,
                     replaceInstructions: hookResult?.replaceInstructions ?? options?.replaceInstructions,
+                    ...createSummarizationRetry("branch_summary", this.streamOptions.summarizationRetry, (event) => this.emitOwn(event)),
                 });
                 if (!branchSummary.ok) {
                     if (branchSummary.error.code === "aborted")
@@ -937,10 +900,10 @@ export class AgentHarness {
         this.streamOptions = cloneStreamOptions(streamOptions);
     }
     async abort() {
-        const clearedSteer = [...this.steerQueue];
-        const clearedFollowUp = [...this.followUpQueue];
-        this.steerQueue = [];
-        this.followUpQueue = [];
+        if (this.phase !== "idle" && this.phase !== "turn")
+            throw new AgentHarnessError("invalid_state", `Cannot abort during ${this.phase}`);
+        const clearedSteer = this.steerQueue.splice(0);
+        const clearedFollowUp = this.followUpQueue.splice(0);
         this.runAbortController?.abort();
         const errors = [];
         try {