antechamber 1.0.12 → 1.0.14

package/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.0.14] - 2026-10-22
+
+### Fixed
+
+- Preselect OmO's real effort in OpenChamber 2.x instead of "Default": `/api/agent` now nests the agent's
+  default model and level as `model: {id, providerID, variant}`, and a reopened session reports the model and
+  level OmO will resume it with, read from its session file, instead of `variant: "default"`.
+
+## [1.0.13] - 2026-10-22
+
+### Fixed
+
+- Show the effort (thinking level) picker again in OpenChamber 2.x: `/api/model` and `/api/model/default`
+  now list each model's thinking levels in `variants` instead of an empty array.
+- Keep a session's effort when OpenChamber 2.x reopens it on another device: the v2 session record now reports
+  the thinking level actually applied, instead of a stale one that the next prompt sent back.
+
 ## [1.0.12] - 2026-10-21
 
 ### Fixed

package/dist/routes-v2.js

@@ -16,9 +16,13 @@ import { announceSessionError, compactSession, getCommands, unsupportedShare } f
 import { defaultV2Model, flattenModels, toV2Message, toV2Session } from "./v2.js";
 import { agentDescriptors, modelRefFromBody, numberParam, OPENCODE_COMPAT_VERSION, promptAsync, runSessionShell, runSessionSlash, sessionDirectory, sessionMetadata, } from "./route-services.js";
 async function v2Agents(services) {
-    return (await agentDescriptors(services)).map((agent) => ({
+    return (await agentDescriptors(services)).map(({ model, variant, ...agent }) => ({
         id: agent.name,
         ...agent,
+        // v2 nests the effort in the agent's ModelRef; OpenChamber 2.x preselects only `model.id` + `model.variant`.
+        ...(model !== undefined
+            ? { model: { id: model.modelID, providerID: model.providerID, ...(variant !== undefined ? { variant } : {}) } }
+            : {}),
         request: { settings: {}, headers: {}, body: {} },
         permissions: agent.permission.map((rule) => ({
             action: rule.permission,

package/dist/session-store.d.ts

@@ -19,8 +19,16 @@ import type { ChildTask } from "./subagents.js";
 export declare function piSessionDir(cwd: string): string;
 /** Deterministic OpenChamber session id for a pi session id. */
 export declare function ocIdFor(piSessionId: string): string;
+/** The model and thinking level OmO resumes a session file with. */
+export interface SessionSelection {
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    thinkingLevel?: string;
+}
 /** One *.jsonl discovered on disk, not (yet) backed by a live pi process. */
-export interface ScannedSession {
+export interface ScannedSession extends SessionSelection {
     piSessionId: string;
     piPath: string;
     directory: string;
@@ -66,12 +74,13 @@ export interface SessionRegistryEntry {
 export declare class SessionPersistenceError extends Error {
     constructor(file: string, cause: unknown);
 }
-/** Native renames append anywhere in the transcript; directory mtimes do not change. */
-export declare function readSessionTitle(piPath: string, piSessionId: string): {
+interface SessionFileMeta extends SessionSelection {
     title: string;
     fallbackTitle: string;
     titleSource: TitleSource;
-};
+}
+/** Native renames and model/thinking changes append anywhere in the transcript; directory mtimes do not change. */
+export declare function readSessionFileMeta(piPath: string, piSessionId: string): SessionFileMeta;
 /**
  * Newest mtime across the sessions root and its per-cwd subdirectories. Cache
  * key for {@link scanAllPiSessions}: a new session file bumps its own cwd
@@ -114,3 +123,4 @@ export declare class SessionStore {
     /** Every directory the registry knows about — used to resolve bare session ids. */
     directories(): string[];
 }
+export {};

package/dist/session-store.js

@@ -84,16 +84,97 @@ function titleFromHead(head, piSessionId) {
     }
     return `pi session ${piSessionId.slice(0, 8)}`;
 }
-const titleCache = new Map();
-/** Native renames append anywhere in the transcript; directory mtimes do not change. */
-export function readSessionTitle(piPath, piSessionId) {
+function modelRef(provider, modelID) {
+    return typeof provider === "string" && provider !== "" && typeof modelID === "string" && modelID !== ""
+        ? { providerID: provider, modelID }
+        : undefined;
+}
+function selectionStep(entry) {
+    if (entry.type === "thinking_level_change")
+        return { kind: "thinking", level: typeof entry.thinkingLevel === "string" ? entry.thinkingLevel : undefined };
+    if (entry.type === "model_change")
+        return {
+            kind: "model",
+            reason: entry.reason,
+            model: modelRef(entry.provider, entry.modelId),
+            original: modelRef(entry.originalProvider, entry.originalModelId),
+        };
+    const message = entry.message;
+    // A failed routing attempt names the virtual model; no model answered it.
+    if (entry.type !== "message" || message?.role !== "assistant" || message.api === "pi-virtual")
+        return undefined;
+    const model = modelRef(message.provider, message.model);
+    return model === undefined ? undefined : { kind: "reply", model };
+}
+/**
+ * OmO resumes at the file's last entry and resolves the model and level along its path, restoring the
+ * pre-fallback model and level across a fallback window. Mirrors senpi's getSessionContextSettings
+ * (dist/core/session-manager.js), except that legacy provider ids are not normalized.
+ */
+function resumeSelection(byId, leafId) {
+    const path = [];
+    const seen = new Set();
+    for (let id = leafId; id !== undefined && !seen.has(id);) {
+        const entry = byId.get(id);
+        if (entry === undefined)
+            break;
+        seen.add(id);
+        if (entry.step !== undefined)
+            path.push(entry.step);
+        id = entry.parentId ?? undefined;
+    }
+    let model;
+    let explicit = false;
+    let inFallback = false;
+    let level;
+    let preFallbackLevel;
+    for (const step of path.reverse()) {
+        if (step.kind === "thinking")
+            level = step.level;
+        else if (step.kind === "model" && step.reason === "fallback") {
+            if (!inFallback) {
+                preFallbackLevel = level;
+                if (step.original !== undefined) {
+                    model = step.original;
+                    explicit = true;
+                }
+            }
+            inFallback = true;
+        }
+        else if (step.kind === "model" && step.reason === "fallback-revert") {
+            if (inFallback)
+                level = preFallbackLevel;
+            inFallback = false;
+        }
+        else if (step.kind === "model") {
+            inFallback = false;
+            if (step.model !== undefined) {
+                model = step.model;
+                explicit = true;
+            }
+        }
+        else if (!inFallback && !(explicit && model?.providerID === step.model.providerID)) {
+            // A reply echoes the wire id; only a reply from another provider overrides an explicit pick.
+            model = step.model;
+            explicit = false;
+        }
+    }
+    if (inFallback)
+        level = preFallbackLevel;
+    return { ...(model !== undefined ? { model } : {}), ...(level !== undefined ? { thinkingLevel: level } : {}) };
+}
+const fileMetaCache = new Map();
+/** Native renames and model/thinking changes append anywhere in the transcript; directory mtimes do not change. */
+export function readSessionFileMeta(piPath, piSessionId) {
     const stat = statSync(piPath);
-    const cached = titleCache.get(piPath);
+    const cached = fileMetaCache.get(piPath);
     if (cached?.mtimeMs === stat.mtimeMs && cached.size === stat.size)
         return cached;
     const raw = readFileSync(piPath, "utf8");
     const fallbackTitle = titleFromHead(raw, piSessionId);
     let native;
+    const byId = new Map();
+    let leafId;
     for (const line of raw.split("\n")) {
         try {
             const entry = JSON.parse(line);
@@ -102,6 +183,14 @@ export function readSessionTitle(piPath, piSessionId) {
                 if (name !== "")
                     native = name;
             }
+            if (entry?.type !== "session" && typeof entry?.id === "string") {
+                const step = selectionStep(entry);
+                byId.set(entry.id, {
+                    parentId: typeof entry.parentId === "string" ? entry.parentId : null,
+                    ...(step !== undefined ? { step } : {}),
+                });
+                leafId = entry.id;
+            }
         }
         catch {
             // Partial trailing writes do not erase the last valid title.
@@ -113,8 +202,9 @@ export function readSessionTitle(piPath, piSessionId) {
         title: native ?? fallbackTitle,
         fallbackTitle,
         titleSource: native === undefined ? "fallback" : "native",
+        ...resumeSelection(byId, leafId),
     };
-    titleCache.set(piPath, metadata);
+    fileMetaCache.set(piPath, metadata);
     return metadata;
 }
 function parseSessionHeader(head) {
@@ -146,7 +236,7 @@ function buildScanned(piPath, directory, header) {
         piSessionId,
         piPath,
         directory,
-        ...readSessionTitle(piPath, piSessionId),
+        ...readSessionFileMeta(piPath, piSessionId),
         created: Number.isNaN(created) ? Math.floor(updated) : created,
         updated: Math.floor(updated),
     };

package/dist/sessions.d.ts

@@ -176,6 +176,11 @@ export declare class SessionManager {
      */
     setModel(sessionId: string, ref: ModelSelection): Promise<OCModelRef>;
     private setModelLive;
+    /**
+     * On a device with no saved pick, OpenChamber 2.x restores a reopened session's effort from this
+     * record and resends it with the next prompt, so a stale level silently resets the user's choice.
+     */
+    private syncRecordVariant;
     /**
      * Single funnel for "pi is now running this model": adopt it, persist it for
      * the next cold start, and tell the UI. Returns whether anything changed.

package/dist/sessions.js

@@ -20,7 +20,7 @@ import { MonitorSessions } from "./monitor-sessions.js";
 import { WorkStatusBridge } from "./work-status.js";
 import { sessionDiff } from "./session-diff.js";
 import { announceSessionNotice, skillCommandText, slashTitlePrompt } from "./session-commands.js";
-import { ocIdFor, piSessionDir, piSessionsRootMtime, scanAllPiSessions, scanPiSessions, SessionStore, readSessionTitle, } from "./session-store.js";
+import { ocIdFor, piSessionDir, piSessionsRootMtime, scanAllPiSessions, scanPiSessions, SessionStore, readSessionFileMeta, } from "./session-store.js";
 import { ADAPTER_VERSION } from "./version.js";
 export { ADAPTER_VERSION } from "./version.js";
 const SESSION_SCAN_CACHE_TTL_MS = 5_000;
@@ -30,6 +30,21 @@ const SESSION_TITLE_MAX_CHARS = 60;
 /** OmO's reply when a compaction is aborted (`CompactionCancelledError`). */
 const OMO_COMPACTION_CANCELLED = "Compaction cancelled";
 const COMPACT_CANCEL_RETRIES = 2;
+/**
+ * A dormant session's record as OmO will resume it. OpenChamber 2.x restores a reopened session's effort
+ * from this record and resends it, so the model and level come together from the file; the registry only
+ * fills in when the file records no model.
+ */
+function dormantModel(file, registry) {
+    if (file.model !== undefined)
+        return { model: file.model, variant: file.thinkingLevel ?? "default" };
+    if (registry === undefined)
+        return undefined;
+    return {
+        model: { providerID: registry.providerID, modelID: registry.modelID },
+        variant: registry.variant ?? "default",
+    };
+}
 export class SessionManager {
     emit;
     defaultDirectory;
@@ -215,9 +230,15 @@ export class SessionManager {
     refreshNativeTitle(s) {
         if (s.pi !== undefined || s.restored === undefined || !existsSync(s.restored.piPath))
             return;
-        const metadata = readSessionTitle(s.restored.piPath, s.restored.piSessionId);
+        const metadata = readSessionFileMeta(s.restored.piPath, s.restored.piSessionId);
         if (metadata.titleSource === "native")
             this.applyNativeTitle(s, metadata.title);
+        // Not revived here yet, so nothing cached overrides what OmO will resume with, which another client may change.
+        const resumed = s.thinkingLevel === undefined ? dormantModel(metadata, undefined) : undefined;
+        if (resumed !== undefined) {
+            s.model = resumed.model;
+            s.info.model = { id: resumed.model.modelID, providerID: resumed.model.providerID, variant: resumed.variant };
+        }
     }
     wirePi(s, pi) {
         s.unwirePi?.();
@@ -837,6 +858,7 @@ export class SessionManager {
         // not cost a round-trip nor emit a phantom "model switched" marker.
         if (s.model !== undefined && s.model.providerID === ref.providerID && s.model.modelID === ref.modelID) {
             await setThinkingLevel(s, pi, ref.variant);
+            this.syncRecordVariant(s);
             return s.model;
         }
         const res = await pi.command({
@@ -868,8 +890,17 @@ export class SessionManager {
         };
         this.applyPiModel(s, resolved.providerID, resolved.modelID);
         await setThinkingLevel(s, pi, ref.variant);
+        this.syncRecordVariant(s);
         return resolved;
     }
+    /**
+     * On a device with no saved pick, OpenChamber 2.x restores a reopened session's effort from this
+     * record and resends it with the next prompt, so a stale level silently resets the user's choice.
+     */
+    syncRecordVariant(s) {
+        if (s.info.model !== undefined)
+            s.info.model = { ...s.info.model, variant: s.thinkingLevel ?? "default" };
+    }
     /**
      * Single funnel for "pi is now running this model": adopt it, persist it for
      * the next cold start, and tell the UI. Returns whether anything changed.
@@ -1208,6 +1239,7 @@ export class SessionManager {
             s.piPath = restored.piPath;
             s.piSessionId = restored.piSessionId;
             this.applyPiModel(s, state.data.model?.provider, state.data.model?.id);
+            this.syncRecordVariant(s);
             this.refreshMessageCache(s);
             this.persistMeta(s);
             delete s.restored;
@@ -1336,6 +1368,7 @@ export class SessionManager {
         const titleSource = reg?.titleSource ??
             (reg?.title && reg.title !== "New session" && reg.title !== sc.fallbackTitle ? "user" : "fallback");
         const useRegistry = titleSource === "user" || (sc.titleSource !== "native" && titleSource === "generated");
+        const resumed = dormantModel(sc, reg?.model);
         const info = {
             id: ocId,
             projectID: sc.directory,
@@ -1349,9 +1382,9 @@ export class SessionManager {
             ...(reg?.metadata !== undefined ? { metadata: reg.metadata } : {}),
             ...(reg?.parentID !== undefined ? { parentID: reg.parentID } : {}),
             ...(reg?.parentMessageID !== undefined ? { parentMessageID: reg.parentMessageID } : {}),
-            ...(reg?.model !== undefined
+            ...(resumed !== undefined
                 ? {
-                    model: { id: reg.model.modelID, providerID: reg.model.providerID, variant: reg.model.variant ?? "default" },
+                    model: { id: resumed.model.modelID, providerID: resumed.model.providerID, variant: resumed.variant },
                 }
                 : {}),
             ...(reg?.tree?.revert ? { revert: { messageID: reg.tree.revert.messageID } } : {}),
@@ -1369,7 +1402,7 @@ export class SessionManager {
             pi: undefined,
             messages: undefined,
             status: { type: "idle" },
-            model: reg?.model !== undefined ? { providerID: reg.model.providerID, modelID: reg.model.modelID } : undefined,
+            model: resumed?.model,
             streaming: undefined,
             toolByCallId: new Map(),
             restored: { piSessionId: sc.piSessionId, piPath: sc.piPath },
@@ -1393,7 +1426,7 @@ export class SessionManager {
                 piSessionId: reg.piSessionId,
                 piPath: reg.piPath,
                 directory: reg.directory,
-                ...readSessionTitle(reg.piPath, reg.piSessionId),
+                ...readSessionFileMeta(reg.piPath, reg.piSessionId),
                 created: reg.created,
                 updated: reg.updated,
             });

package/dist/v2.d.ts

@@ -86,6 +86,8 @@ interface CatalogModelLike {
         context: number;
         output: number;
     };
+    /** Thinking levels keyed by id, the v1 shape. */
+    variants?: Record<string, Record<string, unknown>>;
 }
 interface CatalogProviderLike {
     id: string;

package/dist/v2.js

@@ -44,7 +44,8 @@ function toV2Model(m) {
         providerID: m.providerID,
         name: m.name,
         capabilities: { tools: true, input: inputs.length > 0 ? inputs : ["text"], output: ["text"] },
-        variants: [],
+        // OpenChamber 2.x reads a model's efforts only from this array; empty hides the picker.
+        variants: Object.entries(m.variants ?? {}).map(([id, settings]) => ({ id, settings })),
         time: { released: 0 },
         cost: [
             { input: m.cost.input, output: m.cost.output, cache: { read: m.cost.cache.read, write: m.cost.cache.write } },

package/extensions/omo-compat/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-compat",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "OpenChamber extension: displays OmO tool calls the way OmO means them when OpenChamber runs on antechamber",
   "private": true,
   "type": "module",

package/extensions/omo-dag/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-graph",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "OpenChamber extension: live, interactive graph of the OmO sub-agents behind the current session",
   "private": true,
   "type": "module",

package/extensions/omo-work/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-work",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "OpenChamber 2.x Work Status section: OmO todo phases, monitors, eval cells and background work of the current session",
   "private": true,
   "type": "module",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "OpenCode-compatible HTTP/SSE server that lets OpenChamber drive the pi coding agent (and OmO) over RPC",
   "type": "module",
   "license": "MIT",