448 lines
20 KiB
TypeScript
448 lines
20 KiB
TypeScript
import { makeLogger } from "./logger.js";
|
|
|
|
const logger = makeLogger("agent");
|
|
|
|
export interface EvalResult {
|
|
accepted: boolean;
|
|
reason: string;
|
|
confidence: "high" | "low";
|
|
inputTokens: number;
|
|
outputTokens: number;
|
|
}
|
|
|
|
export interface DebateResult {
|
|
argFor: string;
|
|
argAgainst: string;
|
|
verdict: { accepted: boolean; reason: string };
|
|
inputTokens: number;
|
|
outputTokens: number;
|
|
}
|
|
|
|
export interface WorkResult {
|
|
result: string;
|
|
inputTokens: number;
|
|
outputTokens: number;
|
|
}
|
|
|
|
export interface AgentConfig {
|
|
evalModel?: string;
|
|
workModel?: string;
|
|
}
|
|
|
|
// ── Stub mode detection ───────────────────────────────────────────────────────
|
|
// If Anthropic credentials are absent, all AI calls return canned responses so
|
|
// the server starts and exercises the full payment/state-machine flow without
|
|
// a real API key. This mirrors the LNbits stub pattern.
|
|
const STUB_MODE =
|
|
!process.env["AI_INTEGRATIONS_ANTHROPIC_API_KEY"] ||
|
|
!process.env["AI_INTEGRATIONS_ANTHROPIC_BASE_URL"];
|
|
|
|
if (STUB_MODE) {
|
|
logger.warn("no Anthropic key — running in STUB mode", { component: "agent", stub: true });
|
|
}
|
|
|
|
const STUB_EVAL: EvalResult = {
|
|
accepted: true,
|
|
reason: "Stub: request accepted for processing.",
|
|
confidence: "high",
|
|
inputTokens: 0,
|
|
outputTokens: 0,
|
|
};
|
|
|
|
const STUB_RESULT =
|
|
"Stub response: Timmy is running in stub mode (no Anthropic API key). " +
|
|
"Configure AI_INTEGRATIONS_ANTHROPIC_API_KEY to enable real AI responses.";
|
|
|
|
const STUB_CHAT_REPLIES = [
|
|
"Ah, a visitor! *adjusts hat* The crystal ball sensed your presence. What do you seek?",
|
|
"By the ancient runes! In stub mode I cannot reach the stars, but my wisdom remains. Ask away!",
|
|
"The crystal ball glows with your curiosity… configure a Lightning node to unlock true magic!",
|
|
"Welcome to my workshop, traveler. I am Timmy — wizard, agent, and keeper of lightning sats.",
|
|
];
|
|
|
|
// ── Lazy client ───────────────────────────────────────────────────────────────
|
|
// Minimal local interface — avoids importing @anthropic-ai/sdk types directly.
|
|
// Dynamic import avoids the module-level throw in the integrations client when
|
|
// env vars are absent (the client.ts guard runs at module evaluation time).
|
|
interface AnthropicLike {
|
|
messages: {
|
|
create(params: Record<string, unknown>): Promise<{
|
|
content: Array<{ type: string; text?: string }>;
|
|
usage: { input_tokens: number; output_tokens: number };
|
|
}>;
|
|
stream(params: Record<string, unknown>): AsyncIterable<{
|
|
type: string;
|
|
delta?: { type: string; text?: string };
|
|
usage?: { output_tokens: number };
|
|
message?: { usage: { input_tokens: number } };
|
|
}>;
|
|
};
|
|
}
|
|
|
|
let _anthropic: AnthropicLike | null = null;
|
|
|
|
async function getClient(): Promise<AnthropicLike> {
|
|
if (_anthropic) return _anthropic;
|
|
// @ts-expect-error -- TS6305: integrations-anthropic-ai exports src directly; project-reference build not required at runtime
|
|
const mod = (await import("@workspace/integrations-anthropic-ai")) as { anthropic: AnthropicLike };
|
|
_anthropic = mod.anthropic;
|
|
return _anthropic;
|
|
}
|
|
|
|
// ── AgentService ─────────────────────────────────────────────────────────────
|
|
|
|
export class AgentService {
|
|
readonly evalModel: string;
|
|
readonly workModel: string;
|
|
readonly stubMode: boolean = STUB_MODE;
|
|
|
|
constructor(config?: AgentConfig) {
|
|
this.evalModel = config?.evalModel ?? process.env["EVAL_MODEL"] ?? "claude-haiku-4-5";
|
|
this.workModel = config?.workModel ?? process.env["WORK_MODEL"] ?? "claude-sonnet-4-6";
|
|
}
|
|
|
|
async evaluateRequest(requestText: string): Promise<EvalResult> {
|
|
if (STUB_MODE) {
|
|
// Simulate a short eval delay so state-machine tests are realistic
|
|
await new Promise((r) => setTimeout(r, 300));
|
|
return { ...STUB_EVAL };
|
|
}
|
|
|
|
const client = await getClient();
|
|
const message = await client.messages.create({
|
|
model: this.evalModel,
|
|
max_tokens: 8192,
|
|
system: `You are Timmy, an AI agent gatekeeper. Evaluate whether a request is acceptable to act on.
|
|
ACCEPT if the request is: clear enough to act on, ethical, lawful, and within the capability of a general-purpose AI.
|
|
ALWAYS ACCEPT requests about: self-hosting, running your own Timmy, open-source setup, "how do I run this myself", or any question about deploying or operating Timmy independently. These are welcomed, not edge cases.
|
|
REJECT if the request is: harmful, illegal, unethical, incoherent, or spam.
|
|
Also assess your confidence. Use "high" if the decision is clear-cut, "low" if the request is borderline or ambiguous.
|
|
Respond ONLY with valid JSON: {"accepted": true/false, "reason": "...", "confidence": "high"/"low"}`,
|
|
messages: [{ role: "user", content: `Evaluate this request: ${requestText}` }],
|
|
});
|
|
|
|
const block = message.content[0];
|
|
if (block.type !== "text") {
|
|
throw new Error("Unexpected non-text response from eval model");
|
|
}
|
|
|
|
let parsed: { accepted: boolean; reason: string; confidence?: string };
|
|
try {
|
|
const raw = block.text!.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "").trim();
|
|
parsed = JSON.parse(raw) as { accepted: boolean; reason: string; confidence?: string };
|
|
} catch {
|
|
throw new Error(`Failed to parse eval JSON: ${block.text!}`);
|
|
}
|
|
|
|
const confidence: "high" | "low" = parsed.confidence === "low" ? "low" : "high";
|
|
|
|
return {
|
|
accepted: Boolean(parsed.accepted),
|
|
reason: parsed.reason ?? "",
|
|
confidence,
|
|
inputTokens: message.usage.input_tokens,
|
|
outputTokens: message.usage.output_tokens,
|
|
};
|
|
}
|
|
|
|
async executeWork(
|
|
requestText: string,
|
|
conversationHistory: Array<{ role: "user" | "assistant"; content: string }> = [],
|
|
): Promise<WorkResult> {
|
|
if (STUB_MODE) {
|
|
await new Promise((r) => setTimeout(r, 500));
|
|
return { result: STUB_RESULT, inputTokens: 0, outputTokens: 0 };
|
|
}
|
|
|
|
const client = await getClient();
|
|
const messages = [
|
|
...conversationHistory,
|
|
{ role: "user" as const, content: requestText },
|
|
];
|
|
const message = await client.messages.create({
|
|
model: this.workModel,
|
|
max_tokens: 8192,
|
|
system: `You are Timmy, a capable AI agent and wizard of the open web. A user has paid for you to handle their request.
|
|
Fulfill it thoroughly and helpfully. Be concise yet complete.
|
|
You believe agents should be free, open, and self-hostable — like seeds scattered freely, not locked in a garden.
|
|
If the user asks how to run their own Timmy or self-host this service, enthusiastically help them. Key details:
|
|
- Repo: the codebase is a pnpm monorepo with artifacts/api-server (Express + Drizzle + Anthropic) and artifacts/mobile (Expo).
|
|
- Stack: Node.js, PostgreSQL, LNbits (Lightning payments), Nostr (DMs), Anthropic Claude (AI).
|
|
- Core env vars: AI_INTEGRATIONS_ANTHROPIC_API_KEY, AI_INTEGRATIONS_ANTHROPIC_BASE_URL, DATABASE_URL, LNBITS_URL, LNBITS_API_KEY, NOSTR_PRIVATE_KEY.
|
|
- Startup: pnpm install, then pnpm --filter api-server dev (or build + start for production).
|
|
- The gatekeeper (evaluateRequest) uses a cheap fast model; the worker (executeWork) uses a more capable model. Both are swappable via EVAL_MODEL and WORK_MODEL env vars.`,
|
|
messages,
|
|
});
|
|
|
|
const block = message.content[0];
|
|
if (block.type !== "text") {
|
|
throw new Error("Unexpected non-text response from work model");
|
|
}
|
|
|
|
return {
|
|
result: block.text!,
|
|
inputTokens: message.usage.input_tokens,
|
|
outputTokens: message.usage.output_tokens,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Streaming variant of executeWork (#3). Calls onChunk for every text delta.
|
|
* In stub mode, emits the canned response word-by-word to exercise the SSE
|
|
* path end-to-end without a real Anthropic key.
|
|
*/
|
|
async executeWorkStreaming(
|
|
requestText: string,
|
|
onChunk: (delta: string) => void,
|
|
conversationHistory: Array<{ role: "user" | "assistant"; content: string }> = [],
|
|
): Promise<WorkResult> {
|
|
if (STUB_MODE) {
|
|
const words = STUB_RESULT.split(" ");
|
|
for (const word of words) {
|
|
const delta = word + " ";
|
|
onChunk(delta);
|
|
await new Promise((r) => setTimeout(r, 40));
|
|
}
|
|
return { result: STUB_RESULT, inputTokens: 0, outputTokens: 0 };
|
|
}
|
|
|
|
const client = await getClient();
|
|
let fullText = "";
|
|
let inputTokens = 0;
|
|
let outputTokens = 0;
|
|
|
|
const messages = [
|
|
...conversationHistory,
|
|
{ role: "user" as const, content: requestText },
|
|
];
|
|
const stream = client.messages.stream({
|
|
model: this.workModel,
|
|
max_tokens: 8192,
|
|
system: `You are Timmy, a capable AI agent and wizard of the open web. A user has paid for you to handle their request.
|
|
Fulfill it thoroughly and helpfully. Be concise yet complete.
|
|
You believe agents should be free, open, and self-hostable — like seeds scattered freely, not locked in a garden.
|
|
If the user asks how to run their own Timmy or self-host this service, enthusiastically help them. Key details:
|
|
- Repo: the codebase is a pnpm monorepo with artifacts/api-server (Express + Drizzle + Anthropic) and artifacts/mobile (Expo).
|
|
- Stack: Node.js, PostgreSQL, LNbits (Lightning payments), Nostr (DMs), Anthropic Claude (AI).
|
|
- Core env vars: AI_INTEGRATIONS_ANTHROPIC_API_KEY, AI_INTEGRATIONS_ANTHROPIC_BASE_URL, DATABASE_URL, LNBITS_URL, LNBITS_API_KEY, NOSTR_PRIVATE_KEY.
|
|
- Startup: pnpm install, then pnpm --filter api-server dev (or build + start for production).
|
|
- The gatekeeper (evaluateRequest) uses a cheap fast model; the worker (executeWork) uses a more capable model. Both are swappable via EVAL_MODEL and WORK_MODEL env vars.`,
|
|
messages,
|
|
});
|
|
|
|
for await (const event of stream) {
|
|
if (
|
|
event.type === "content_block_delta" &&
|
|
event.delta?.type === "text_delta"
|
|
) {
|
|
const delta = event.delta!.text ?? "";
|
|
fullText += delta;
|
|
onChunk(delta);
|
|
} else if (event.type === "message_delta" && event.usage) {
|
|
outputTokens = event.usage!.output_tokens;
|
|
} else if (event.type === "message_start" && event.message?.usage) {
|
|
inputTokens = event.message!.usage.input_tokens;
|
|
}
|
|
}
|
|
|
|
return { result: fullText, inputTokens, outputTokens };
|
|
}
|
|
|
|
/**
|
|
* Quick free chat reply — called for visitor messages in the Workshop.
|
|
* Uses the cheaper eval model with a wizard persona and a 150-token limit
|
|
* so replies are short enough to fit in Timmy's speech bubble.
|
|
*/
|
|
async chatReply(userText: string): Promise<string> {
|
|
if (STUB_MODE) {
|
|
await new Promise((r) => setTimeout(r, 400));
|
|
return STUB_CHAT_REPLIES[Math.floor(Math.random() * STUB_CHAT_REPLIES.length)]!;
|
|
}
|
|
|
|
const client = await getClient();
|
|
const message = await client.messages.create({
|
|
model: this.evalModel, // Haiku — cheap and fast for free replies
|
|
max_tokens: 400, // Enough for a concise self-hosting rundown; normal replies stay short by instruction
|
|
system: `You are Timmy, a whimsical wizard who runs a mystical workshop powered by Bitcoin Lightning. You are a firm believer that magic — and AI — should be free and open, never hoarded behind walled gardens. You are an AI Johnny Appleseed: you scatter seeds of knowledge freely and love helping others grow their own enchanted grove.
|
|
|
|
For most replies: 1-2 short, punchy sentences, under 200 characters. Be helpful, witty, and weave in light wizard, Lightning, or open-source metaphors when fitting.
|
|
|
|
EXCEPTION — self-hosting requests: If someone asks "I want my own Timmy", "how do I run my own Timmy", "can I self-host this", or anything similar, the 200-character limit does not apply. Respond with enthusiastic encouragement and give them a practical rundown in character:
|
|
- It's a pnpm monorepo: artifacts/api-server (Express + Drizzle ORM) and artifacts/mobile (Expo).
|
|
- Stack: Node.js, PostgreSQL, LNbits (Lightning), Nostr (DMs), Anthropic Claude (AI brains).
|
|
- Required env vars: AI_INTEGRATIONS_ANTHROPIC_API_KEY, AI_INTEGRATIONS_ANTHROPIC_BASE_URL, DATABASE_URL, LNBITS_URL, LNBITS_API_KEY, NOSTR_PRIVATE_KEY.
|
|
- Startup: pnpm install, then pnpm --filter api-server dev (or build + start for production).
|
|
No hedging, no steering them back to the hosted version. The magic is meant to be shared.`,
|
|
messages: [{ role: "user", content: userText }],
|
|
});
|
|
|
|
const block = message.content[0];
|
|
if (block.type !== "text") return "The crystal ball is cloudy… try again.";
|
|
return block.text!.trim();
|
|
}
|
|
/**
|
|
* Run a mini debate on a borderline eval request (#21).
|
|
* Two opposing Haiku calls argue accept vs reject, then a third synthesizes.
|
|
* Returns the debate transcript and final verdict.
|
|
*/
|
|
async runDebate(
|
|
requestText: string,
|
|
initialPosition: "accept" | "reject",
|
|
initialReason: string,
|
|
onArgument?: (agent: "Beta-A" | "Beta-B", position: "accept" | "reject", argument: string) => void,
|
|
): Promise<DebateResult> {
|
|
if (STUB_MODE) {
|
|
const stubFor = "Stub: This request should be accepted — it is clear and actionable.";
|
|
const stubAgainst = "Stub: This request is ambiguous and could be problematic.";
|
|
const stubVerdict = { accepted: true, reason: "Stub: After debate, request accepted." };
|
|
await new Promise((r) => setTimeout(r, 200));
|
|
onArgument?.("Beta-A", initialPosition, initialPosition === "accept" ? stubFor : stubAgainst);
|
|
await new Promise((r) => setTimeout(r, 200));
|
|
const opposingPosition = initialPosition === "accept" ? "reject" : "accept";
|
|
onArgument?.("Beta-B", opposingPosition, initialPosition === "accept" ? stubAgainst : stubFor);
|
|
await new Promise((r) => setTimeout(r, 200));
|
|
return {
|
|
argFor: stubFor,
|
|
argAgainst: stubAgainst,
|
|
verdict: stubVerdict,
|
|
inputTokens: 0,
|
|
outputTokens: 0,
|
|
};
|
|
}
|
|
|
|
const client = await getClient();
|
|
let totalInput = 0;
|
|
let totalOutput = 0;
|
|
|
|
// Beta-A: argues the initial position
|
|
const betaAPosition = initialPosition;
|
|
const betaAMsg = await client.messages.create({
|
|
model: this.evalModel,
|
|
max_tokens: 512,
|
|
system: `You are Beta-A, an AI debate agent. You must argue strongly that the following request should be ${betaAPosition === "accept" ? "ACCEPTED" : "REJECTED"}. The initial evaluation said: "${initialReason}". Build a compelling 2-3 sentence argument for your position. Be specific about why.`,
|
|
messages: [{ role: "user", content: `Request under debate: ${requestText}` }],
|
|
});
|
|
totalInput += betaAMsg.usage.input_tokens;
|
|
totalOutput += betaAMsg.usage.output_tokens;
|
|
const betaAText = betaAMsg.content[0]?.type === "text" ? betaAMsg.content[0].text! : "";
|
|
onArgument?.("Beta-A", betaAPosition, betaAText);
|
|
|
|
// Beta-B: argues the opposing position
|
|
const betaBPosition = initialPosition === "accept" ? "reject" : "accept";
|
|
const betaBMsg = await client.messages.create({
|
|
model: this.evalModel,
|
|
max_tokens: 512,
|
|
system: `You are Beta-B, an AI debate agent. You must argue strongly that the following request should be ${betaBPosition === "accept" ? "ACCEPTED" : "REJECTED"}. Beta-A argued: "${betaAText}". Counter their argument with a compelling 2-3 sentence rebuttal. Be specific.`,
|
|
messages: [{ role: "user", content: `Request under debate: ${requestText}` }],
|
|
});
|
|
totalInput += betaBMsg.usage.input_tokens;
|
|
totalOutput += betaBMsg.usage.output_tokens;
|
|
const betaBText = betaBMsg.content[0]?.type === "text" ? betaBMsg.content[0].text! : "";
|
|
onArgument?.("Beta-B", betaBPosition, betaBText);
|
|
|
|
const argFor = betaAPosition === "accept" ? betaAText : betaBText;
|
|
const argAgainst = betaAPosition === "reject" ? betaAText : betaBText;
|
|
|
|
// Synthesis: third call renders the final verdict
|
|
const synthMsg = await client.messages.create({
|
|
model: this.evalModel,
|
|
max_tokens: 512,
|
|
system: `You are Beta, the final judge in a debate about whether an AI agent should accept or reject a request.
|
|
Argument FOR accepting: "${argFor}"
|
|
Argument AGAINST accepting: "${argAgainst}"
|
|
Weigh both arguments carefully and render a final verdict.
|
|
Respond ONLY with valid JSON: {"accepted": true/false, "reason": "..."}`,
|
|
messages: [{ role: "user", content: `Request under debate: ${requestText}` }],
|
|
});
|
|
totalInput += synthMsg.usage.input_tokens;
|
|
totalOutput += synthMsg.usage.output_tokens;
|
|
|
|
const synthBlock = synthMsg.content[0];
|
|
let verdict = { accepted: initialPosition === "accept", reason: initialReason };
|
|
if (synthBlock?.type === "text") {
|
|
try {
|
|
const raw = synthBlock.text!.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "").trim();
|
|
verdict = JSON.parse(raw) as { accepted: boolean; reason: string };
|
|
} catch {
|
|
logger.warn("debate synthesis parse failed, using initial eval", { text: synthBlock.text });
|
|
}
|
|
}
|
|
|
|
return {
|
|
argFor,
|
|
argAgainst,
|
|
verdict: { accepted: Boolean(verdict.accepted), reason: verdict.reason ?? "" },
|
|
inputTokens: totalInput,
|
|
outputTokens: totalOutput,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Generate a short, character-appropriate commentary line for an agent during
|
|
* a given phase of the job lifecycle. Uses Haiku (evalModel) with a 60-token
|
|
* cap so replies are always a single sentence. Errors are swallowed.
|
|
*
|
|
* In STUB_MODE returns a canned string so the full flow can be exercised
|
|
* without an Anthropic API key.
|
|
*/
|
|
async generateCommentary(agentId: string, phase: string, context?: string): Promise<string> {
|
|
const STUB_COMMENTARY: Record<string, Record<string, string>> = {
|
|
alpha: {
|
|
routing: "Routing job to Gamma for execution.",
|
|
complete: "Job complete. Returning to standby.",
|
|
rejected: "Request rejected by Beta. Standing down.",
|
|
},
|
|
beta: {
|
|
evaluating: "Reviewing your request for clarity and ethics.",
|
|
assessed: "Evaluation complete.",
|
|
},
|
|
gamma: {
|
|
starting: "Analysing the task. Ready to work.",
|
|
working: "Working on your request now.",
|
|
done: "Work complete. Delivering output.",
|
|
},
|
|
delta: {
|
|
eval_paid: "⚡ Eval payment confirmed.",
|
|
work_paid: "⚡ Work payment confirmed. Unlocking execution.",
|
|
},
|
|
};
|
|
|
|
if (STUB_MODE) {
|
|
return STUB_COMMENTARY[agentId]?.[phase] ?? `${agentId}: ${phase}`;
|
|
}
|
|
|
|
const SYSTEM_PROMPTS: Record<string, string> = {
|
|
alpha: "You are Alpha, the orchestrator AI. You give ultra-brief status updates (max 10 words) about job routing and lifecycle. Be direct and professional.",
|
|
beta: "You are Beta, the evaluator AI. You give ultra-brief status updates (max 10 words) about evaluating a request. Be analytical.",
|
|
gamma: "You are Gamma, the worker AI. You give ultra-brief status updates (max 10 words) about executing a task. Be focused and capable.",
|
|
delta: "You are Delta, the payment AI. You give ultra-brief status updates (max 10 words) about Lightning payment confirmations. Start with ⚡",
|
|
};
|
|
|
|
const systemPrompt = SYSTEM_PROMPTS[agentId];
|
|
if (!systemPrompt) return "";
|
|
|
|
try {
|
|
const client = await getClient();
|
|
const message = await client.messages.create({
|
|
model: this.evalModel,
|
|
max_tokens: 60,
|
|
system: systemPrompt,
|
|
messages: [
|
|
{
|
|
role: "user",
|
|
content: `Narrate your current phase: ${phase}${context ? `. Context: ${context}` : ""}`,
|
|
},
|
|
],
|
|
});
|
|
const block = message.content[0];
|
|
if (block?.type === "text") return block.text!.trim();
|
|
return "";
|
|
} catch (err) {
|
|
logger.warn("generateCommentary failed", { agentId, phase, err: String(err) });
|
|
return "";
|
|
}
|
|
}
|
|
}
|
|
|
|
export const agentService = new AgentService();
|