@ai-agent-forge/agent-forge 0.86.7 → 0.87.0

package/dist/core/session-manager.js

@@ -8,6 +8,7 @@ import { isDeepStrictEqual } from "util";
 import { APP_NAME, getAgentDir as getDefaultAgentDir, getSessionsDir } from "../config.js";
 import { normalizePath, resolvePath } from "../utils/paths.js";
 import { AGENT_SESSIONS_DIR_NAME } from "./agent-session-paths.js";
+import { t } from "./i18n/index.js";
 import { createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, createInterruptedToolResultMessage, } from "./messages.js";
 import { FileSessionStorageProvider, SessionHeaderScanLimitError, } from "./session-storage.js";
 export const CURRENT_SESSION_VERSION = 3;
@@ -24,25 +25,25 @@ function assertJsonSerializable(value, field, seen = new WeakSet(), path = field
     if (typeof value === "number") {
         if (Number.isFinite(value))
             return;
-        throw new Error(`${field} must be JSON-serializable: non-finite number at ${path}`);
+        throw new Error(t("{field} must be JSON-serializable: non-finite number at {path}", { field, path }));
     }
     if (typeof value === "undefined" ||
         typeof value === "function" ||
         typeof value === "symbol" ||
         typeof value === "bigint") {
-        throw new Error(`${field} must be JSON-serializable: unsupported value at ${path}`);
+        throw new Error(t("{field} must be JSON-serializable: unsupported value at {path}", { field, path }));
     }
     if (typeof value !== "object")
-        throw new Error(`${field} must be JSON-serializable: unsupported value at ${path}`);
+        throw new Error(t("{field} must be JSON-serializable: unsupported value at {path}", { field, path }));
     if (seen.has(value))
-        throw new Error(`${field} must be JSON-serializable: cyclic value at ${path}`);
+        throw new Error(t("{field} must be JSON-serializable: cyclic value at {path}", { field, path }));
     if (!Array.isArray(value)) {
         const prototype = Object.getPrototypeOf(value);
         if (prototype !== Object.prototype && prototype !== null) {
-            throw new Error(`${field} must be JSON-serializable: non-plain object at ${path}`);
+            throw new Error(t("{field} must be JSON-serializable: non-plain object at {path}", { field, path }));
         }
         if (Object.getOwnPropertySymbols(value).length > 0) {
-            throw new Error(`${field} must be JSON-serializable: symbol key at ${path}`);
+            throw new Error(t("{field} must be JSON-serializable: symbol key at {path}", { field, path }));
         }
     }
     seen.add(value);
@@ -56,7 +57,7 @@ function assertJsonSerializable(value, field, seen = new WeakSet(), path = field
         for (const key of Object.keys(value)) {
             const descriptor = Object.getOwnPropertyDescriptor(value, key);
             if (!descriptor || !("value" in descriptor)) {
-                throw new Error(`${field} must be JSON-serializable: accessor at ${path}.${key}`);
+                throw new Error(t("{field} must be JSON-serializable: accessor at {path}", { field, path: `${path}.${key}` }));
             }
             assertJsonSerializable(descriptor.value, field, seen, `${path}.${key}`);
         }
@@ -70,7 +71,7 @@ function createSessionId() {
 }
 export function assertValidSessionId(id) {
     if (!/^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/.test(id)) {
-        throw new Error("Session id must be non-empty, contain only alphanumeric characters, '-', '_', and '.', and start and end with an alphanumeric character");
+        throw new Error(t("Session id must be non-empty, contain only alphanumeric characters, '-', '_', and '.', and start and end with an alphanumeric character"));
     }
 }
 /** Generate a unique short ID (8 hex chars, collision-checked) */
@@ -673,7 +674,10 @@ export class SessionManager {
             if (this.fileEntries.length === 0) {
                 const explicitPath = this.sessionFile;
                 if (this.storage.size(explicitPath) > 0) {
-                    throw new Error(`Session file is not a valid ${APP_NAME} session: ${explicitPath}`);
+                    throw new Error(t("Session file is not a valid {appName} session: {path}", {
+                        appName: APP_NAME,
+                        path: explicitPath,
+                    }));
                 }
                 this.newSession();
                 this.sessionFile = explicitPath;
@@ -744,10 +748,14 @@ export class SessionManager {
             this.leafId = entry.id;
             if (entry.type === "compaction" && entry.operationId !== undefined) {
                 if (typeof entry.operationId !== "string" || entry.operationId.trim() === "") {
-                    throw new Error(`Invalid compaction operationId in session entry: ${entry.id}`);
+                    throw new Error(t("Invalid compaction operationId in session entry: {operationId}", {
+                        operationId: String(entry.operationId),
+                    }));
                 }
                 if (this.compactionOperations.has(entry.operationId)) {
-                    throw new Error(`Duplicate compaction operationId in session: ${entry.operationId}`);
+                    throw new Error(t("Duplicate compaction operationId in session: {operationId}", {
+                        operationId: entry.operationId,
+                    }));
                 }
                 this.compactionOperations.set(entry.operationId, entry);
             }
@@ -863,7 +871,7 @@ export class SessionManager {
                 }
             }
             catch (rollbackError) {
-                throw new AggregateError([error, rollbackError], "Session append failed and rollback failed");
+                throw new AggregateError([error, rollbackError], t("Session append failed and rollback failed"));
             }
             throw error;
         }
@@ -946,7 +954,7 @@ export class SessionManager {
                     revision: this._revisionAfterEntry(previousOperation),
                 };
             }
-            throw new Error(`operation_id_reused: ${request.operationId}`);
+            throw new Error(t("operation_id_reused: {operationId}", { operationId: request.operationId }));
         }
         const currentRevision = this.getRevision();
         if (!sameSessionRevision(request.expectedRevision, currentRevision)) {
@@ -954,7 +962,9 @@ export class SessionManager {
         }
         const currentBranchContainsFirstKeptEntry = this.getBranch().some((entry) => entry.id === request.firstKeptEntryId);
         if (!currentBranchContainsFirstKeptEntry) {
-            throw new Error(`first_kept_entry_not_on_current_branch: ${request.firstKeptEntryId}`);
+            throw new Error(t("first_kept_entry_not_on_current_branch: {firstKeptEntryId}", {
+                firstKeptEntryId: request.firstKeptEntryId,
+            }));
         }
         const entry = {
             type: "compaction",
@@ -975,22 +985,22 @@ export class SessionManager {
     }
     _validateCompactionCommitRequest(request) {
         if (!request || typeof request !== "object")
-            throw new Error("Compaction commit request must be an object");
+            throw new Error(t("Compaction commit request must be an object"));
         if (request.version !== 1)
-            throw new Error("Unsupported compaction commit request version");
+            throw new Error(t("Unsupported compaction commit request version"));
         if (typeof request.operationId !== "string" || request.operationId.trim() === "") {
-            throw new Error("operationId must be a non-empty string");
+            throw new Error(t("operationId must be a non-empty string"));
         }
         if (typeof request.summary !== "string" || request.summary.trim() === "") {
-            throw new Error("summary must be a non-empty string");
+            throw new Error(t("summary must be a non-empty string"));
         }
         if (typeof request.firstKeptEntryId !== "string" || request.firstKeptEntryId === "") {
-            throw new Error("firstKeptEntryId must be a non-empty string");
+            throw new Error(t("firstKeptEntryId must be a non-empty string"));
         }
         if (typeof request.tokensBefore !== "number" ||
             !Number.isFinite(request.tokensBefore) ||
             request.tokensBefore < 0) {
-            throw new Error("tokensBefore must be a non-negative finite number");
+            throw new Error(t("tokensBefore must be a non-negative finite number"));
         }
         if (request.details !== undefined)
             assertJsonSerializable(request.details, "details");
@@ -1003,13 +1013,13 @@ export class SessionManager {
             !Number.isInteger(revision.sequence) ||
             revision.sequence < 0 ||
             (revision.leafId !== null && typeof revision.leafId !== "string")) {
-            throw new Error("expectedRevision must be a valid SessionRevisionV1");
+            throw new Error(t("expectedRevision must be a valid SessionRevisionV1"));
         }
     }
     _matchesCompactionCommitRequest(entry, request) {
         const entryIndex = this.fileEntries.indexOf(entry);
         if (entryIndex <= 0)
-            throw new Error(`Compaction operation entry is missing: ${entry.id}`);
+            throw new Error(t("Compaction operation entry is missing: {entryId}", { entryId: entry.id }));
         return (request.expectedRevision.version === 1 &&
             request.expectedRevision.sessionId === this.sessionId &&
             request.expectedRevision.sequence === entryIndex - 1 &&
@@ -1024,7 +1034,7 @@ export class SessionManager {
     _revisionAfterEntry(entry) {
         const entryIndex = this.fileEntries.indexOf(entry);
         if (entryIndex <= 0)
-            throw new Error(`Compaction operation entry is missing: ${entry.id}`);
+            throw new Error(t("Compaction operation entry is missing: {entryId}", { entryId: entry.id }));
         return { version: 1, sessionId: this.sessionId, sequence: entryIndex, leafId: entry.id };
     }
     /** Append a custom entry (for extensions) as child of current leaf, then advance leaf. Returns entry id. */
@@ -1125,7 +1135,7 @@ export class SessionManager {
      */
     appendLabelChange(targetId, label) {
         if (!this.byId.has(targetId)) {
-            throw new Error(`Entry ${targetId} not found`);
+            throw new Error(t("Entry {id} not found", { id: targetId }));
         }
         const entry = {
             type: "label",
@@ -1264,7 +1274,7 @@ export class SessionManager {
      */
     branch(branchFromId) {
         if (!this.byId.has(branchFromId)) {
-            throw new Error(`Entry ${branchFromId} not found`);
+            throw new Error(t("Entry {id} not found", { id: branchFromId }));
         }
         this.leafId = branchFromId;
     }
@@ -1283,7 +1293,7 @@ export class SessionManager {
      */
     branchWithSummary(branchFromId, summary, details, fromHook, usage) {
         if (branchFromId !== null && !this.byId.has(branchFromId)) {
-            throw new Error(`Entry ${branchFromId} not found`);
+            throw new Error(t("Entry {id} not found", { id: branchFromId }));
         }
         const fromId = this.leafId ?? "root";
         this.leafId = branchFromId;
@@ -1310,7 +1320,7 @@ export class SessionManager {
         const previousSessionFile = this.sessionFile;
         const path = this.getBranch(leafId);
         if (path.length === 0) {
-            throw new Error(`Entry ${leafId} not found`);
+            throw new Error(t("Entry {id} not found", { id: leafId }));
         }
         // Filter out LabelEntry from path - we'll recreate them from the resolved map.
         // Because labels are real tree entries, later entries can be children of labels;
@@ -1484,11 +1494,11 @@ export class SessionManager {
         const resolvedTargetCwd = resolvePath(targetCwd);
         const sourceEntries = storage.loadEntries(resolvedSourcePath);
         if (sourceEntries.length === 0) {
-            throw new Error(`Cannot fork: source session file is empty or invalid: ${resolvedSourcePath}`);
+            throw new Error(t("Cannot fork: source session file is empty or invalid: {path}", { path: resolvedSourcePath }));
         }
         const sourceHeader = sourceEntries.find((e) => e.type === "session");
         if (!sourceHeader) {
-            throw new Error(`Cannot fork: source session has no header: ${resolvedSourcePath}`);
+            throw new Error(t("Cannot fork: source session has no header: {path}", { path: resolvedSourcePath }));
         }
         const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(resolvedTargetCwd);
         storage.ensureDir(dir);