Merge pull request #472 from koala73/main

feat: add hooks.gmail.model for cheaper Gmail PubSub processing

src/agents/model-fallback.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it, vi } from "vitest";
+
+import type { ClawdbotConfig } from "../config/config.js";
+import { runWithModelFallback } from "./model-fallback.js";
+
+function makeCfg(overrides: Partial<ClawdbotConfig> = {}): ClawdbotConfig {
+  return {
+    agents: {
+      defaults: {
+        model: {
+          primary: "openai/gpt-4.1-mini",
+          fallbacks: ["anthropic/claude-haiku-3-5"],
+        },
+      },
+    },
+    ...overrides,
+  } as ClawdbotConfig;
+}
+
+describe("runWithModelFallback", () => {
+  it("does not fall back on non-auth errors", async () => {
+    const cfg = makeCfg();
+    const run = vi
+      .fn()
+      .mockRejectedValueOnce(new Error("bad request"))
+      .mockResolvedValueOnce("ok");
+
+    await expect(
+      runWithModelFallback({
+        cfg,
+        provider: "openai",
+        model: "gpt-4.1-mini",
+        run,
+      }),
+    ).rejects.toThrow("bad request");
+    expect(run).toHaveBeenCalledTimes(1);
+  });
+
+  it("falls back on auth errors", async () => {
+    const cfg = makeCfg();
+    const run = vi
+      .fn()
+      .mockRejectedValueOnce(Object.assign(new Error("nope"), { status: 401 }))
+      .mockResolvedValueOnce("ok");
+
+    const result = await runWithModelFallback({
+      cfg,
+      provider: "openai",
+      model: "gpt-4.1-mini",
+      run,
+    });
+
+    expect(result.result).toBe("ok");
+    expect(run).toHaveBeenCalledTimes(2);
+    expect(run.mock.calls[1]?.[0]).toBe("anthropic");
+    expect(run.mock.calls[1]?.[1]).toBe("claude-haiku-3-5");
+  });
+
+  it("appends the configured primary as a last fallback", async () => {
+    const cfg = makeCfg({
+      agents: {
+        defaults: {
+          model: {
+            primary: "openai/gpt-4.1-mini",
+            fallbacks: [],
+          },
+        },
+      },
+    });
+    const run = vi
+      .fn()
+      .mockRejectedValueOnce(
+        Object.assign(new Error("timeout"), { code: "ETIMEDOUT" }),
+      )
+      .mockResolvedValueOnce("ok");
+
+    const result = await runWithModelFallback({
+      cfg,
+      provider: "openrouter",
+      model: "meta-llama/llama-3.3-70b:free",
+      run,
+    });
+
+    expect(result.result).toBe("ok");
+    expect(run).toHaveBeenCalledTimes(2);
+    expect(result.provider).toBe("openai");
+    expect(result.model).toBe("gpt-4.1-mini");
+  });
+});

src/agents/model-fallback.ts

@@ -4,8 +4,13 @@ import {
   buildModelAliasIndex,
   modelKey,
   parseModelRef,
+  resolveConfiguredModelRef,
   resolveModelRefFromString,
 } from "./model-selection.js";
