@sourcepress/ai 0.1.0

package/src/__tests__/budget.test.ts

@@ -0,0 +1,103 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { BudgetTracker } from "../budget.js";
+
+describe("BudgetTracker", () => {
+	let tracker: BudgetTracker;
+	beforeEach(() => {
+		tracker = new BudgetTracker({ daily_limit_usd: 5.0, warn_at_usd: 3.0 });
+	});
+
+	it("starts with zero spent", () => {
+		const status = tracker.getStatus();
+		expect(status.spent_today_usd).toBe(0);
+		expect(status.remaining_usd).toBe(5.0);
+		expect(status.is_over_limit).toBe(false);
+		expect(status.is_warned).toBe(false);
+	});
+
+	it("tracks token usage", () => {
+		tracker.record({
+			input_tokens: 1000,
+			output_tokens: 500,
+			estimated_cost_usd: 0.01,
+			function_name: "classify",
+			timestamp: new Date().toISOString(),
+		});
+		const status = tracker.getStatus();
+		expect(status.spent_today_usd).toBe(0.01);
+		expect(status.remaining_usd).toBe(4.99);
+	});
+
+	it("warns when approaching limit", () => {
+		tracker.record({
+			input_tokens: 100000,
+			output_tokens: 50000,
+			estimated_cost_usd: 3.5,
+			function_name: "extract",
+			timestamp: new Date().toISOString(),
+		});
+		const status = tracker.getStatus();
+		expect(status.is_warned).toBe(true);
+		expect(status.is_over_limit).toBe(false);
+	});
+
+	it("detects over-limit", () => {
+		tracker.record({
+			input_tokens: 200000,
+			output_tokens: 100000,
+			estimated_cost_usd: 5.5,
+			function_name: "judge",
+			timestamp: new Date().toISOString(),
+		});
+		expect(tracker.getStatus().is_over_limit).toBe(true);
+	});
+
+	it("can check if operation is allowed", () => {
+		expect(tracker.canSpend(4.0)).toBe(true);
+		expect(tracker.canSpend(6.0)).toBe(false);
+		tracker.record({
+			input_tokens: 100000,
+			output_tokens: 50000,
+			estimated_cost_usd: 4.0,
+			function_name: "score",
+			timestamp: new Date().toISOString(),
+		});
+		expect(tracker.canSpend(0.5)).toBe(true);
+		expect(tracker.canSpend(2.0)).toBe(false);
+	});
+
+	it("returns usage history", () => {
+		tracker.record({
+			input_tokens: 1000,
+			output_tokens: 500,
+			estimated_cost_usd: 0.01,
+			function_name: "classify",
+			timestamp: new Date().toISOString(),
+		});
+		tracker.record({
+			input_tokens: 2000,
+			output_tokens: 1000,
+			estimated_cost_usd: 0.02,
+			function_name: "extract",
+			timestamp: new Date().toISOString(),
+		});
+		const history = tracker.getHistory();
+		expect(history).toHaveLength(2);
+		expect(history[0].function_name).toBe("classify");
+		expect(history[1].function_name).toBe("extract");
+	});
+
+	it("resets daily spending", () => {
+		tracker.record({
+			input_tokens: 100000,
+			output_tokens: 50000,
+			estimated_cost_usd: 3.0,
+			function_name: "judge",
+			timestamp: new Date().toISOString(),
+		});
+		tracker.resetDaily();
+		const status = tracker.getStatus();
+		expect(status.spent_today_usd).toBe(0);
+		expect(status.remaining_usd).toBe(5.0);
+	});
+});

