366 lines
11 KiB
TypeScript
366 lines
11 KiB
TypeScript
import fs from "node:fs/promises";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
|
|
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
|
|
|
vi.mock("../agents/pi-embedded.js", () => ({
|
|
runEmbeddedPiAgent: vi.fn(),
|
|
queueEmbeddedPiMessage: vi.fn().mockReturnValue(false),
|
|
}));
|
|
vi.mock("../agents/model-catalog.js", () => ({
|
|
loadModelCatalog: vi.fn(),
|
|
}));
|
|
|
|
import { loadModelCatalog } from "../agents/model-catalog.js";
|
|
import { runEmbeddedPiAgent } from "../agents/pi-embedded.js";
|
|
import {
|
|
loadSessionStore,
|
|
resolveSessionKey,
|
|
saveSessionStore,
|
|
} from "../config/sessions.js";
|
|
import {
|
|
extractThinkDirective,
|
|
extractVerboseDirective,
|
|
getReplyFromConfig,
|
|
} from "./reply.js";
|
|
|
|
async function withTempHome<T>(fn: (home: string) => Promise<T>): Promise<T> {
|
|
const base = await fs.mkdtemp(path.join(os.tmpdir(), "clawdis-reply-"));
|
|
const previousHome = process.env.HOME;
|
|
process.env.HOME = base;
|
|
try {
|
|
return await fn(base);
|
|
} finally {
|
|
process.env.HOME = previousHome;
|
|
await fs.rm(base, { recursive: true, force: true });
|
|
}
|
|
}
|
|
|
|
describe("directive parsing", () => {
|
|
beforeEach(() => {
|
|
vi.mocked(runEmbeddedPiAgent).mockReset();
|
|
vi.mocked(loadModelCatalog).mockResolvedValue([
|
|
{ id: "claude-opus-4-5", name: "Opus 4.5", provider: "anthropic" },
|
|
{ id: "claude-sonnet-4-1", name: "Sonnet 4.1", provider: "anthropic" },
|
|
{ id: "gpt-4.1-mini", name: "GPT-4.1 Mini", provider: "openai" },
|
|
]);
|
|
});
|
|
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
it("ignores verbose directive inside URL", () => {
|
|
const body = "https://x.com/verioussmith/status/1997066835133669687";
|
|
const res = extractVerboseDirective(body);
|
|
expect(res.hasDirective).toBe(false);
|
|
expect(res.cleaned).toBe(body);
|
|
});
|
|
|
|
it("ignores typoed /verioussmith", () => {
|
|
const body = "/verioussmith";
|
|
const res = extractVerboseDirective(body);
|
|
expect(res.hasDirective).toBe(false);
|
|
expect(res.cleaned).toBe(body.trim());
|
|
});
|
|
|
|
it("ignores think directive inside URL", () => {
|
|
const body = "see https://example.com/path/thinkstuff";
|
|
const res = extractThinkDirective(body);
|
|
expect(res.hasDirective).toBe(false);
|
|
});
|
|
|
|
it("matches verbose with leading space", () => {
|
|
const res = extractVerboseDirective(" please /verbose on now");
|
|
expect(res.hasDirective).toBe(true);
|
|
expect(res.verboseLevel).toBe("on");
|
|
});
|
|
|
|
it("matches think at start of line", () => {
|
|
const res = extractThinkDirective("/think:high run slow");
|
|
expect(res.hasDirective).toBe(true);
|
|
expect(res.thinkLevel).toBe("high");
|
|
});
|
|
|
|
it("applies inline think and still runs agent content", async () => {
|
|
await withTempHome(async (home) => {
|
|
vi.mocked(runEmbeddedPiAgent).mockResolvedValue({
|
|
payloads: [{ text: "done" }],
|
|
meta: {
|
|
durationMs: 5,
|
|
agentMeta: { sessionId: "s", provider: "p", model: "m" },
|
|
},
|
|
});
|
|
|
|
const res = await getReplyFromConfig(
|
|
{
|
|
Body: "please sync /think:high now",
|
|
From: "+1004",
|
|
To: "+2000",
|
|
},
|
|
{},
|
|
{
|
|
agent: {
|
|
provider: "anthropic",
|
|
model: "claude-opus-4-5",
|
|
workspace: path.join(home, "clawd"),
|
|
},
|
|
routing: {
|
|
allowFrom: ["*"],
|
|
},
|
|
session: { store: path.join(home, "sessions.json") },
|
|
},
|
|
);
|
|
|
|
const texts = (Array.isArray(res) ? res : [res])
|
|
.map((entry) => entry?.text)
|
|
.filter(Boolean);
|
|
expect(texts).toContain("done");
|
|
expect(runEmbeddedPiAgent).toHaveBeenCalledOnce();
|
|
});
|
|
});
|
|
|
|
it("acks verbose directive immediately with system marker", async () => {
|
|
await withTempHome(async (home) => {
|
|
vi.mocked(runEmbeddedPiAgent).mockReset();
|
|
|
|
const res = await getReplyFromConfig(
|
|
{ Body: "/verbose on", From: "+1222", To: "+1222" },
|
|
{},
|
|
{
|
|
agent: {
|
|
provider: "anthropic",
|
|
model: "claude-opus-4-5",
|
|
workspace: path.join(home, "clawd"),
|
|
},
|
|
session: { store: path.join(home, "sessions.json") },
|
|
},
|
|
);
|
|
|
|
const text = Array.isArray(res) ? res[0]?.text : res?.text;
|
|
expect(text).toMatch(/^⚙️ Verbose logging enabled\./);
|
|
expect(runEmbeddedPiAgent).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
it("updates tool verbose during an in-flight run (toggle on)", async () => {
|
|
await withTempHome(async (home) => {
|
|
const storePath = path.join(home, "sessions.json");
|
|
const ctx = { Body: "please do the thing", From: "+1004", To: "+2000" };
|
|
const sessionKey = resolveSessionKey(
|
|
"per-sender",
|
|
{ From: ctx.From, To: ctx.To, Body: ctx.Body },
|
|
"main",
|
|
);
|
|
|
|
vi.mocked(runEmbeddedPiAgent).mockImplementation(async (params) => {
|
|
const shouldEmit = params.shouldEmitToolResult;
|
|
expect(shouldEmit?.()).toBe(false);
|
|
const store = loadSessionStore(storePath);
|
|
const entry = store[sessionKey] ?? {
|
|
sessionId: "s",
|
|
updatedAt: Date.now(),
|
|
};
|
|
store[sessionKey] = {
|
|
...entry,
|
|
verboseLevel: "on",
|
|
updatedAt: Date.now(),
|
|
};
|
|
await saveSessionStore(storePath, store);
|
|
expect(shouldEmit?.()).toBe(true);
|
|
return {
|
|
payloads: [{ text: "done" }],
|
|
meta: {
|
|
durationMs: 5,
|
|
agentMeta: { sessionId: "s", provider: "p", model: "m" },
|
|
},
|
|
};
|
|
});
|
|
|
|
const res = await getReplyFromConfig(
|
|
ctx,
|
|
{},
|
|
{
|
|
agent: {
|
|
provider: "anthropic",
|
|
model: "claude-opus-4-5",
|
|
workspace: path.join(home, "clawd"),
|
|
},
|
|
routing: {
|
|
allowFrom: ["*"],
|
|
},
|
|
session: { store: storePath },
|
|
},
|
|
);
|
|
|
|
const texts = (Array.isArray(res) ? res : [res])
|
|
.map((entry) => entry?.text)
|
|
.filter(Boolean);
|
|
expect(texts).toContain("done");
|
|
expect(runEmbeddedPiAgent).toHaveBeenCalledOnce();
|
|
});
|
|
});
|
|
|
|
it("updates tool verbose during an in-flight run (toggle off)", async () => {
|
|
await withTempHome(async (home) => {
|
|
const storePath = path.join(home, "sessions.json");
|
|
const ctx = {
|
|
Body: "please do the thing /verbose on",
|
|
From: "+1004",
|
|
To: "+2000",
|
|
};
|
|
const sessionKey = resolveSessionKey(
|
|
"per-sender",
|
|
{ From: ctx.From, To: ctx.To, Body: ctx.Body },
|
|
"main",
|
|
);
|
|
|
|
vi.mocked(runEmbeddedPiAgent).mockImplementation(async (params) => {
|
|
const shouldEmit = params.shouldEmitToolResult;
|
|
expect(shouldEmit?.()).toBe(true);
|
|
const store = loadSessionStore(storePath);
|
|
const entry = store[sessionKey] ?? {
|
|
sessionId: "s",
|
|
updatedAt: Date.now(),
|
|
};
|
|
store[sessionKey] = {
|
|
...entry,
|
|
verboseLevel: "off",
|
|
updatedAt: Date.now(),
|
|
};
|
|
await saveSessionStore(storePath, store);
|
|
expect(shouldEmit?.()).toBe(false);
|
|
return {
|
|
payloads: [{ text: "done" }],
|
|
meta: {
|
|
durationMs: 5,
|
|
agentMeta: { sessionId: "s", provider: "p", model: "m" },
|
|
},
|
|
};
|
|
});
|
|
|
|
const res = await getReplyFromConfig(
|
|
ctx,
|
|
{},
|
|
{
|
|
agent: {
|
|
provider: "anthropic",
|
|
model: "claude-opus-4-5",
|
|
workspace: path.join(home, "clawd"),
|
|
},
|
|
routing: {
|
|
allowFrom: ["*"],
|
|
},
|
|
session: { store: storePath },
|
|
},
|
|
);
|
|
|
|
const texts = (Array.isArray(res) ? res : [res])
|
|
.map((entry) => entry?.text)
|
|
.filter(Boolean);
|
|
expect(texts).toContain("done");
|
|
expect(runEmbeddedPiAgent).toHaveBeenCalledOnce();
|
|
});
|
|
});
|
|
|
|
it("lists allowlisted models on /model", async () => {
|
|
await withTempHome(async (home) => {
|
|
vi.mocked(runEmbeddedPiAgent).mockReset();
|
|
const storePath = path.join(home, "sessions.json");
|
|
|
|
const res = await getReplyFromConfig(
|
|
{ Body: "/model", From: "+1222", To: "+1222" },
|
|
{},
|
|
{
|
|
agent: {
|
|
provider: "anthropic",
|
|
model: "claude-opus-4-5",
|
|
workspace: path.join(home, "clawd"),
|
|
allowedModels: ["anthropic/claude-opus-4-5", "openai/gpt-4.1-mini"],
|
|
},
|
|
session: { store: storePath },
|
|
},
|
|
);
|
|
|
|
const text = Array.isArray(res) ? res[0]?.text : res?.text;
|
|
expect(text).toContain("anthropic/claude-opus-4-5");
|
|
expect(text).toContain("openai/gpt-4.1-mini");
|
|
expect(text).not.toContain("claude-sonnet-4-1");
|
|
expect(runEmbeddedPiAgent).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
it("sets model override on /model directive", async () => {
|
|
await withTempHome(async (home) => {
|
|
vi.mocked(runEmbeddedPiAgent).mockReset();
|
|
const storePath = path.join(home, "sessions.json");
|
|
|
|
const res = await getReplyFromConfig(
|
|
{ Body: "/model openai/gpt-4.1-mini", From: "+1222", To: "+1222" },
|
|
{},
|
|
{
|
|
agent: {
|
|
provider: "anthropic",
|
|
model: "claude-opus-4-5",
|
|
workspace: path.join(home, "clawd"),
|
|
allowedModels: ["openai/gpt-4.1-mini"],
|
|
},
|
|
session: { store: storePath },
|
|
},
|
|
);
|
|
|
|
const text = Array.isArray(res) ? res[0]?.text : res?.text;
|
|
expect(text).toContain("Model set to openai/gpt-4.1-mini");
|
|
const store = loadSessionStore(storePath);
|
|
const entry = store.main;
|
|
expect(entry.modelOverride).toBe("gpt-4.1-mini");
|
|
expect(entry.providerOverride).toBe("openai");
|
|
expect(runEmbeddedPiAgent).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
it("uses model override for inline /model", async () => {
|
|
await withTempHome(async (home) => {
|
|
const storePath = path.join(home, "sessions.json");
|
|
vi.mocked(runEmbeddedPiAgent).mockResolvedValue({
|
|
payloads: [{ text: "done" }],
|
|
meta: {
|
|
durationMs: 5,
|
|
agentMeta: { sessionId: "s", provider: "p", model: "m" },
|
|
},
|
|
});
|
|
|
|
const res = await getReplyFromConfig(
|
|
{
|
|
Body: "please sync /model openai/gpt-4.1-mini now",
|
|
From: "+1004",
|
|
To: "+2000",
|
|
},
|
|
{},
|
|
{
|
|
agent: {
|
|
provider: "anthropic",
|
|
model: "claude-opus-4-5",
|
|
workspace: path.join(home, "clawd"),
|
|
allowedModels: ["openai/gpt-4.1-mini"],
|
|
},
|
|
routing: {
|
|
allowFrom: ["*"],
|
|
},
|
|
session: { store: storePath },
|
|
},
|
|
);
|
|
|
|
const texts = (Array.isArray(res) ? res : [res])
|
|
.map((entry) => entry?.text)
|
|
.filter(Boolean);
|
|
expect(texts).toContain("done");
|
|
expect(runEmbeddedPiAgent).toHaveBeenCalledOnce();
|
|
const call = vi.mocked(runEmbeddedPiAgent).mock.calls[0]?.[0];
|
|
expect(call?.provider).toBe("openai");
|
|
expect(call?.model).toBe("gpt-4.1-mini");
|
|
});
|
|
});
|
|
});
|