+import {
+  isAuthErrorMessage,
+  isRateLimitErrorMessage,
+} from "./pi-embedded-helpers.js";
 
 type ModelCandidate = {
   provider: string;
@@ -29,6 +34,59 @@ function isAbortError(err: unknown): boolean {
   return message.includes("aborted");
 }
 
+function getStatusCode(err: unknown): number | null {
+  if (!err || typeof err !== "object") return null;
+  const candidate =
+    (err as { status?: unknown; statusCode?: unknown }).status ??
+    (err as { statusCode?: unknown }).statusCode;
+  if (typeof candidate === "number") return candidate;
+  if (typeof candidate === "string" && /^\d+$/.test(candidate)) {
+    return Number(candidate);
+  }
+  return null;
+}
+
+function getErrorCode(err: unknown): string {
+  if (!err || typeof err !== "object") return "";
+  const candidate = (err as { code?: unknown }).code;
+  return typeof candidate === "string" ? candidate : "";
+}
+
+function getErrorMessage(err: unknown): string {
+  if (err instanceof Error) return err.message;
+  return String(err ?? "");
+}
+
+function isTimeoutErrorMessage(raw: string): boolean {
+  const value = raw.toLowerCase();
+  return (
+    value.includes("timeout") ||
+    value.includes("timed out") ||
+    value.includes("deadline exceeded") ||
+    value.includes("context deadline exceeded")
+  );
+}
+
+function shouldFallbackForError(err: unknown): boolean {
+  const statusCode = getStatusCode(err);
+  if (statusCode && [401, 403, 429].includes(statusCode)) return true;
+  const code = getErrorCode(err).toUpperCase();
+  if (
+    ["ETIMEDOUT", "ESOCKETTIMEDOUT", "ECONNRESET", "ECONNABORTED"].includes(
+      code,
+    )
+  ) {
+    return true;
+  }
+  const message = getErrorMessage(err);
+  if (!message) return false;
+  return (
+    isAuthErrorMessage(message) ||
+    isRateLimitErrorMessage(message) ||
+    isTimeoutErrorMessage(message)
+  );
+}
+
 function buildAllowedModelKeys(
   cfg: ClawdbotConfig | undefined,
   defaultProvider: string,
@@ -119,6 +177,13 @@ function resolveFallbackCandidates(params: {
 }): ModelCandidate[] {
   const provider = params.provider.trim() || DEFAULT_PROVIDER;
   const model = params.model.trim() || DEFAULT_MODEL;
+  const primary = params.cfg
+    ? resolveConfiguredModelRef({
+        cfg: params.cfg,
+        defaultProvider: DEFAULT_PROVIDER,
+        defaultModel: DEFAULT_MODEL,
+      })
+    : null;
   const aliasIndex = buildModelAliasIndex({
     cfg: params.cfg ?? {},
     defaultProvider: DEFAULT_PROVIDER,
@@ -160,6 +225,10 @@ function resolveFallbackCandidates(params: {
     addCandidate(resolved.ref, true);
   }
 
+  if (primary?.provider && primary.model) {
+    addCandidate({ provider: primary.provider, model: primary.model }, false);
+  }
+
   return candidates;
 }
 
@@ -197,6 +266,8 @@ export async function runWithModelFallback<T>(params: {
       };
     } catch (err) {
       if (isAbortError(err)) throw err;
+      const shouldFallback = shouldFallbackForError(err);
+      if (!shouldFallback) throw err;
       lastError = err;
       attempts.push({
         provider: candidate.provider,

src/agents/model-selection.test.ts

@@ -1,10 +1,12 @@
 import { describe, expect, it } from "vitest";
 
 import type { ClawdbotConfig } from "../config/config.js";
+import { DEFAULT_PROVIDER } from "./defaults.js";
 import {
   buildAllowedModelSet,
   modelKey,
   parseModelRef,
+  resolveHooksGmailModel,
 } from "./model-selection.js";
 
 const catalog = [
@@ -70,3 +72,74 @@ describe("parseModelRef", () => {
     });
   });
 });
+
+describe("resolveHooksGmailModel", () => {
+  it("returns null when hooks.gmail.model is not set", () => {
+    const cfg = {} satisfies ClawdbotConfig;
+    const result = resolveHooksGmailModel({
+      cfg,
+      defaultProvider: DEFAULT_PROVIDER,
+    });
+    expect(result).toBeNull();
+  });
+
+  it("returns null when hooks.gmail.model is empty", () => {
+    const cfg = {
+      hooks: { gmail: { model: "" } },
+    } satisfies ClawdbotConfig;
+    const result = resolveHooksGmailModel({
+      cfg,
+      defaultProvider: DEFAULT_PROVIDER,
+    });
+    expect(result).toBeNull();
+  });
+
+  it("parses provider/model from hooks.gmail.model", () => {
+    const cfg = {
+      hooks: { gmail: { model: "openrouter/meta-llama/llama-3.3-70b:free" } },
+    } satisfies ClawdbotConfig;
+    const result = resolveHooksGmailModel({
+      cfg,
+      defaultProvider: DEFAULT_PROVIDER,
+    });
+    expect(result).toEqual({
+      provider: "openrouter",
+      model: "meta-llama/llama-3.3-70b:free",
+    });
+  });
+
+  it("resolves alias from agent.models", () => {
+    const cfg = {
+      agents: {
+        defaults: {
+          models: {
+            "anthropic/claude-sonnet-4-1": { alias: "Sonnet" },
+          },
+        },
+      },
+      hooks: { gmail: { model: "Sonnet" } },
+    } satisfies ClawdbotConfig;
+    const result = resolveHooksGmailModel({
+      cfg,
+      defaultProvider: DEFAULT_PROVIDER,
+    });
+    expect(result).toEqual({
+      provider: "anthropic",
+      model: "claude-sonnet-4-1",
+    });
+  });
+
+  it("uses default provider when model omits provider", () => {
+    const cfg = {
+      hooks: { gmail: { model: "claude-haiku-3-5" } },
+    } satisfies ClawdbotConfig;
+    const result = resolveHooksGmailModel({
+      cfg,
+      defaultProvider: "anthropic",
+    });
+    expect(result).toEqual({
+      provider: "anthropic",
+      model: "claude-haiku-3-5",
+    });
+  });
+});

src/agents/model-selection.ts

@@ -211,3 +211,28 @@ export function resolveThinkingDefault(params: {
   if (candidate?.reasoning) return "low";
   return "off";
 }
+
+/**
+ * Resolve the model configured for Gmail hook processing.
+ * Returns null if hooks.gmail.model is not set.
+ */
+export function resolveHooksGmailModel(params: {
+  cfg: ClawdbotConfig;
+  defaultProvider: string;
+}): ModelRef | null {
+  const hooksModel = params.cfg.hooks?.gmail?.model;
+  if (!hooksModel?.trim()) return null;
+
+  const aliasIndex = buildModelAliasIndex({
+    cfg: params.cfg,
+    defaultProvider: params.defaultProvider,
+  });
+
+  const resolved = resolveModelRefFromString({
+    raw: hooksModel,
+    defaultProvider: params.defaultProvider,
+    aliasIndex,
+  });
+
+  return resolved?.ref ?? null;
+}