fix: inherit model overrides for thread sessions

src/auto-reply/reply/get-reply-directives.ts

@@ -379,6 +379,7 @@ export async function resolveReplyDirectives(params: {
     sessionEntry,
     sessionStore,
     sessionKey,
+    parentSessionKey: ctx.ParentSessionKey,
     storePath,
     defaultProvider,
     defaultModel,

src/auto-reply/reply/model-selection.inherit-parent.test.ts

@@ -0,0 +1,157 @@
+import { describe, expect, it, vi } from "vitest";
+
+import type { ClawdbotConfig } from "../../config/config.js";
+import { createModelSelectionState } from "./model-selection.js";
+
+vi.mock("../../agents/model-catalog.js", () => ({
+  loadModelCatalog: vi.fn(async () => [
+    { provider: "openai", id: "gpt-4o-mini", name: "GPT-4o mini" },
+    { provider: "openai", id: "gpt-4o", name: "GPT-4o" },
+    { provider: "anthropic", id: "claude-opus-4-5", name: "Claude Opus 4.5" },
+  ]),
+}));
+
+const defaultProvider = "openai";
+const defaultModel = "gpt-4o-mini";
+
+const makeEntry = (overrides: Record<string, unknown> = {}) => ({
+  sessionId: "session-id",
+  updatedAt: Date.now(),
+  ...overrides,
+});
+
+async function resolveState(params: {
+  cfg: ClawdbotConfig;
+  sessionEntry: ReturnType<typeof makeEntry>;
+  sessionStore: Record<string, ReturnType<typeof makeEntry>>;
+  sessionKey: string;
+  parentSessionKey?: string;
+}) {
+  return createModelSelectionState({
+    cfg: params.cfg,
+    agentCfg: params.cfg.agents?.defaults,
+    sessionEntry: params.sessionEntry,
+    sessionStore: params.sessionStore,
+    sessionKey: params.sessionKey,
+    parentSessionKey: params.parentSessionKey,
+    defaultProvider,
+    defaultModel,
+    provider: defaultProvider,
+    model: defaultModel,
+    hasModelDirective: false,
+  });
+}
+
+describe("createModelSelectionState parent inheritance", () => {
+  it("inherits parent override from explicit parentSessionKey", async () => {
+    const cfg = {} as ClawdbotConfig;
+    const parentKey = "agent:main:discord:channel:C1";
+    const sessionKey = "agent:main:discord:channel:C1:thread:123";
+    const parentEntry = makeEntry({
+      providerOverride: "openai",
+      modelOverride: "gpt-4o",
+    });
+    const sessionEntry = makeEntry();
+    const sessionStore = {
+      [parentKey]: parentEntry,
+      [sessionKey]: sessionEntry,
+    };
+
+    const state = await resolveState({
+      cfg,
+      sessionEntry,
+      sessionStore,
+      sessionKey,
+      parentSessionKey: parentKey,
+    });
+
+    expect(state.provider).toBe("openai");
+    expect(state.model).toBe("gpt-4o");
+  });
+
+  it("derives parent key from topic session suffix", async () => {
+    const cfg = {} as ClawdbotConfig;
+    const parentKey = "agent:main:telegram:group:123";
+    const sessionKey = "agent:main:telegram:group:123:topic:99";
+    const parentEntry = makeEntry({
+      providerOverride: "openai",
+      modelOverride: "gpt-4o",
+    });
+    const sessionEntry = makeEntry();
+    const sessionStore = {
+      [parentKey]: parentEntry,
+      [sessionKey]: sessionEntry,
+    };
+
+    const state = await resolveState({
+      cfg,
+      sessionEntry,
+      sessionStore,
+      sessionKey,
+    });
+
+    expect(state.provider).toBe("openai");
+    expect(state.model).toBe("gpt-4o");
+  });
+
+  it("prefers child override over parent", async () => {
+    const cfg = {} as ClawdbotConfig;
+    const parentKey = "agent:main:telegram:group:123";
+    const sessionKey = "agent:main:telegram:group:123:topic:99";
+    const parentEntry = makeEntry({
+      providerOverride: "openai",
+      modelOverride: "gpt-4o",
+    });
+    const sessionEntry = makeEntry({
+      providerOverride: "anthropic",
+      modelOverride: "claude-opus-4-5",
+    });
+    const sessionStore = {
+      [parentKey]: parentEntry,
+      [sessionKey]: sessionEntry,
+    };
+
+    const state = await resolveState({
+      cfg,
+      sessionEntry,
+      sessionStore,
+      sessionKey,
+    });
+
+    expect(state.provider).toBe("anthropic");
+    expect(state.model).toBe("claude-opus-4-5");
+  });
+
+  it("ignores parent override when disallowed", async () => {
+    const cfg = {
+      agents: {
+        defaults: {
+          models: {
+            "openai/gpt-4o-mini": {},
+          },
+        },
+      },
+    } as ClawdbotConfig;
+    const parentKey = "agent:main:slack:channel:C1";
+    const sessionKey = "agent:main:slack:channel:C1:thread:123";
+    const parentEntry = makeEntry({
+      providerOverride: "anthropic",
+      modelOverride: "claude-opus-4-5",
+    });
+    const sessionEntry = makeEntry();
+    const sessionStore = {
+      [parentKey]: parentEntry,
+      [sessionKey]: sessionEntry,
+    };
+
+    const state = await resolveState({
+      cfg,
+      sessionEntry,
+      sessionStore,
+      sessionKey,
+    });
+
+    expect(state.provider).toBe(defaultProvider);
+    expect(state.model).toBe(defaultModel);
+  });
+});

src/auto-reply/reply/model-selection.ts

@@ -13,6 +13,7 @@ import type { ClawdbotConfig } from "../../config/config.js";
 import { type SessionEntry, updateSessionStore } from "../../config/sessions.js";
 import { clearSessionAuthProfileOverride } from "../../agents/auth-profiles/session-override.js";
 import { applyModelOverrideToSessionEntry } from "../../sessions/model-overrides.js";
+import { resolveThreadParentSessionKey } from "../../sessions/session-key-utils.js";
 import type { ThinkLevel } from "./directives.js";
 
 export type ModelDirectiveSelection = {
@@ -78,6 +79,52 @@ function boundedLevenshteinDistance(a: string, b: string, maxDistance: number):
   return dist;
 }
 
+type StoredModelOverride = {
+  provider?: string;
+  model: string;
+  source: "session" | "parent";
+};
+
+function resolveModelOverrideFromEntry(entry?: SessionEntry): {
+  provider?: string;
+  model: string;
+} | null {
+  const model = entry?.modelOverride?.trim();
+  if (!model) return null;
+  const provider = entry?.providerOverride?.trim() || undefined;
+  return { provider, model };
+}
+
+function resolveParentSessionKeyCandidate(params: {
+  sessionKey?: string;
+  parentSessionKey?: string;
+}): string | null {
+  const explicit = params.parentSessionKey?.trim();
+  if (explicit && explicit !== params.sessionKey) return explicit;
+  const derived = resolveThreadParentSessionKey(params.sessionKey);
+  if (derived && derived !== params.sessionKey) return derived;
+  return null;
+}
+
+function resolveStoredModelOverride(params: {
+  sessionEntry?: SessionEntry;
+  sessionStore?: Record<string, SessionEntry>;
+  sessionKey?: string;
+  parentSessionKey?: string;
+}): StoredModelOverride | null {
+  const direct = resolveModelOverrideFromEntry(params.sessionEntry);
+  if (direct) return { ...direct, source: "session" };
+  const parentKey = resolveParentSessionKeyCandidate({
+    sessionKey: params.sessionKey,
+    parentSessionKey: params.parentSessionKey,
+  });
+  if (!parentKey || !params.sessionStore) return null;
+  const parentEntry = params.sessionStore[parentKey];
+  const parentOverride = resolveModelOverrideFromEntry(parentEntry);
+  if (!parentOverride) return null;
+  return { ...parentOverride, source: "parent" };
+}
+
 function scoreFuzzyMatch(params: {
   provider: string;
   model: string;
@@ -177,6 +224,7 @@ export async function createModelSelectionState(params: {
   sessionEntry?: SessionEntry;
   sessionStore?: Record<string, SessionEntry>;
   sessionKey?: string;
+  parentSessionKey?: string;
   storePath?: string;
   defaultProvider: string;
   defaultModel: string;
@@ -190,6 +238,7 @@ export async function createModelSelectionState(params: {
     sessionEntry,
     sessionStore,
     sessionKey,
+    parentSessionKey,
     storePath,
     defaultProvider,
     defaultModel,
@@ -199,7 +248,13 @@ export async function createModelSelectionState(params: {
   let model = params.model;
 
   const hasAllowlist = agentCfg?.models && Object.keys(agentCfg.models).length > 0;
-  const hasStoredOverride = Boolean(sessionEntry?.modelOverride || sessionEntry?.providerOverride);
+  const initialStoredOverride = resolveStoredModelOverride({
+    sessionEntry,
+    sessionStore,
+    sessionKey,
+    parentSessionKey,
+  });
+  const hasStoredOverride = Boolean(initialStoredOverride);
   const needsModelCatalog = params.hasModelDirective || hasAllowlist || hasStoredOverride;
 
   let allowedModelKeys = new Set<string>();
@@ -242,14 +297,18 @@ export async function createModelSelectionState(params: {
     }
   }
 
-  const storedProviderOverride = sessionEntry?.providerOverride?.trim();
-  const storedModelOverride = sessionEntry?.modelOverride?.trim();
-  if (storedModelOverride) {
-    const candidateProvider = storedProviderOverride || defaultProvider;
-    const key = modelKey(candidateProvider, storedModelOverride);
+  const storedOverride = resolveStoredModelOverride({
+    sessionEntry,
+    sessionStore,
+    sessionKey,
+    parentSessionKey,
+  });
+  if (storedOverride?.model) {
+    const candidateProvider = storedOverride.provider || defaultProvider;
+    const key = modelKey(candidateProvider, storedOverride.model);
     if (allowedModelKeys.size === 0 || allowedModelKeys.has(key)) {
       provider = candidateProvider;
-      model = storedModelOverride;
+      model = storedOverride.model;
     }
   }