package/src/__tests__/classify.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it, vi } from "vitest";
+import { BudgetTracker } from "../budget.js";
+import { classify } from "../functions/classify.js";
+import type { ResolvedProvider } from "../provider.js";
+
+vi.mock("ai", () => ({ generateObject: vi.fn() }));
+import { generateObject } from "ai";
+
+const mockProvider: ResolvedProvider = {
+	provider: "anthropic",
+	model: "claude-sonnet-4-5-20250514",
+};
+
+describe("classify", () => {
+	it("classifies structured text correctly", async () => {
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: {
+				quality: "structured",
+				quality_score: 8,
+				type: "project-notes",
+				reasoning: "Well-organized document with clear sections",
+			},
+			usage: { promptTokens: 500, completionTokens: 100 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+		const budget = new BudgetTracker({ daily_limit_usd: 5.0 });
+		const result = await classify(
+			{ text: "Meeting with Acme Corp 2026-04-01. Discussed Next.js migration timeline." },
+			mockProvider,
+			budget,
+		);
+		expect(result.quality).toBe("structured");
+		expect(result.quality_score).toBe(8);
+		expect(result.type).toBe("project-notes");
+		expect(result.usage.function_name).toBe("classify");
+	});
+
+	it("classifies draft-quality text", async () => {
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: { quality: "draft", quality_score: 5, type: "brainstorm", reasoning: "Rough notes" },
+			usage: { promptTokens: 300, completionTokens: 80 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+		const budget = new BudgetTracker({ daily_limit_usd: 5.0 });
+		const result = await classify(
+			{ text: "maybe we should try... react? or vue?" },
+			mockProvider,
+			budget,
+		);
+		expect(result.quality).toBe("draft");
+		expect(result.quality_score).toBeLessThanOrEqual(6);
+	});
+
+	it("respects available_types constraint", async () => {
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: {
+				quality: "structured",
+				quality_score: 7,
+				type: "meeting-notes",
+				reasoning: "Typed as meeting-notes",
+			},
+			usage: { promptTokens: 400, completionTokens: 90 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+		const budget = new BudgetTracker({ daily_limit_usd: 5.0 });
+		const result = await classify(
+			{
+				text: "Team standup 2026-04-04",
+				available_types: ["meeting-notes", "project-notes", "transcript"],
+			},
+			mockProvider,
+			budget,
+		);
+		expect(result.type).toBe("meeting-notes");
+	});
+
+	it("records budget usage", async () => {
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: { quality: "structured", quality_score: 8, type: "notes", reasoning: "OK" },
+			usage: { promptTokens: 500, completionTokens: 100 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+		const budget = new BudgetTracker({ daily_limit_usd: 5.0 });
+		await classify({ text: "test" }, mockProvider, budget);
+		const history = budget.getHistory();
+		expect(history).toHaveLength(1);
+		expect(history[0].function_name).toBe("classify");
+		expect(history[0].input_tokens).toBe(500);
+	});
+});

package/src/__tests__/eval-runner.test.ts

@@ -0,0 +1,199 @@
+import { describe, expect, it, vi } from "vitest";
+import { BudgetTracker } from "../budget.js";
+import { EvalRunner } from "../eval/runner.js";
+import type { ResolvedProvider } from "../provider.js";
+
+vi.mock("ai", () => ({ generateObject: vi.fn() }));
+import { generateObject } from "ai";
+
+const mockProvider: ResolvedProvider = {
+	provider: "anthropic",
+	model: "claude-sonnet-4-5-20250514",
+};
+
+const baseConfig = {
+	content_type: "case-study",
+	knowledge_context:
+		"Acme Corp migrated 12 microservices to Next.js in 8 weeks. Load time improved by 40%.",
+	gold_standard:
+		"# Perfect Case Study\n\nDetailed migration with 12 services, 8 weeks, 40% improvement.",
+	judge_prompt: "Score this content 0-100 against the gold standard.",
+	generation_prompt: "Write a compelling case study.",
+	threshold: 70,
+	max_iterations: 3,
+};
+
+describe("EvalRunner", () => {
+	it("keeps content when score meets threshold on first iteration", async () => {
+		// Generate
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: {
+				frontmatter: { title: "Acme Corp Case Study" },
+				body: "# Acme Corp\n\nWe migrated 12 services in 8 weeks, improving load time by 40%.",
+			},
+			usage: { promptTokens: 3000, completionTokens: 500 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+
+		// Judge — score above threshold
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: { score: 85, reasoning: "Excellent match. Specific metrics included." },
+			usage: { promptTokens: 2000, completionTokens: 200 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+
+		const budget = new BudgetTracker({ daily_limit_usd: 10.0 });
+		const runner = new EvalRunner(mockProvider, budget);
+		const result = await runner.run(baseConfig);
+
+		expect(result.final_status).toBe("keep");
+		expect(result.final_score).toBe(85);
+		expect(result.iterations).toHaveLength(1);
+		expect(result.final_content).toBeTruthy();
+		expect(result.prompt_improved).toBe(false);
+	});
+
+	it("improves prompt and retries when score is below threshold", async () => {
+		// Iteration 1: Generate
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: {
+				frontmatter: { title: "Acme" },
+				body: "We helped Acme.",
+			},
+			usage: { promptTokens: 2000, completionTokens: 200 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+
+		// Iteration 1: Judge — below threshold
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: { score: 40, reasoning: "Too generic, no metrics." },
+			usage: { promptTokens: 1500, completionTokens: 150 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+
+		// Iteration 1: Improve prompt
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: {
+				improved_prompt: "Write a case study with specific metrics and client quotes.",
+				changes_summary: "Added metrics requirement.",
+			},
+			usage: { promptTokens: 1000, completionTokens: 200 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+
+		// Iteration 2: Generate with improved prompt
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: {
+				frontmatter: { title: "Acme Corp — Migration to Next.js" },
+				body: "# Acme Corp\n\n12 services migrated in 8 weeks. 40% load time improvement.",
+			},
+			usage: { promptTokens: 2500, completionTokens: 400 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+
+		// Iteration 2: Judge — above threshold
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: {
+				score: 78,
+				reasoning: "Good metrics, clear structure. Matches gold standard well.",
+			},
+			usage: { promptTokens: 2000, completionTokens: 180 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+
+		const budget = new BudgetTracker({ daily_limit_usd: 10.0 });
+		const runner = new EvalRunner(mockProvider, budget);
+		const result = await runner.run(baseConfig);
+
+		expect(result.final_status).toBe("keep");
+		expect(result.final_score).toBe(78);
+		expect(result.iterations).toHaveLength(2);
+		expect(result.prompt_improved).toBe(true);
+		expect(result.final_prompt).toContain("metrics");
+	});
+
+	it("discards after max iterations if threshold never met", async () => {
+		// Mock 3 iterations, all below threshold
+		for (let i = 0; i < 3; i++) {
+			// Generate
+			vi.mocked(generateObject).mockResolvedValueOnce({
+				object: {
+					frontmatter: { title: "Attempt" },
+					body: "Generic content.",
+				},
+				usage: { promptTokens: 2000, completionTokens: 200 },
+				// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+			} as any);
+
+			// Judge — below threshold
+			vi.mocked(generateObject).mockResolvedValueOnce({
+				object: { score: 30 + i * 10, reasoning: "Still not good enough." },
+				usage: { promptTokens: 1500, completionTokens: 150 },
+				// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+			} as any);
+
+			// Improve prompt (not on last iteration)
+			if (i < 2) {
+				vi.mocked(generateObject).mockResolvedValueOnce({
+					object: {
+						improved_prompt: `Improved prompt v${i + 2}.`,
+						changes_summary: "Tweaked instructions.",
+					},
+					usage: { promptTokens: 1000, completionTokens: 200 },
+					// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+				} as any);
+			}
+		}
+
+		const budget = new BudgetTracker({ daily_limit_usd: 10.0 });
+		const runner = new EvalRunner(mockProvider, budget);
+		const result = await runner.run(baseConfig);
+
+		expect(result.final_status).toBe("discard");
+		expect(result.iterations).toHaveLength(3);
+		expect(result.final_content).toBeUndefined();
+	});
+
+	it("judgeOnly scores existing content without loop", async () => {
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: { score: 72, reasoning: "Decent quality, matches intent." },
+			usage: { promptTokens: 1500, completionTokens: 100 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+
+		const budget = new BudgetTracker({ daily_limit_usd: 10.0 });
+		const runner = new EvalRunner(mockProvider, budget);
+		const result = await runner.judgeOnly({
+			draft: "# Existing content\n\nSome published text.",
+			gold_standard: "# Perfect example.",
+			judge_prompt: "Score 0-100.",
+		});
+
+		expect(result.score).toBe(72);
+		expect(result.reasoning).toBeTruthy();
+	});
+
+	it("accumulates total usage across iterations", async () => {
+		// Generate
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: { frontmatter: { title: "T" }, body: "B" },
+			usage: { promptTokens: 1000, completionTokens: 100 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+
+		// Judge — keep
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: { score: 90, reasoning: "Great." },
+			usage: { promptTokens: 500, completionTokens: 50 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+
+		const budget = new BudgetTracker({ daily_limit_usd: 10.0 });
+		const runner = new EvalRunner(mockProvider, budget);
+		const result = await runner.run(baseConfig);
+
+		expect(result.total_usage.input_tokens).toBe(1500);
+		expect(result.total_usage.output_tokens).toBe(150);
+		expect(result.total_usage.estimated_cost_usd).toBeGreaterThan(0);
+	});
+});

package/src/__tests__/extract.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it, vi } from "vitest";
+import { BudgetTracker } from "../budget.js";
+import { extract } from "../functions/extract.js";
+import type { ResolvedProvider } from "../provider.js";
+
+vi.mock("ai", () => ({ generateObject: vi.fn() }));
+import { generateObject } from "ai";
+
+const mockProvider: ResolvedProvider = {
+	provider: "anthropic",
+	model: "claude-sonnet-4-5-20250514",
+};
+
+describe("extract", () => {
+	it("extracts entities and relations from text", async () => {
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: {
+				entities: [
+					{ type: "client", name: "Acme Corp", aliases: ["Acme", "ACME"], confidence: 0.95 },
+					{ type: "technology", name: "Next.js", aliases: ["NextJS"], confidence: 0.99 },
+				],
+				relations: [
+					{
+						from_entity: "Acme Corp",
+						to_entity: "Next.js",
+						relation_type: "uses",
+						confidence: 0.9,
+						evidence: "Acme Corp is migrating to Next.js",
+					},
+				],
+			},
+			usage: { promptTokens: 800, completionTokens: 200 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+		const budget = new BudgetTracker({ daily_limit_usd: 5.0 });
+		const result = await extract(
+			{
+				text: "Meeting with Acme Corp. They want to migrate to Next.js.",
+				file_path: "knowledge/clients/acme.md",
+			},
+			mockProvider,
+			budget,
+		);
+		expect(result.entities).toHaveLength(2);
+		expect(result.entities[0].name).toBe("Acme Corp");
+		expect(result.relations).toHaveLength(1);
+		expect(result.usage.function_name).toBe("extract");
+	});
+
+	it("includes existing entities as context", async () => {
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: {
+				entities: [{ type: "technology", name: "React", aliases: [], confidence: 0.95 }],
+				relations: [
+					{
+						from_entity: "React",
+						to_entity: "Next.js",
+						relation_type: "used_by",
+						confidence: 0.98,
+						evidence: "React is the foundation of Next.js",
+					},
+				],
+			},
+			usage: { promptTokens: 1000, completionTokens: 150 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+		const budget = new BudgetTracker({ daily_limit_usd: 5.0 });
+		const result = await extract(
+			{
+				text: "React is great for building UIs.",
+				file_path: "knowledge/tech/react.md",
+				existing_entities: [{ type: "technology", name: "Next.js" }],
+			},
+			mockProvider,
+			budget,
+		);
+		expect(result.entities).toHaveLength(1);
+		expect(result.relations).toHaveLength(1);
+	});
+
+	it("records budget usage", async () => {
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: { entities: [], relations: [] },
+			usage: { promptTokens: 400, completionTokens: 50 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+		const budget = new BudgetTracker({ daily_limit_usd: 5.0 });
+		await extract({ text: "Empty text", file_path: "test.md" }, mockProvider, budget);
+		expect(budget.getHistory()).toHaveLength(1);
+		expect(budget.getHistory()[0].function_name).toBe("extract");
+	});
+});

package/src/__tests__/find-gaps.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it, vi } from "vitest";
+import { BudgetTracker } from "../budget.js";
+import { findGaps } from "../functions/find-gaps.js";
+import type { ResolvedProvider } from "../provider.js";
+
+vi.mock("ai", () => ({ generateObject: vi.fn() }));
+import { generateObject } from "ai";
+const mockProvider: ResolvedProvider = {
+	provider: "anthropic",
+	model: "claude-sonnet-4-5-20250514",
+};
+
+describe("findGaps", () => {
+	it("identifies knowledge without corresponding content", async () => {
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: {
+				gaps: [
+					{
+						entity_name: "React",
+						entity_type: "technology",
+						suggested_content_type: "blog-post",
+						priority: "high",
+						reason: "Core tech with no content page.",
+					},
+					{
+						entity_name: "TypeScript",
+						entity_type: "technology",
+						suggested_content_type: "service-page",
+						priority: "medium",
+						reason: "Appears in projects but no content.",
+					},
+				],
+			},
+			usage: { promptTokens: 2500, completionTokens: 300 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+		const budget = new BudgetTracker({ daily_limit_usd: 5.0 });
+		const result = await findGaps(
+			{
+				entities: [
+					{ type: "technology", name: "React" },
+					{ type: "technology", name: "TypeScript" },
+					{ type: "technology", name: "Next.js" },
+				],
+				relations: [{ from: "Next.js", to: "React", type: "built_on" }],
+				existing_content: [
+					{
+						path: "content/cases/acme.mdx",
+						title: "Acme Corp — Next.js Migration",
+						summary: "Case study about Next.js",
+					},
+				],
+			},
+			mockProvider,
+			budget,
+		);
+		expect(result.gaps).toHaveLength(2);
+		expect(result.gaps[0].entity_name).toBe("React");
+		expect(result.gaps[0].priority).toBe("high");
+		expect(result.usage.function_name).toBe("findGaps");
+	});
+
+	it("uses business context for prioritization", async () => {
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: {
+				gaps: [
+					{
+						entity_name: "AI Strategy",
+						entity_type: "service",
+						suggested_content_type: "service-page",
+						priority: "high",
+						reason: "Core business offering.",
+					},
+				],
+			},
+			usage: { promptTokens: 2000, completionTokens: 150 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+		const budget = new BudgetTracker({ daily_limit_usd: 5.0 });
+		const result = await findGaps(
+			{
+				entities: [{ type: "service", name: "AI Strategy" }],
+				relations: [],
+				existing_content: [],
+				business_context: "We are a digital agency focused on AI strategy consulting.",
+			},
+			mockProvider,
+			budget,
+		);
+		expect(result.gaps).toHaveLength(1);
+		expect(result.gaps[0].priority).toBe("high");
+	});
+});

package/src/__tests__/generate.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it, vi } from "vitest";
+import { BudgetTracker } from "../budget.js";
+import { generate } from "../functions/generate.js";
+import type { ResolvedProvider } from "../provider.js";
+
+vi.mock("ai", () => ({ generateObject: vi.fn() }));
+import { generateObject } from "ai";
+
+const mockProvider: ResolvedProvider = {
+	provider: "anthropic",
+	model: "claude-sonnet-4-5-20250514",
+};
+
+describe("generate", () => {
+	it("generates content from knowledge context", async () => {
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: {
+				frontmatter: { title: "Acme Corp Case Study", client: "acme-corp" },
+				body: "# Acme Corp\n\nWe migrated 12 services in 8 weeks.",
+			},
+			usage: { promptTokens: 3000, completionTokens: 500 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+
+		const budget = new BudgetTracker({ daily_limit_usd: 5.0 });
+		const result = await generate(
+			{
+				content_type: "case-study",
+				generation_prompt: "Write a compelling case study with specific metrics.",
+				knowledge_context:
+					"Acme Corp migrated 12 microservices to Next.js in 8 weeks. Load time improved by 40%.",
+			},
+			mockProvider,
+			budget,
+		);
+
+		expect(result.content).toContain("Acme Corp");
+		expect(result.frontmatter.title).toBe("Acme Corp Case Study");
+		expect(result.usage.function_name).toBe("generate");
+	});
+
+	it("includes intent in generation when provided", async () => {
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: {
+				frontmatter: { title: "Test" },
+				body: "Vi hjälpte kunden att migrera.",
+			},
+			usage: { promptTokens: 3500, completionTokens: 400 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+
+		const budget = new BudgetTracker({ daily_limit_usd: 5.0 });
+		const result = await generate(
+			{
+				content_type: "case-study",
+				generation_prompt: "Write a case study.",
+				knowledge_context: "Acme Corp project data.",
+				intent: 'Always use "vi" form. No buzzwords.',
+			},
+			mockProvider,
+			budget,
+		);
+
+		expect(result.content).toBeTruthy();
+		expect(result.usage.function_name).toBe("generate");
+	});
+
+	it("tracks budget usage", async () => {
+		vi.mocked(generateObject).mockResolvedValueOnce({
+			object: {
+				frontmatter: { title: "Test" },
+				body: "Content body.",
+			},
+			usage: { promptTokens: 2000, completionTokens: 300 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of generateObject return type
+		} as any);
+
+		const budget = new BudgetTracker({ daily_limit_usd: 5.0 });
+		await generate(
+			{
+				content_type: "blog-post",
+				generation_prompt: "Write a blog post.",
+				knowledge_context: "Blog knowledge.",
+			},
+			mockProvider,
+			budget,
+		);
+
+		const status = budget.getStatus();
+		expect(status.spent_today_usd).toBeGreaterThan(0);
+	});
+});