openreport 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openreport",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "packageManager": "bun@1.3.9",
   "description": "A modern TUI to generate detailed AI-powered reports on software projects",
   "type": "module",
@@ -37,25 +37,26 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@ai-sdk/anthropic": "^1.2.0",
-    "@ai-sdk/google": "^1.2.0",
-    "@ai-sdk/mistral": "^1.2.0",
-    "@ai-sdk/openai": "^1.3.0",
-    "ai": "^4.3.0",
+    "@ai-sdk/anthropic": "^3.0.43",
+    "@ai-sdk/google": "^3.0.29",
+    "@ai-sdk/mistral": "^3.0.20",
+    "@ai-sdk/openai": "^3.0.28",
+    "@ai-sdk/provider": "^3.0.8",
+    "ai": "^6.0.85",
     "chalk": "^5.4.0",
     "clipanion": "^3.2.0",
     "ignore": "^7.0.0",
-    "ink": "^5.1.0",
+    "ink": "^6.7.0",
     "ink-spinner": "^5.0.0",
-    "marked": "^15.0.0",
+    "marked": "^17.0.2",
     "marked-terminal": "^7.3.0",
-    "react": "^18.3.1",
-    "zod": "^3.24.0"
+    "react": "^19.2.4",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.15",
     "@types/bun": "^1.3.9",
-    "@types/react": "^18.3.0",
+    "@types/react": "^19.2.14",
     "typescript": "^5.7.0"
   }
 }

package/src/agents/orchestrator.ts

@@ -1,4 +1,4 @@
-import type { LanguageModelV1 } from "ai";
+import type { LanguageModelV2 } from "@ai-sdk/provider";
 import type { OpenReportConfig } from "../config/schema.js";
 import type { FullReport } from "../types/index.js";
 import { ProgressTracker } from "../pipeline/progress.js";
