@tyvm/knowhow 0.0.105 → 0.0.106

package/src/clients/pricing/types.ts

@@ -4,7 +4,8 @@ export type ModelType =
   | "image"
   | "audio"
   | "video"
-  | "transaction";
+  | "transaction"
+  | "live";
 
 export interface ModelPricing {
   input?: number;
@@ -17,13 +18,93 @@ export interface ModelPricing {
   input_gt_200k?: number;
   output_gt_200k?: number;
   image_generation?: number;
+  image_generation_per_1m_tokens?: number;
   video_generation?: number;
+  output_image_per_1m_tokens?: number;
+  // Optional metadata — when set on a pricing entry, the catalog picks them up automatically
+  deprecated?: boolean;
+  deprecationDate?: string;
+  limitedAvailability?: boolean;
+  replacedBy?: string;
+  /** Supported reasoning effort levels for this model (ordered low→high). If set, effort will be clamped to these values. */
+  reasoningLevels?: string[];
+  /** If true, this model must be called via the Responses API (/v1/responses) instead of /v1/chat/completions */
+  useResponsesApi?: boolean;
 }
 
 export interface ModelCatalogEntry {
   id: string;
   provider: string;
   type: ModelType;
-  displayName: string;
   pricing: ModelPricing;
+  deprecated?: boolean;
+  deprecationDate?: string;
+  /** Model exists but is not generally available (e.g. Live API only, limited access, or returns empty responses) */
+  limitedAvailability?: boolean;
+  /** Recommended replacement model ID when this model is deprecated */
+  replacedBy?: string;
+}
+
+// ─── Bulk catalog helpers ─────────────────────────────────────────────────────
+
+export interface DeprecationOptions {
+  deprecated?: boolean;
+  deprecationDate?: string;
+  limitedAvailability?: boolean;
+  replacedBy?: string;
+}
+
+function makeEntries(
+  type: ModelType,
+  ids: string[],
+  provider: string,
+  pricing: Record<string, ModelPricing>,
+  deprecation?: DeprecationOptions
+): ModelCatalogEntry[] {
+  return ids.map((id) => {
+    const p = pricing[id] ?? {};
+    // Explicit dep options take precedence; fall back to metadata embedded in the pricing entry
+    const deprecated       = deprecation?.deprecated       ?? p.deprecated;
+    const deprecationDate  = deprecation?.deprecationDate  ?? p.deprecationDate;
+    const limitedAvailability = deprecation?.limitedAvailability ?? p.limitedAvailability;
+    const replacedBy       = deprecation?.replacedBy       ?? p.replacedBy;
+    // Strip metadata fields before storing as pricing
+    const { deprecated: _d, deprecationDate: _dd, limitedAvailability: _la, replacedBy: _rb, reasoningLevels: _rl, useResponsesApi: _ura, ...pricingOnly } = p;
+    return {
+      id,
+      provider,
+      type,
+      pricing: { input: 0, output: 0, ...pricingOnly },
+      deprecated,
+      deprecationDate,
+      limitedAvailability,
+      replacedBy,
+    };
+  });
+}
+
+export const completions  = (ids: string[], provider: string, pricing: Record<string, ModelPricing>, dep?: DeprecationOptions) => makeEntries("completion",   ids, provider, pricing, dep);
+export const embeddings   = (ids: string[], provider: string, pricing: Record<string, ModelPricing>, dep?: DeprecationOptions) => makeEntries("embedding",    ids, provider, pricing, dep);
+export const images       = (ids: string[], provider: string, pricing: Record<string, ModelPricing>, dep?: DeprecationOptions) => makeEntries("image",        ids, provider, pricing, dep);
+export const videos       = (ids: string[], provider: string, pricing: Record<string, ModelPricing>, dep?: DeprecationOptions) => makeEntries("video",        ids, provider, pricing, dep);
+export const audios       = (ids: string[], provider: string, pricing: Record<string, ModelPricing>, dep?: DeprecationOptions) => makeEntries("audio",        ids, provider, pricing, dep);
+export const transactions = (ids: string[], provider: string, pricing: Record<string, ModelPricing>, dep?: DeprecationOptions) => makeEntries("transaction",  ids, provider, pricing, dep);
+export const liveApi      = (ids: string[], provider: string, pricing: Record<string, ModelPricing>, dep?: DeprecationOptions) => makeEntries("live",         ids, provider, pricing, dep);
+
+// ─── Single-entry helpers (for deprecated/special cases) ─────────────────────
+
+export function completion(
+  id: string,
+  provider: string,
+  pricing: Partial<ModelPricing> = {},
+  deprecation?: DeprecationOptions
+): ModelCatalogEntry {
+  return {
+    id, provider, type: "completion",
+    pricing: { input: 0, output: 0, ...pricing },
+    deprecated: deprecation?.deprecated,
+    deprecationDate: deprecation?.deprecationDate,
+    limitedAvailability: deprecation?.limitedAvailability,
+    replacedBy: deprecation?.replacedBy,
+  };
 }

package/src/clients/pricing/xai.ts

@@ -1,74 +1,130 @@
-import { Models } from "../../types";
-import { ModelPricing } from "./types";
+/**
+ * xAI model IDs, pricing, and catalog.
+ * Single source of truth for all xAI/Grok models.
+ */
+import { completions, images, videos, ModelCatalogEntry, ModelPricing } from "./types";
 
-export const XaiTextPricing = {
+// ─── Model IDs ────────────────────────────────────────────────────────────────
 
-  [Models.xai.Grok_4_20_Reasoning]: {
-    input: 2.0,
-    cache_hit: 0.20,
-    output: 6.0,
-  },
-  [Models.xai.Grok_4_20_NonReasoning]: {
-    input: 2.0,
-    cache_hit: 0.20,
-    output: 6.0,
-  },
-  [Models.xai.Grok4_1_Fast_NonReasoning]: {
-    input: 0.2,
-    cache_hit: 0.05,
-    output: 0.5,
-  },
-  [Models.xai.Grok4_1_Fast_Reasoning]: {
-    input: 0.2,
-    cache_hit: 0.05,
-    output: 0.5,
-  },
-  [Models.xai.GrokCodeFast]: {
-    input: 0.2,
-    cache_hit: 0.02,
-    output: 1.5,
-  },
-  [Models.xai.Grok4]: {
-    input: 3.0,
-    output: 15.0,
-  },
-  [Models.xai.Grok3Beta]: {
-    input: 3.0,
-    output: 15.0,
-  },
-  [Models.xai.Grok3MiniBeta]: {
-    input: 0.3,
-    output: 0.5,
-  },
-  [Models.xai.Grok3FastBeta]: {
-    input: 5.0,
-    output: 25.0,
-  },
-  [Models.xai.Grok3MiniFastBeta]: {
-    input: 0.6,
-    output: 4.0,
-  },
-  [Models.xai.Grok21212]: {
-    input: 2.0,
-    output: 10.0,
-  },
-  [Models.xai.Grok2Vision1212]: {
-    input: 2.0,
-    output: 10.0,
-    image_input: 2.0,
-  },
+export const XaiModels = {
+  Grok_4_20_Reasoning: "grok-4.20-0309-reasoning",
+  Grok_4_20_NonReasoning: "grok-4.20-0309-non-reasoning",
+  Grok_4_20_MultiAgent: "grok-4.20-multi-agent-0309",
+  Grok4_1_Fast_Reasoning: "grok-4-1-fast-reasoning",
+  Grok4_1_Fast_NonReasoning: "grok-4-1-fast-non-reasoning",
+  GrokCodeFast: "grok-code-fast-1",
+  Grok4: "grok-4-0709",
+  Grok3Beta: "grok-3-beta",
+  Grok3MiniBeta: "grok-3-mini-beta",
+  Grok3FastBeta: "grok-3-fast-beta",
+  Grok3MiniFastBeta: "grok-3-mini-fast-beta",
+  // Deprecated alias IDs used by models.dev (latest aliases and older beta names)
+  Grok2Latest: "grok-2-latest",
+  Grok2VisionLatest: "grok-2-vision-latest",
+  Grok3Latest: "grok-3-latest",
+  Grok3FastLatest: "grok-3-fast-latest",
+  Grok3MiniLatest: "grok-3-mini-latest",
+  Grok3MiniFastLatest: "grok-3-mini-fast-latest",
+  GrokBeta: "grok-beta",
+  GrokVisionBeta: "grok-vision-beta",
+  // grok-4-1-fast variants (aliases for grok-4-1-fast-reasoning/non-reasoning)
+  Grok4_1_Fast: "grok-4-1-fast",
+  Grok4Fast: "grok-4-fast",
+  Grok4FastNonReasoning: "grok-4-fast-non-reasoning",
+  Grok21212: "grok-2-1212",
+  Grok2Vision1212: "grok-2-vision-1212",
+  GrokImagineImage: "grok-imagine-image",
+  GrokImagineVideo: "grok-imagine-video",
+  Grok2Image1212: "grok-2-image-1212",
+} as const;
+
+// ─── Modality arrays ──────────────────────────────────────────────────────────
+
+export const XaiTextModels: string[] = [
+  XaiModels.Grok_4_20_Reasoning, XaiModels.Grok_4_20_NonReasoning,
+  XaiModels.Grok_4_20_MultiAgent,
+  XaiModels.Grok4_1_Fast_Reasoning, XaiModels.Grok4_1_Fast_NonReasoning,
+  XaiModels.GrokCodeFast, XaiModels.Grok4,
+  XaiModels.Grok3Beta, XaiModels.Grok3MiniBeta, XaiModels.Grok3FastBeta, XaiModels.Grok3MiniFastBeta,
+];
+
+// Models that require the Responses API (/v1/responses) instead of /v1/chat/completions
+// The xAI reasoning variants and multi-agent model use the Responses API
+export const XaiResponsesOnlyModels: string[] = [
+  XaiModels.Grok_4_20_Reasoning,
+  XaiModels.Grok_4_20_NonReasoning,
+  XaiModels.Grok_4_20_MultiAgent,
+  XaiModels.Grok4_1_Fast_Reasoning,
+  XaiModels.Grok4_1_Fast_NonReasoning,
+];
+
+// Models that support the reasoning_effort parameter
+// grok-3-mini variants support reasoning_effort; grok-3-beta, grok-4 etc. do NOT
+export const XaiReasoningModels: string[] = [
+  XaiModels.Grok_4_20_MultiAgent,
+  XaiModels.Grok3MiniBeta,
+  XaiModels.Grok3MiniFastBeta,
+];
+
+// Deprecated xAI models — "Model not found" (400) when called
+export const XaiDeprecatedTextModels: string[] = [
+  XaiModels.Grok21212, XaiModels.Grok2Vision1212,
+  // Alias IDs from models.dev that map to deprecated/versioned models
+  XaiModels.Grok2Latest, XaiModels.Grok2VisionLatest,
+  XaiModels.Grok3Latest, XaiModels.Grok3FastLatest,
+  XaiModels.Grok3MiniLatest, XaiModels.Grok3MiniFastLatest,
+  XaiModels.GrokBeta, XaiModels.GrokVisionBeta,
+  XaiModels.Grok4_1_Fast, XaiModels.Grok4Fast, XaiModels.Grok4FastNonReasoning,
+];
+export const XaiImageModels: string[] = [XaiModels.GrokImagineImage, XaiModels.Grok2Image1212];
+export const XaiVideoModels: string[] = [XaiModels.GrokImagineVideo];
+
+// ─── Pricing (USD per 1M tokens / per-image / per-second) ────────────────────
+
+export const XaiTextPricing: Record<string, ModelPricing> = {
+  [XaiModels.Grok_4_20_Reasoning]:       { input: 2.0, cache_hit: 0.20, output: 6.0, useResponsesApi: true },
+  [XaiModels.Grok_4_20_NonReasoning]:    { input: 2.0, cache_hit: 0.20, output: 6.0, useResponsesApi: true },
+  [XaiModels.Grok_4_20_MultiAgent]:      { input: 2.0, cache_hit: 0.20, output: 6.0, reasoningLevels: ["low", "medium", "high", "xhigh"], useResponsesApi: true },
+  [XaiModels.Grok4_1_Fast_Reasoning]:    { input: 0.2, cache_hit: 0.05, output: 0.5, useResponsesApi: true },
+  [XaiModels.Grok4_1_Fast_NonReasoning]: { input: 0.2, cache_hit: 0.05, output: 0.5, useResponsesApi: true },
+  [XaiModels.GrokCodeFast]:              { input: 0.2, cache_hit: 0.02, output: 1.5 },
+  [XaiModels.Grok4]:                     { input: 3.0, output: 15.0 },
+  [XaiModels.Grok3Beta]:                 { input: 3.0, output: 15.0 },
+  [XaiModels.Grok3MiniBeta]:             { input: 0.3, output: 0.5 },
+  [XaiModels.Grok3FastBeta]:             { input: 5.0, output: 25.0 },
+  [XaiModels.Grok3MiniFastBeta]:         { input: 0.6, output: 4.0 },
+  [XaiModels.Grok21212]:       { input: 2.0, output: 10.0, deprecated: true },
+  [XaiModels.Grok2Vision1212]: { input: 2.0, output: 10.0, deprecated: true },
+  // Deprecated alias IDs (models.dev uses these; they map to versioned/beta models above)
+  [XaiModels.Grok2Latest]:          { input: 2.0, output: 10.0, deprecated: true },
+  [XaiModels.Grok2VisionLatest]:    { input: 2.0, output: 10.0, deprecated: true },
+  [XaiModels.Grok3Latest]:          { input: 3.0, output: 15.0, deprecated: true },
+  [XaiModels.Grok3FastLatest]:      { input: 5.0, output: 25.0, deprecated: true },
+  [XaiModels.Grok3MiniLatest]:      { input: 0.3, output: 0.5,  deprecated: true },
+  [XaiModels.Grok3MiniFastLatest]:  { input: 0.6, output: 4.0,  deprecated: true },
+  [XaiModels.GrokBeta]:             { input: 5.0, output: 15.0, deprecated: true },
+  [XaiModels.GrokVisionBeta]:       { input: 5.0, output: 15.0, deprecated: true },
+  // grok-4-1-fast / grok-4-fast aliases — deprecated in favor of versioned reasoning/non-reasoning variants
+  [XaiModels.Grok4_1_Fast]:         { input: 0.2, output: 0.5, deprecated: true },
+  [XaiModels.Grok4Fast]:            { input: 0.2, output: 0.5, deprecated: true },
+  [XaiModels.Grok4FastNonReasoning]:{ input: 0.2, output: 0.5, deprecated: true },
 };
 
-// Image generation pricing: per image
-// Based on https://docs.x.ai/developers/models
 export const XaiImagePricing: Record<string, ModelPricing> = {
-  "grok-imagine-image-pro": { image_generation: 0.07 },
-  "grok-imagine-image": { image_generation: 0.02 },
-  "grok-2-image-1212": { image_generation: 0.07 },
+  "grok-imagine-image-pro":        { image_generation: 0.07 },
+  [XaiModels.GrokImagineImage]:    { image_generation: 0.02 },
+  [XaiModels.Grok2Image1212]:      { image_generation: 0.07 },
 };
 
-// Video generation pricing: $0.05 per second
-// Based on https://docs.x.ai/developers/models
 export const XaiVideoPricing: Record<string, ModelPricing> = {
-  "grok-imagine-video": { video_generation: 0.05 }, // per second
+  [XaiModels.GrokImagineVideo]: { video_generation: 0.05 },
 };
+
+// ─── Catalog ──────────────────────────────────────────────────────────────────
+// Metadata (deprecated, useResponsesApi) is read directly from XaiTextPricing entries.
+
+export const XAI_MODEL_CATALOG: ModelCatalogEntry[] = [
+  ...completions([...XaiTextModels, ...XaiDeprecatedTextModels], "xai", XaiTextPricing),
+  ...images(XaiImageModels, "xai", XaiImagePricing),
+  ...videos(XaiVideoModels, "xai", XaiVideoPricing),
+];

package/src/clients/types.ts

@@ -57,6 +57,10 @@ export interface CompletionOptions {
   tools?: Tool[];
   tool_choice?: "auto" | "none";
   max_tokens?: number;
+  /** Reasoning effort level for models that support it.
+   *  Maps to: OpenAI reasoning_effort, xAI reasoning.effort, Gemini thinkingLevel/thinkingBudget, Anthropic thinking budget.
+   *  "low" = minimal thinking, "medium" = balanced, "high" = maximum reasoning */
+  reasoning_effort?: "low" | "medium" | "high";
 }
 
 export interface CompletionResponse {

package/src/clients/xai.ts

@@ -29,6 +29,7 @@ import {
 
 import { Models, XaiImageModels, XaiVideoModels } from "../types";
 import { ModelModality } from "./types";
+import { XaiReasoningModels, XaiResponsesOnlyModels } from "./pricing/xai";
 
 export class GenericXAIClient implements GenericClient {
   private client: OpenAI;
@@ -54,6 +55,11 @@ export class GenericXAIClient implements GenericClient {
   async createChatCompletion(
     options: CompletionOptions
   ): Promise<CompletionResponse> {
+    // Route to Responses API for models that require it
+    if (XaiResponsesOnlyModels.includes(options.model)) {
+      return this.createChatResponse(options);
+    }
+
     const xaiMessages = options.messages.map((msg) => {
       if (msg.role === "tool") {
         return {
@@ -70,6 +76,10 @@ export class GenericXAIClient implements GenericClient {
       model: options.model,
       messages: xaiMessages,
       max_tokens: options.max_tokens,
+      ...(XaiReasoningModels.includes(options.model) && options.reasoning_effort && {
+        // grok-3-mini models support reasoning_effort: "low" | "medium" | "high"
+        reasoning_effort: options.reasoning_effort,
+      }),
       ...(options.tools && {
         tools: options.tools,
         tool_choice: "auto",
@@ -94,6 +104,146 @@ export class GenericXAIClient implements GenericClient {
     };
   }
 
+  /**
+   * Creates a completion using the xAI Responses API (/v1/responses).
+   * Used for grok-4.20 reasoning/non-reasoning and multi-agent models.
+   * Translates Chat Completions message format to Responses API format.
+   */
+  async createChatResponse(
+    options: CompletionOptions
+  ): Promise<CompletionResponse> {
+    const apiKey = this.apiKey || process.env.XAI_API_KEY;
+    if (!apiKey) {
+      throw new Error("XAI API key not set");
+    }
+
+    // Extract system messages as instructions
+    const systemMessages = options.messages.filter((m) => m.role === "system");
+    const nonSystemMessages = options.messages.filter((m) => m.role !== "system");
+    const instructions = systemMessages
+      .map((m) => (typeof m.content === "string" ? m.content : ""))
+      .join("\n")
+      .trim() || undefined;
+
+    // Convert chat messages to Responses API input items
+    const input: any[] = nonSystemMessages.map((msg) => {
+      if (msg.role === "tool") {
+        return {
+          type: "function_call_output",
+          call_id: msg.tool_call_id,
+          output: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+        };
+      }
+      if (msg.role === "assistant" && msg.tool_calls?.length) {
+        return msg.tool_calls.map((tc) => ({
+          type: "function_call",
+          id: tc.id.startsWith("fc") ? tc.id : `fc_${tc.id}`,
+          call_id: tc.id,
+          name: tc.function.name,
+          arguments: tc.function.arguments,
+        }));
+      }
+      return {
+        role: msg.role,
+        content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+      };
+    }).flat();
+
+    // Convert tool definitions to Responses API format
+    const tools = options.tools?.map((tool) => ({
+      type: "function" as const,
+      name: tool.function.name,
+      description: tool.function.description,
+      parameters: tool.function.parameters as Record<string, unknown>,
+      strict: false,
+    }));
+
+    // Resolve reasoning effort, clamping to supported levels if defined in pricing
+    const pricing = XaiTextPricing[options.model];
+    const supportedLevels = pricing?.reasoningLevels;
+    let reasoningEffort: string | undefined = options.reasoning_effort;
+    if (supportedLevels?.length) {
+      if (!reasoningEffort || !supportedLevels.includes(reasoningEffort)) {
+        reasoningEffort = supportedLevels[0];
+      }
+    }
+
+    const body: any = {
+      model: options.model,
+      input,
+      ...(instructions && { instructions }),
+      ...(options.max_tokens && { max_output_tokens: Math.max(options.max_tokens, 16_000) }),
+      ...(reasoningEffort && { reasoning: { effort: reasoningEffort } }),
+      ...(tools?.length && { tools, tool_choice: "auto" }),
+      store: false,
+    };
+
+    const response = await fetch("https://api.x.ai/v1/responses", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`XAI Responses API error: ${response.status} ${errorText}`);
+    }
+
+    const data = await response.json();
+
+    // Map usage
+    const usage = data.usage
+      ? {
+          prompt_tokens: data.usage.input_tokens,
+          completion_tokens: data.usage.output_tokens,
+          total_tokens: data.usage.input_tokens + data.usage.output_tokens,
+        }
+      : undefined;
+
+    const usdCost = usage ? this.calculateCost(options.model, usage) : undefined;
+
+    // Collect text content and tool calls from output items
+    let textContent: string | null = null;
+    const toolCalls: any[] = [];
+
+    for (const item of data.output ?? []) {
+      if (item.type === "message") {
+        for (const part of item.content ?? []) {
+          if (part.type === "output_text") {
+            textContent = (textContent ?? "") + part.text;
+          }
+        }
+      } else if (item.type === "function_call") {
+        toolCalls.push({
+          id: item.call_id,
+          type: "function",
+          function: {
+            name: item.name,
+            arguments: item.arguments,
+          },
+        });
+      }
+    }
+
+    return {
+      choices: [
+        {
+          message: {
+            role: "assistant",
+            content: textContent,
+            ...(toolCalls.length > 0 && { tool_calls: toolCalls }),
+          },
+        },
+      ],
+      model: options.model,
+      usage,
+      usd_cost: usdCost,
+    };
+  }
+
   pricesPerMillion() {
     return XaiTextPricing;
   }

package/src/fileSync.ts

@@ -265,8 +265,14 @@ export async function uploadDirectory(
   for (const relFile of localFiles) {
     const localFilePath = localDir + relFile;
     const remoteFilePath = remoteDir + relFile;
-    await uploadFile(client, s3Service, remoteFilePath, localFilePath, dryRun);
-    count++;
+    try {
+      await uploadFile(client, s3Service, remoteFilePath, localFilePath, dryRun);
+      count++;
+    } catch (error) {
+      console.error(
+        `   ❌ Failed to upload ${localFilePath}, skipping: ${error.message}`
+      );
+    }
   }
   return count;
 }

package/src/login.ts

@@ -29,7 +29,10 @@ export async function login(jwtFlag?: boolean): Promise<void> {
     // Use browser login as default method
     console.log("Starting browser-based authentication...");
     try {
-      const browserLoginService = new BrowserLoginService();
+      // Pass existing orgId from config (if any) so the browser pre-selects the right org
+      const existingConfig = await getConfig();
+      const existingOrgId = existingConfig?.orgId;
+      const browserLoginService = new BrowserLoginService(undefined, existingOrgId);
       await browserLoginService.login();
       console.log("Successfully authenticated via browser!");
     } catch (error) {
@@ -43,6 +46,7 @@ export async function login(jwtFlag?: boolean): Promise<void> {
   try {
     const storedJwt = await loadJwt();
     const { user, currentOrg } = await checkJwt(storedJwt);
+    const orgId = currentOrg?.organizationId;
 
     console.log(
       `Current user: ${user.email}, \nOrganization: ${currentOrg?.organization?.name} - ${currentOrg?.organization?.id}`
@@ -61,9 +65,13 @@ export async function login(jwtFlag?: boolean): Promise<void> {
       config.modelProviders.push({
         provider: "knowhow",
       });
-
-      await updateConfig(config);
     }
+    // Save orgId to config so sync:remote and other features use the correct org
+    if (orgId) {
+      config.orgId = orgId;
+    }
+
+    await updateConfig(config);
   } catch (error) {
     if (http.isHttpError(error) && error.response) {
       const errData = await error.response.json().catch(() => ({ message: "Unknown error" }));

package/src/services/AgentSyncFs.ts

@@ -121,7 +121,11 @@ export class AgentSyncFs {
   /**
    * Update metadata file with current agent state
    */
-  private async updateMetadata(agent: BaseAgent, inProgress: boolean, result?: string): Promise<void> {
+  private async updateMetadata(
+    agent: BaseAgent,
+    inProgress: boolean,
+    result?: string
+  ): Promise<void> {
     if (!this.taskPath) return;
 
     try {
@@ -137,7 +141,8 @@ export class AgentSyncFs {
 
       metadata.threads = agent.getThreads();
       metadata.totalCostUsd = agent.getTotalCostUsd();
-    metadata.agentName = agent.name;
+      metadata.tokenUsage = agent.getTokenUsage();
+      metadata.agentName = agent.name;
       metadata.inProgress = inProgress;
       metadata.lastUpdate = new Date().toISOString();
 
@@ -147,7 +152,11 @@ export class AgentSyncFs {
         await this.writeStatus("completed");
       }
 
-      await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf8");
+      await fs.writeFile(
+        metadataPath,
+        JSON.stringify(metadata, null, 2),
+        "utf8"
+      );
     } catch (error) {
       console.error(`❌ Failed to update metadata:`, error);
     }
@@ -206,7 +215,9 @@ export class AgentSyncFs {
       // Check for new input/messages
       const input = await this.readInput();
       if (input && input !== this.lastInputContent && input.trim() !== "") {
-        console.log(`📬 New message received via filesystem for task ${this.taskId}`);
+        console.log(
+          `📬 New message received via filesystem for task ${this.taskId}`
+        );
         this.lastInputContent = input;
 
         agent.addPendingUserMessage({
@@ -234,7 +245,7 @@ export class AgentSyncFs {
       await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
 
       const status = await this.readStatus();
-      
+
       if (status === "killed") {
         console.log(`🛑 Agent task ${this.taskId} killed while paused`);
         await agent.kill();
@@ -314,7 +325,10 @@ export class AgentSyncFs {
         console.error(`❌ Error during threadUpdate sync:`, error);
       }
     };
-    agent.agentEvents.on(agent.eventTypes.threadUpdate, this.threadUpdateHandler);
+    agent.agentEvents.on(
+      agent.eventTypes.threadUpdate,
+      this.threadUpdateHandler
+    );
 
     // Listen to completion event to finalize task (store reference for cleanup)
     this.doneHandler = (result: string) => {
@@ -323,7 +337,9 @@ export class AgentSyncFs {
         return;
       }
 
-      console.log(`🎯 [AgentSyncFs] Done event received for task: ${this.taskId}`);
+      console.log(
+        `🎯 [AgentSyncFs] Done event received for task: ${this.taskId}`
+      );
 
       // Store finalization promise so callers can await it (same pattern as AgentSyncKnowhowWeb)
       this.finalizationPromise = (async () => {
@@ -332,7 +348,9 @@ export class AgentSyncFs {
           // This prevents the race where a pending "inProgress: true" metadata write
           // overwrites the finalization write.
           if (this.pendingThreadUpdatePromise) {
-            console.log(`⏳ [AgentSyncFs] Awaiting pending thread update before finalizing...`);
+            console.log(
+              `⏳ [AgentSyncFs] Awaiting pending thread update before finalizing...`
+            );
             await this.pendingThreadUpdatePromise.catch(() => {
               // Ignore errors in pending update — we still want to finalize
             });
@@ -379,7 +397,7 @@ export class AgentSyncFs {
   private static async cleanupOldTasks(): Promise<void> {
     try {
       const agentsPath = AgentSyncFs.sharedBasePath;
-      
+
       // Check if directory exists
       try {
         await fs.access(agentsPath);
@@ -396,7 +414,7 @@ export class AgentSyncFs {
         if (!entry.isDirectory()) continue;
 
         const taskPath = path.join(agentsPath, entry.name);
-        
+
         try {
           const stats = await fs.stat(taskPath);
           const age = now - stats.mtimeMs;
@@ -449,11 +467,17 @@ export class AgentSyncFs {
     // Remove old event listeners from the agent before resetting
     if (this.agent) {
       if (this.threadUpdateHandler) {
-        this.agent.agentEvents.removeListener(this.agent.eventTypes.threadUpdate, this.threadUpdateHandler);
+        this.agent.agentEvents.removeListener(
+          this.agent.eventTypes.threadUpdate,
+          this.threadUpdateHandler
+        );
         this.threadUpdateHandler = undefined;
       }
       if (this.doneHandler) {
-        this.agent.agentEvents.removeListener(this.agent.eventTypes.done, this.doneHandler);
+        this.agent.agentEvents.removeListener(
+          this.agent.eventTypes.done,
+          this.doneHandler
+        );
         this.doneHandler = undefined;
       }
       this.agent = undefined;