@@ -7,7 +7,7 @@ import { runPipeline } from "../pipeline/runner.js";
 export interface OrchestratorOptions {
   projectRoot: string;
   reportType: string;
-  model: LanguageModelV1;
+  model: LanguageModelV2;
   modelId: string;
   config: OpenReportConfig;
   onProgress?: (progress: ProgressTracker) => void;

package/src/app/App.tsx

@@ -8,13 +8,13 @@ import { ConfigScreen, type ConfigChanges } from "../screens/ConfigScreen.js";
 import { createProviderRegistry } from "../config/providers.js";
 import { saveProjectConfig } from "../config/saver.js";
 import { debugLog } from "../utils/debug.js";
-import type { LanguageModelV1 } from "ai";
+import type { LanguageModelV2 } from "@ai-sdk/provider";
 import type { Screen, NavigationState } from "../types/index.js";
 import type { OpenReportConfig } from "../config/schema.js";
 
 interface AppProps {
   projectRoot: string;
-  initialModel: LanguageModelV1;
+  initialModel: LanguageModelV2;
   initialModelId: string;
   initialConfig: OpenReportConfig;
 }
@@ -28,7 +28,7 @@ export function App({
   const { exit } = useApp();
   const [nav, setNav] = useState<NavigationState>({ screen: "home" });
   const [config, setConfig] = useState<OpenReportConfig>(initialConfig);
-  const [model, setModel] = useState<LanguageModelV1>(initialModel);
+  const [model, setModel] = useState<LanguageModelV2>(initialModel);
   const [modelId, setModelId] = useState<string>(initialModelId);
 
   const navigate = useCallback(

package/src/components/generation/AgentStatusItem.tsx

@@ -73,21 +73,23 @@ export const AgentStatusItem = React.memo(function AgentStatusItem({
         </Text>
       </Box>
 
-      {/* Duration */}
-      {duration > 0 && (
-        <Box width={timeWidth} justifyContent="flex-end">
+      {/* Duration — always rendered to keep columns aligned with header */}
+      <Box width={timeWidth} justifyContent="flex-end">
+        {duration > 0 && (
           <Text color="gray" dimColor>
             {formatDuration(duration)}
           </Text>
-        </Box>
-      )}
+        )}
+      </Box>
 
-      {/* Tokens (hidden in compact mode) */}
-      {tokenStr && !isCompact && (
+      {/* Tokens — always rendered (when not compact) to keep columns aligned */}
+      {!isCompact && (
         <Box width={tokenWidth} justifyContent="flex-end">
-          <Text color="gray" dimColor>
-            {tokenStr}
-          </Text>
+          {tokenStr ? (
+            <Text color="gray" dimColor>
+              {tokenStr}
+            </Text>
+          ) : null}
         </Box>
       )}
     </Box>

package/src/config/cli-model.ts

@@ -2,10 +2,11 @@ import { spawn as spawnChild, execFile } from "child_process";
 import { promisify } from "util";
 import * as os from "os";
 import type {
-  LanguageModelV1,
-  LanguageModelV1CallOptions,
-  LanguageModelV1StreamPart,
-} from "ai";
+  LanguageModelV2,
+  LanguageModelV2CallOptions,
+  LanguageModelV2StreamPart,
+  LanguageModelV2Content,
+} from "@ai-sdk/provider";
 import { estimateTokens } from "../ingestion/token-budget.js";
 import { debugLog } from "../utils/debug.js";
 import {
@@ -40,10 +41,10 @@ async function resolveWindowsCommand(command: string): Promise<{ cmd: string; ar
 
 // ── CLI model marker for provider detection ─────────────────────────────
 
-const cliModels = new WeakSet<LanguageModelV1>();
+const cliModels = new WeakSet<LanguageModelV2>();
 
-/** Check whether a LanguageModelV1 was created by `createCliModel`. */
-export function isCliModel(model: LanguageModelV1): boolean {
+/** Check whether a LanguageModelV2 was created by `createCliModel`. */
+export function isCliModel(model: LanguageModelV2): boolean {
   return cliModels.has(model);
 }
 
@@ -146,7 +147,7 @@ function parseStreamEvent(line: string): ParsedStreamEvent | null {
 function processRemainingBuffer(
   buffer: string,
   textChunks: string[],
-  controller: ReadableStreamDefaultController<LanguageModelV1StreamPart>,
+  controller: ReadableStreamDefaultController<LanguageModelV2StreamPart>,
   usage: { inputTokens: number; outputTokens: number },
 ): void {
   if (!buffer.trim()) return;
@@ -156,7 +157,7 @@ function processRemainingBuffer(
 
   if (parsed.type === "text" && parsed.text) {
     textChunks.push(parsed.text);
-    controller.enqueue({ type: "text-delta", textDelta: parsed.text });
+    controller.enqueue({ type: "text-delta", id: "0", delta: parsed.text });
   }
   if (parsed.usage) {
     if (parsed.usage.input_tokens) usage.inputTokens = parsed.usage.input_tokens;
@@ -168,19 +169,18 @@ function buildStreamFinishResult(
   textChunks: string[],
   usage: { inputTokens: number; outputTokens: number },
   fullPrompt: string,
-): { finishParts: LanguageModelV1StreamPart[] } {
+): { finishParts: LanguageModelV2StreamPart[] } {
   const totalText = textChunks.join("");
   const toolCalls = parseToolCalls(totalText);
-  const parts: LanguageModelV1StreamPart[] = [];
+  const parts: LanguageModelV2StreamPart[] = [];
 
   if (toolCalls) {
     for (const tc of toolCalls) {
       parts.push({
         type: "tool-call",
-        toolCallType: "function",
         toolCallId: tc.toolCallId,
         toolName: tc.toolName,
-        args: tc.args,
+        input: tc.args,
       });
     }
   }
@@ -189,8 +189,9 @@ function buildStreamFinishResult(
     type: "finish",
     finishReason: toolCalls ? "tool-calls" : "stop",
     usage: {
-      promptTokens: usage.inputTokens || estimateTokens(fullPrompt),
-      completionTokens: usage.outputTokens || estimateTokens(totalText),
+      inputTokens: usage.inputTokens || estimateTokens(fullPrompt),
+      outputTokens: usage.outputTokens || estimateTokens(totalText),
+      totalTokens: undefined,
     },
   });
 
@@ -204,14 +205,14 @@ async function streamClaude(
   fullPrompt: string,
   model: string | null,
   signal?: AbortSignal
-): Promise<ReadableStream<LanguageModelV1StreamPart>> {
+): Promise<ReadableStream<LanguageModelV2StreamPart>> {
   const command = getCliCommand(tool.id);
   validateCliCommand(command);
   const args = tool.buildStreamArgs(model);
 
   const resolved = await resolveWindowsCommand(command);
 
-  return new ReadableStream<LanguageModelV1StreamPart>({
+  return new ReadableStream<LanguageModelV2StreamPart>({
     start(controller) {
       const proc = spawnChild(resolved.cmd, [...resolved.args, ...args], {
         stdio: ["pipe", "pipe", "pipe"],
@@ -234,6 +235,7 @@ async function streamClaude(
       let buffer = "";
       const textChunks: string[] = [];
       const usage = { inputTokens: 0, outputTokens: 0 };
+      let textStarted = false;
 
       proc.stdout.on("data", (chunk: Buffer) => {
         buffer += chunk.toString("utf-8");
@@ -245,8 +247,12 @@ async function streamClaude(
           if (!parsed) continue;
 
           if (parsed.type === "text" && parsed.text) {
+            if (!textStarted) {
+              controller.enqueue({ type: "text-start", id: "0" });
+              textStarted = true;
+            }
             textChunks.push(parsed.text);
-            controller.enqueue({ type: "text-delta", textDelta: parsed.text });
+            controller.enqueue({ type: "text-delta", id: "0", delta: parsed.text });
           }
           if (parsed.usage) {
             if (parsed.usage.input_tokens) usage.inputTokens = parsed.usage.input_tokens;
@@ -268,6 +274,10 @@ async function streamClaude(
 
         processRemainingBuffer(buffer, textChunks, controller, usage);
 
+        if (textStarted) {
+          controller.enqueue({ type: "text-end", id: "0" });
+        }
+
         const { finishParts } = buildStreamFinishResult(textChunks, usage, fullPrompt);
         for (const part of finishParts) {
           controller.enqueue(part);
@@ -283,24 +293,24 @@ async function streamClaude(
   });
 }
 
-// ── LanguageModelV1 implementation ──────────────────────────────────────
+// ── LanguageModelV2 implementation ──────────────────────────────────────
 
 export function createCliModel(
   toolId: string,
   modelOverride?: string
-): LanguageModelV1 {
+): LanguageModelV2 {
   const tool = CLI_TOOLS.find((t) => t.id === toolId);
   if (!tool) throw new Error(`Unknown CLI tool: ${toolId}`);
 
   const modelId = modelOverride || tool.defaultModel;
 
-  const model = {
-    specificationVersion: "v1" as const,
+  const model: LanguageModelV2 = {
+    specificationVersion: "v2" as const,
     provider: tool.id,
     modelId,
-    defaultObjectGenerationMode: "json" as const,
+    supportedUrls: {},
 
-    async doGenerate(options: LanguageModelV1CallOptions) {
+    async doGenerate(options: LanguageModelV2CallOptions) {
       const fullPrompt = buildFullPrompt(options);
 
       // Use async spawn to avoid blocking the event loop
@@ -308,26 +318,40 @@ export function createCliModel(
 
       const { cleanText, toolCalls } = processCliOutput(output);
 
+      const content: LanguageModelV2Content[] = [];
+      if (cleanText) {
+        content.push({ type: "text", text: cleanText });
+      }
+      if (toolCalls) {
+        for (const tc of toolCalls) {
+          content.push({
+            type: "tool-call",
+            toolCallId: tc.toolCallId,
+            toolName: tc.toolName,
+            input: tc.args,
+          });
+        }
+      }
+
       return {
-        text: cleanText || undefined,
-        toolCalls,
-        finishReason: toolCalls
-          ? ("tool-calls" as const)
-          : ("stop" as const),
+        content,
+        finishReason: toolCalls ? "tool-calls" as const : "stop" as const,
         usage: {
-          promptTokens: estimateTokens(fullPrompt),
-          completionTokens: estimateTokens(output),
+          inputTokens: estimateTokens(fullPrompt),
+          outputTokens: estimateTokens(output),
+          totalTokens: undefined,
+        },
+        request: {
+          body: fullPrompt,
         },
-        rawCall: {
-          rawPrompt: fullPrompt,
-          rawSettings: { toolId, modelId },
+        response: {
+          headers: {},
         },
-        rawResponse: { headers: {} },
         warnings: [],
       };
     },
 
-    async doStream(options: LanguageModelV1CallOptions) {
+    async doStream(options: LanguageModelV2CallOptions) {
       const fullPrompt = buildFullPrompt(options);
 
       // Use native streaming for Claude Code
@@ -336,12 +360,12 @@ export function createCliModel(
 
         return {
           stream,
-          rawCall: {
-            rawPrompt: fullPrompt,
-            rawSettings: { toolId, modelId },
+          request: {
+            body: fullPrompt,
+          },
+          response: {
+            headers: {},
           },
-          rawResponse: { headers: {} },
-          warnings: [],
         };
       }
 
@@ -350,19 +374,20 @@ export function createCliModel(
 
       const { cleanText, toolCalls } = processCliOutput(output);
 
-      const stream = new ReadableStream<LanguageModelV1StreamPart>({
+      const stream = new ReadableStream<LanguageModelV2StreamPart>({
         start(controller) {
           if (cleanText) {
-            controller.enqueue({ type: "text-delta", textDelta: cleanText });
+            controller.enqueue({ type: "text-start", id: "0" });
+            controller.enqueue({ type: "text-delta", id: "0", delta: cleanText });
+            controller.enqueue({ type: "text-end", id: "0" });
           }
           if (toolCalls) {
             for (const tc of toolCalls) {
               controller.enqueue({
                 type: "tool-call",
-                toolCallType: "function",
                 toolCallId: tc.toolCallId,
                 toolName: tc.toolName,
-                args: tc.args,
+                input: tc.args,
               });
             }
           }
@@ -370,8 +395,9 @@ export function createCliModel(
             type: "finish",
             finishReason: toolCalls ? "tool-calls" : "stop",
             usage: {
-              promptTokens: estimateTokens(fullPrompt),
-              completionTokens: estimateTokens(output),
+              inputTokens: estimateTokens(fullPrompt),
+              outputTokens: estimateTokens(output),
+              totalTokens: undefined,
             },
           });
           controller.close();
@@ -380,12 +406,12 @@ export function createCliModel(
 
       return {
         stream,
-        rawCall: {
-          rawPrompt: fullPrompt,
-          rawSettings: { toolId, modelId },
+        request: {
+          body: fullPrompt,
+        },
+        response: {
+          headers: {},
         },
-        rawResponse: { headers: {} },
-        warnings: [],
       };
     },
   };

package/src/config/cli-prompt-formatter.ts

@@ -1,10 +1,10 @@
-import type { LanguageModelV1CallOptions } from "ai";
+import type { LanguageModelV2CallOptions } from "@ai-sdk/provider";
 import { debugLog } from "../utils/debug.js";
 
 // ── Prompt formatting ───────────────────────────────────────────────────
 
 export function formatUserPrompt(
-  prompt: LanguageModelV1CallOptions["prompt"]
+  prompt: LanguageModelV2CallOptions["prompt"]
 ): string {
   const parts: string[] = [];
 
@@ -30,7 +30,11 @@ export function formatUserPrompt(
       case "tool":
         for (const part of msg.content) {
           parts.push(
-            `[Tool result for ${part.toolCallId}]\n${JSON.stringify(part.result)}`
+            `[Tool result for ${part.toolCallId}]\n${JSON.stringify(
+              part.output && typeof part.output === "object" && "value" in part.output
+                ? part.output.value
+                : part.output
+            )}`
           );
         }
         break;
@@ -41,9 +45,9 @@ export function formatUserPrompt(
 }
 
 export function formatToolsForPrompt(
-  mode: LanguageModelV1CallOptions["mode"]
+  tools: LanguageModelV2CallOptions["tools"]
 ): string {
-  if (mode.type !== "regular" || !mode.tools || mode.tools.length === 0) {
+  if (!tools || tools.length === 0) {
     return "";
   }
 
@@ -53,9 +57,9 @@ export function formatToolsForPrompt(
   text +=
     '```json\n{"tool_calls": [{"id": "call_1", "name": "toolName", "arguments": {...}}]}\n```\n\n';
 
-  for (const tool of mode.tools) {
+  for (const tool of tools) {
     if (tool.type === "function") {
-      text += `### ${tool.name}\n${tool.description || ""}\nParameters: ${JSON.stringify(tool.parameters)}\n\n`;
+      text += `### ${tool.name}\n${tool.description || ""}\nParameters: ${JSON.stringify(tool.inputSchema)}\n\n`;
     }
   }
 
@@ -102,8 +106,8 @@ export function parseToolCalls(text: string): ParsedToolCall[] | undefined {
  * Build the full prompt from SDK call options.
  * Shared between doGenerate and doStream to avoid duplication.
  */
-export function buildFullPrompt(options: LanguageModelV1CallOptions): string {
-  const toolsText = formatToolsForPrompt(options.mode);
+export function buildFullPrompt(options: LanguageModelV2CallOptions): string {
+  const toolsText = formatToolsForPrompt(options.tools);
   return formatUserPrompt(options.prompt) + toolsText;
 }
 

package/src/config/providers.ts

@@ -1,4 +1,4 @@
-import type { LanguageModelV1 } from "ai";
+import type { LanguageModelV2 } from "@ai-sdk/provider";
 import type { OpenReportConfig } from "./schema.js";
 import { createCliModel } from "./cli-model.js";
 import { CLI_TOOLS } from "./cli-detection.js";
@@ -6,7 +6,7 @@ import { ProviderError } from "../errors.js";
 
 export interface ProviderEntry {
   id: string;
-  createModel: (modelId: string) => LanguageModelV1;
+  createModel: (modelId: string) => LanguageModelV2;
   defaultModel: string;
   type: "api" | "local" | "cli";
 }
@@ -21,7 +21,7 @@ const PROVIDER_DEFAULTS: Record<string, string> = {
 
 // ── Lazy-loaded SDK factory ──────────────────────────────────────────────
 
-type SdkFactory = (modelId: string) => LanguageModelV1;
+type SdkFactory = (modelId: string) => LanguageModelV2;
 type SdkCreator<T> = (opts: Record<string, unknown>) => T;
 
 function createSdkFactory<T>(
@@ -132,7 +132,7 @@ export function createProviderRegistry(config: OpenReportConfig) {
       return providers.get(id);
     },
 
-    getModel(config: OpenReportConfig): LanguageModelV1 {
+    getModel(config: OpenReportConfig): LanguageModelV2 {
       const provider = providers.get(config.defaultProvider);
       if (!provider) {
         throw new ProviderError(`Unknown provider: ${config.defaultProvider}`);
@@ -153,28 +153,28 @@ export function createProviderRegistry(config: OpenReportConfig) {
 export type ProviderRegistry = ReturnType<typeof createProviderRegistry>;
 
 // ── Lazy model proxy ────────────────────────────────────────────────────
-// Creates a LanguageModelV1 that only loads the SDK when doGenerate/doStream is called.
+// Creates a LanguageModelV2 that only loads the SDK when doGenerate/doStream is called.
 
 function createLazyModel(
   getSdk: () => Promise<SdkFactory>,
   modelId: string,
   providerId: string,
-): LanguageModelV1 {
-  let _resolved: LanguageModelV1 | null = null;
+): LanguageModelV2 {
+  let _resolved: LanguageModelV2 | null = null;
 
-  async function resolve(): Promise<LanguageModelV1> {
+  async function resolve(): Promise<LanguageModelV2> {
     if (!_resolved) {
       const sdk = await getSdk();
-      _resolved = sdk(modelId) as LanguageModelV1;
+      _resolved = sdk(modelId) as LanguageModelV2;
     }
     return _resolved;
   }
 
-  const base: LanguageModelV1 = {
-    specificationVersion: "v1",
+  const base: LanguageModelV2 = {
+    specificationVersion: "v2",
     provider: providerId,
     modelId,
-    defaultObjectGenerationMode: undefined,
+    supportedUrls: {},
 
     async doGenerate(options) {
       const model = await resolve();

package/src/config/resolve-provider.ts

@@ -1,4 +1,4 @@
-import type { LanguageModelV1 } from "ai";
+import type { LanguageModelV2 } from "@ai-sdk/provider";
 import type { OpenReportConfig } from "./schema.js";
 import type { ProviderRegistry } from "./providers.js";
 import { detectInstalledClis } from "./cli-detection.js";
@@ -6,7 +6,7 @@ import { ProviderError } from "../errors.js";
 import { debugLog } from "../utils/debug.js";
 
 export interface ResolvedProvider {
-  model: LanguageModelV1;
+  model: LanguageModelV2;
   effectiveProvider: string;
   effectiveModel: string;
   warnings: string[];
@@ -33,7 +33,7 @@ export async function resolveProvider(
     effectiveModel = detectedClis[0].defaultModel;
   }
 
-  let model: LanguageModelV1;
+  let model: LanguageModelV2;
   try {
     const provider = registry.getProvider(effectiveProvider);
     if (provider) {

package/src/config/schema.ts

@@ -17,7 +17,11 @@ export const OpenReportConfigSchema = z.object({
       format: z.enum(["markdown", "json"]).default("markdown"),
       includeMetadata: z.boolean().default(true),
     })
-    .default({}),
+    .default(() => ({
+      directory: ".openreport/reports",
+      format: "markdown" as const,
+      includeMetadata: true,
+    })),
   agents: z
     .object({
       maxConcurrency: z.number().min(1).max(10).default(3),
@@ -25,7 +29,12 @@ export const OpenReportConfigSchema = z.object({
       temperature: z.number().min(0).max(1).default(0.3),
       maxTokens: z.number().default(8192),
     })
-    .default({}),
+    .default(() => ({
+      maxConcurrency: 3,
+      maxStepsOverride: {} as Record<string, number>,
+      temperature: 0.3,
+      maxTokens: 8192,
+    })),
   modelTokenLimits: z.record(z.string(), z.number()).default({}).optional(),
   scan: z
     .object({
@@ -33,19 +42,29 @@ export const OpenReportConfigSchema = z.object({
       maxFileSize: z.number().default(50000),
       maxDepth: z.number().default(10),
     })
-    .default({}),
+    .default(() => ({
+      exclude: [] as string[],
+      maxFileSize: 50000,
+      maxDepth: 10,
+    })),
   ui: z
     .object({
       theme: z.enum(["auto", "dark", "light"]).default("auto"),
       showTokenCount: z.boolean().default(true),
       streamOutput: z.boolean().default(true),
     })
-    .default({}),
+    .default(() => ({
+      theme: "auto" as const,
+      showTokenCount: true,
+      streamOutput: true,
+    })),
   features: z
     .object({
       todoList: z.boolean().default(false),
     })
-    .default({}),
+    .default(() => ({
+      todoList: false,
+    })),
 });
 
 export type OpenReportConfig = z.infer<typeof OpenReportConfigSchema>;

package/src/hooks/useReportGeneration.ts

@@ -2,7 +2,7 @@ import { useState, useEffect, useCallback, useRef, useMemo } from "react";
 import { orchestrate } from "../agents/orchestrator.js";
 import { saveReport } from "../storage/report-store.js";
 import { getErrorMessage } from "../utils/format.js";
-import type { LanguageModelV1 } from "ai";
+import type { LanguageModelV2 } from "@ai-sdk/provider";
 import type {
   AgentStatus,
   PipelinePhase,
@@ -16,7 +16,7 @@ import type { ProgressTracker } from "../pipeline/progress.js";
 export interface UseReportGenerationOptions {
   projectRoot: string;
   reportType: string;
-  model: LanguageModelV1;
+  model: LanguageModelV2;
   modelId: string;
   config: OpenReportConfig;
   generateTodoList?: boolean;

package/src/pipeline/agent-runner.ts

@@ -1,5 +1,5 @@
-import { generateText, streamText } from "ai";
-import type { LanguageModelV1 } from "ai";
+import { generateText, streamText, stepCountIs } from "ai";
+import type { LanguageModelV2 } from "@ai-sdk/provider";
 import { ProgressTracker } from "./progress.js";
 import { extractSubReport } from "./extraction.js";
 import { buildFileContentBlock, type SharedContext } from "./context.js";
@@ -8,6 +8,7 @@ import { createBaseTools, createExtendedTools, type BaseTools, type ExtendedTool
 import { getRelevantFilePaths } from "../ingestion/context-selector.js";
 import { debugLog } from "../utils/debug.js";
 import { getErrorMessage } from "../utils/format.js";
+import { estimateTokens } from "../ingestion/token-budget.js";
 import type { AgentId, AgentDefinition, SubReport } from "../types/index.js";
 import type { OpenReportConfig } from "../config/schema.js";
 
@@ -169,7 +170,7 @@ This overview will be provided to specialized agents (security, performance, cod
 Output your analysis as plain markdown (no JSON, no tags).`;
 
 export async function runOrchestratorAgent(
-  model: LanguageModelV1,
+  model: LanguageModelV2,
   sharedContext: SharedContext,
   config: OpenReportConfig,
   progress: ProgressTracker,
@@ -187,24 +188,38 @@ ${fileContentBlock}
 Produce your project overview now.`;
 
   try {
+    const estimatedInputTokens = estimateTokens(prompt);
+
     const fullText = await withRetry(async () => {
       const result = await streamText({
         model,
         prompt,
-        maxSteps: 1,
-        maxTokens: config.agents.maxTokens,
+        maxOutputTokens: config.agents.maxTokens,
         temperature: 0.3,
         abortSignal: signal,
       });
 
+      let outputCharCount = 0;
       const throttle = createStreamThrottle((preview) => {
         progress.setPhaseDetail(preview);
+        progress.setBaseTokens({
+          input: estimatedInputTokens,
+          output: Math.ceil(outputCharCount / 4),
+        });
       });
 
       for await (const chunk of result.textStream) {
+        outputCharCount += chunk.length;
         throttle.push(chunk);
       }
 
+      // Set final token count from actual usage
+      const usage = await result.usage;
+      progress.setBaseTokens({
+        input: usage.inputTokens || estimatedInputTokens,
+        output: usage.outputTokens || Math.ceil(outputCharCount / 4),
+      });
+
       return throttle.getFullText();
     });
 
@@ -221,7 +236,7 @@ Produce your project overview now.`;
 
 export async function runAgentWithTools(
   agentId: AgentId,
-  model: LanguageModelV1,
+  model: LanguageModelV2,
   projectRoot: string,
   sharedContext: SharedContext,
   config: OpenReportConfig,
@@ -247,9 +262,9 @@ export async function runAgentWithTools(
       system: agentDef.systemPrompt,
       prompt: buildAnalysisPrompt(agentId, agentDef.name, contextWithFiles),
       tools,
-      maxSteps,
+      stopWhen: stepCountIs(maxSteps),
       temperature: config.agents.temperature,
-      maxTokens: config.agents.maxTokens,
+      maxOutputTokens: config.agents.maxTokens,
       abortSignal: signal,
       onStepFinish: (step) => {
         if (step.text) {
@@ -258,8 +273,8 @@ export async function runAgentWithTools(
         }
         if (step.usage) {
           progress.updateAgentTokens(agentId, {
-            input: step.usage.promptTokens,
-            output: step.usage.completionTokens,
+            input: step.usage.inputTokens ?? 0,
+            output: step.usage.outputTokens ?? 0,
           });
         }
       },
@@ -285,7 +300,7 @@ export async function runAgentWithTools(
 
 export async function runAgentWithCli(
   agentId: AgentId,
-  model: LanguageModelV1,
+  model: LanguageModelV2,
   projectRoot: string,
   sharedContext: SharedContext,
   config: OpenReportConfig,
@@ -315,20 +330,26 @@ ${buildAnalysisPrompt(agentId, agentDef.name, "")}`;
       const result = await streamText({
         model,
         prompt,
-        maxSteps: 1,
         temperature: config.agents.temperature,
-        maxTokens: config.agents.maxTokens,
+        maxOutputTokens: config.agents.maxTokens,
         abortSignal: signal,
       });
 
       const pendingChunks: string[] = [];
+      const estimatedInputTokens = estimateTokens(prompt);
+      let outputCharCount = 0;
       const throttle = createStreamThrottle((preview) => {
         progress.updateAgentStatus(agentId, "running", preview);
         progress.addStreamText(pendingChunks.join(""), agentId);
+        progress.updateAgentTokens(agentId, {
+          input: estimatedInputTokens,
+          output: Math.ceil(outputCharCount / 4),
+        });
         pendingChunks.length = 0;
       });
 
       for await (const chunk of result.textStream) {
+        outputCharCount += chunk.length;
         pendingChunks.push(chunk);
         throttle.push(chunk);
       }
@@ -339,8 +360,8 @@ ${buildAnalysisPrompt(agentId, agentDef.name, "")}`;
     });
 
     progress.updateAgentTokens(agentId, {
-      input: usage.promptTokens,
-      output: usage.completionTokens,
+      input: usage.inputTokens ?? 0,
+      output: usage.outputTokens ?? 0,
     });
 
     const subReport = extractSubReport(

package/src/pipeline/extraction.ts

@@ -65,13 +65,13 @@ export function extractSubReport(
   agentName: string,
   text: string,
   filesAnalyzed: number,
-  usage?: { promptTokens: number; completionTokens: number }
+  usage?: { inputTokens?: number; outputTokens?: number; promptTokens?: number; completionTokens?: number }
 ): SubReport {
   const makeMeta = () => ({
     filesAnalyzed,
     tokensUsed: {
-      input: usage?.promptTokens || 0,
-      output: usage?.completionTokens || 0,
+      input: usage?.inputTokens || usage?.promptTokens || 0,
+      output: usage?.outputTokens || usage?.completionTokens || 0,
     },
     duration: 0,
   });

package/src/pipeline/progress.ts

@@ -72,7 +72,7 @@ export class ProgressTracker extends TypedEventEmitter<ProgressEventMap> {
       status: "pending",
     };
     this.agents.set(agentId, status);
-    this.emit("agentStatusChange", status);
+    this.emit("agentStatusChange", { ...status });
   }
 
   updateAgentStatus(
@@ -125,6 +125,13 @@ export class ProgressTracker extends TypedEventEmitter<ProgressEventMap> {
     this.previousTokens.set(agentId, { input: tokens.input, output: tokens.output });
 
     this.emit("tokenUpdate", { ...this.totalTokens });
+    this.emit("agentStatusChange", { ...agent });
+  }
+
+  /** Set base token count (e.g. from orchestrator) before agents run. Agent deltas add on top. */
+  setBaseTokens(tokens: { input: number; output: number }): void {
+    this.totalTokens = { ...tokens };
+    this.emit("tokenUpdate", { ...this.totalTokens });
   }
 
   addStreamText(delta: string, agentId: AgentId): void {

package/src/pipeline/runner.ts

@@ -1,5 +1,5 @@
 import { streamText } from "ai";
-import type { LanguageModelV1 } from "ai";
+import type { LanguageModelV2 } from "@ai-sdk/provider";
 import { ProgressTracker } from "./progress.js";
 import { combineReport, countFindings, type CombineOptions } from "./combiner.js";
 import { getAgentById, getAgentsForReportType } from "../agents/registry.js";
@@ -31,7 +31,7 @@ import { isCliModel } from "../config/cli-model.js";
 export interface RunPipelineOptions {
   projectRoot: string;
   reportType: string;
-  model: LanguageModelV1;
+  model: LanguageModelV2;
   modelId: string;
   config: OpenReportConfig;
   progress: ProgressTracker;
@@ -152,7 +152,7 @@ async function preReadFiles(
 // ── Phase 4: Orchestrator global analysis ─────────────────────────────
 
 async function runOrchestrator(
-  model: LanguageModelV1,
+  model: LanguageModelV2,
   sharedContext: SharedContext,
   config: OpenReportConfig,
   progress: ProgressTracker,
@@ -179,7 +179,7 @@ async function runOrchestrator(
 
 async function executeAgents(
   applicableAgents: AgentId[],
-  model: LanguageModelV1,
+  model: LanguageModelV2,
   projectRoot: string,
   sharedContext: SharedContext,
   config: OpenReportConfig,
@@ -249,7 +249,7 @@ async function executeAgents(
 // ── Phase 5.5: Generate todo list from findings ───────────────────────
 
 async function executeTodoAgent(
-  model: LanguageModelV1,
+  model: LanguageModelV2,
   subReports: SubReport[],
   config: OpenReportConfig,
   progress: ProgressTracker,
@@ -303,8 +303,7 @@ Generate the prioritized todo list based on these findings. Wrap your entire res
       const response = await streamText({
         model,
         prompt,
-        maxSteps: 1,
-        maxTokens: config.agents.maxTokens,
+        maxOutputTokens: config.agents.maxTokens,
         temperature: config.agents.temperature,
         abortSignal: signal,
       });
@@ -330,7 +329,7 @@ Generate the prioritized todo list based on these findings. Wrap your entire res
 // ── Phase 6: Generate executive summary ───────────────────────────────
 
 async function generateExecutiveSummary(
-  model: LanguageModelV1,
+  model: LanguageModelV2,
   subReports: SubReport[],
   projectName: string,
   classification: ProjectClassification,
@@ -379,8 +378,7 @@ Be specific, reference actual findings, and provide actionable insights. Write 4
     const result = await streamText({
       model,
       prompt: summaryPrompt,
-      maxSteps: 1,
-      maxTokens: 2000,
+      maxOutputTokens: 2000,
       temperature: 0.3,
       abortSignal: signal,
     });

package/src/schemas/report.ts

@@ -23,7 +23,11 @@ export const SubReportSchema = z.object({
         .default({ input: 0, output: 0 }),
       duration: z.number().default(0),
     })
-    .default({}),
+    .default(() => ({
+      filesAnalyzed: 0,
+      tokensUsed: { input: 0, output: 0 },
+      duration: 0,
+    })),
 });
 
 export const FindingSummarySchema = z.object({

package/src/screens/GenerationScreen.tsx

@@ -12,14 +12,14 @@ import { openInBrowser } from "../report/open-browser.js";
 import { REPORT_TYPES } from "../config/defaults.js";
 import { formatDuration, formatTokens } from "../utils/format.js";
 import { getGradeTerminalColor } from "../utils/grade-colors.js";
-import type { LanguageModelV1 } from "ai";
+import type { LanguageModelV2 } from "@ai-sdk/provider";
 import type { Screen } from "../types/index.js";
 import type { OpenReportConfig } from "../config/schema.js";
 
 interface GenerationScreenProps {
   projectRoot: string;
   reportType: string;
-  model: LanguageModelV1;
+  model: LanguageModelV2;
   modelId: string;
   config: OpenReportConfig;
   onNavigate: (screen: Screen, params?: Record<string, string>) => void;

package/src/tools/get-file-tree.ts

@@ -123,7 +123,7 @@ export function createGetFileTreeTool(projectRoot: string) {
   return tool({
     description:
       "Get the complete file tree of the project. Excludes node_modules, .git, dist, and binary files. Shows file sizes for large files.",
-    parameters: z.object({
+    inputSchema: z.object({
       maxDepth: z
         .number()
         .optional()

package/src/tools/get-git-info.ts

@@ -19,7 +19,7 @@ export function createGetGitInfoTool(projectRoot: string) {
   return tool({
     description:
       "Get git information about the project: recent commits, branches, most-changed files, and contributors.",
-    parameters: z.object({
+    inputSchema: z.object({
       type: z
         .enum(["summary", "recent-commits", "file-frequency", "contributors"])
         .describe("Type of git information to retrieve"),

package/src/tools/glob.ts

@@ -6,7 +6,7 @@ export function createGlobTool(projectRoot: string) {
   return tool({
     description:
       "Find files matching a glob pattern within the project. Returns up to 200 matching file paths.",
-    parameters: z.object({
+    inputSchema: z.object({
       pattern: z
         .string()
         .describe(

package/src/tools/grep.ts

@@ -44,7 +44,7 @@ export function createGrepTool(projectRoot: string) {
   return tool({
     description:
       "Search for a regex pattern in project files. Returns matching lines with file paths and line numbers.",
-    parameters: z.object({
+    inputSchema: z.object({
       pattern: z.string().describe("Regex pattern to search for"),
       filePattern: z
         .string()

package/src/tools/list-directory.ts

@@ -9,7 +9,7 @@ export function createListDirectoryTool(projectRoot: string) {
   return tool({
     description:
       "List the contents of a directory relative to the project root. Shows files and subdirectories with basic metadata.",
-    parameters: z.object({
+    inputSchema: z.object({
       path: z
         .string()
         .default(".")

package/src/tools/read-file.ts

@@ -7,7 +7,7 @@ export function createReadFileTool(projectRoot: string) {
   return tool({
     description:
       "Read the contents of a file. Path must be relative to the project root. Can optionally read a specific range of lines.",
-    parameters: z.object({
+    inputSchema: z.object({
       path: z.string().describe("Relative file path from project root"),
       maxLines: z
         .number()

package/src/tools/read-package-json.ts

@@ -7,7 +7,7 @@ export function createReadPackageJsonTool(projectRoot: string) {
   return tool({
     description:
       "Read and parse a package.json (or similar manifest) file. Returns structured data about dependencies, scripts, and metadata.",
-    parameters: z.object({
+    inputSchema: z.object({
       path: z
         .string()
         .default("package.json")

package/src/tools/run-command.ts

@@ -87,7 +87,7 @@ export function createRunCommandTool(projectRoot: string) {
   return tool({
     description:
       "Run an allowed shell command in the project directory. Only safe, read-only commands are permitted (eslint, tsc --noEmit, npm audit, etc.).",
-    parameters: z.object({
+    inputSchema: z.object({
       command: z.string().describe("The shell command to execute"),
     }),
     execute: async ({ command }) => {