@tyvm/knowhow 0.0.104 → 0.0.105

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.104",
+  "version": "0.0.105",
   "description": "ai cli with plugins and agents",
   "main": "ts_build/src/index.js",
   "bin": {

package/src/clients/index.ts

@@ -30,6 +30,32 @@ import { ModelProvider } from "../types";
 import { getConfig } from "../config";
 import { loadKnowhowJwt, KNOWHOW_API_URL } from "../services/KnowhowClient";
 import { ContextLimits } from "./contextLimits";
+import { OpenAiTextPricing } from "./pricing/openai";
+import { AnthropicTextPricing } from "./pricing/anthropic";
+import { GeminiPricing } from "./pricing/google";
+import {
+  XaiTextPricing,
+  XaiImagePricing,
+  XaiVideoPricing,
+} from "./pricing/xai";
+import type {
+  ModelPricing,
+  ModelType,
+  ModelCatalogEntry,
+} from "./pricing/types";
+export {
+  OpenAiTextPricing,
+  AnthropicTextPricing,
+  GeminiPricing,
+  XaiTextPricing,
+  XaiImagePricing,
+  XaiVideoPricing,
+};
+export type {
+  ModelPricing,
+  ModelType,
+  ModelCatalogEntry,
+} from "./pricing/types";
 
 // ---------------------------------------------------------------------------
 // Built-in provider registry
@@ -219,7 +245,9 @@ export class AIClient {
 
       if (!client) {
         if (entry.provider === "knowhow") {
-          console.warn(`⚠️  Knowhow provider is not logged in. Run 'knowhow login' to enable Knowhow models.`);
+          console.warn(
+            `⚠️  Knowhow provider is not logged in. Run 'knowhow login' to enable Knowhow models.`
+          );
         }
         continue;
       }
@@ -499,17 +527,22 @@ export class AIClient {
     }
 
     const allModels = this.listAllModels();
-    const hasKnowhowModels =
-      allModels["knowhow"] && allModels["knowhow"].length > 0;
+    const hasKnowhowModels = allModels.knowhow && allModels.knowhow.length > 0;
     const knowhowIsConfigured = Object.keys(allModels).includes("knowhow");
 
-    console.warn(`⚠️  Unable to find model '${model}' for provider '${provider}'.`);
-    console.warn(`   Available providers: ${Object.keys(allModels).join(", ") || "(none)"}`);
+    console.warn(
+      `⚠️  Unable to find model '${model}' for provider '${provider}'.`
+    );
+    console.warn(
+      `   Available providers: ${Object.keys(allModels).join(", ") || "(none)"}`
+    );
 
     if (!hasKnowhowModels && !knowhowIsConfigured) {
       console.warn(`   Tip: Run 'knowhow login' to enable Knowhow models.`);
     } else if (!hasKnowhowModels) {
-      console.warn(`   Tip: The Knowhow provider returned no models. Try running 'knowhow login' to re-authenticate.`);
+      console.warn(
+        `   Tip: The Knowhow provider returned no models. Try running 'knowhow login' to re-authenticate.`
+      );
     }
 
     return { provider, model };
@@ -763,6 +796,67 @@ export class AIClient {
     if (contextLimit === undefined) return undefined;
     return { contextLimit, threshold: contextLimit };
   }
+
+  /**
+   * Returns pricing information for all known models, derived from the
+   * provider pricing maps.
+   *
+   * @param modelId  Optional model id filter (without provider prefix).
+   *                 If omitted, all models across all providers are returned.
+   */
+  getPrices(modelId?: string): ModelCatalogEntry[] {
+    const results: ModelCatalogEntry[] = [];
+
+    const addModels = (
+      models: Record<string, string[]>,
+      type: ModelType,
+      pricingMap: Record<string, ModelPricing>
+    ) => {
+      for (const [provider, ids] of Object.entries(models)) {
+        for (const id of ids) {
+          if (modelId && id !== modelId) continue;
+          if (!pricingMap[id]) continue;
+
+          const p = pricingMap[id];
+          results.push({
+            id,
+            provider,
+            type,
+            displayName: id,
+            pricing: p,
+          });
+        }
+      }
+    };
+
+    // Build a combined pricing map across all providers
+    const allTextPricing: Record<string, ModelPricing> = {
+      ...OpenAiTextPricing,
+      ...AnthropicTextPricing,
+      ...GeminiPricing,
+      ...XaiTextPricing,
+    };
+    const allImagePricing: Record<string, ModelPricing> = {
+      ...XaiImagePricing,
+    };
+    const allVideoPricing: Record<string, ModelPricing> = {
+      ...XaiVideoPricing,
+    };
+
+    addModels(this.completionModels, "completion", allTextPricing);
+    addModels(this.embeddingModels, "embedding", allTextPricing);
+    addModels(this.imageModels, "image", {
+      ...allTextPricing,
+      ...allImagePricing,
+    });
+    addModels(this.audioModels, "audio", allTextPricing);
+    addModels(this.videoModels, "video", {
+      ...allTextPricing,
+      ...allVideoPricing,
+    });
+
+    return results;
+  }
 }
 
 export const Clients = new AIClient();

package/src/clients/pricing/index.ts

@@ -2,5 +2,5 @@ export { OpenAiTextPricing } from "./openai";
 export { GeminiTextPricing } from "./google";
 export { AnthropicTextPricing } from "./anthropic";
 export { XaiTextPricing, XaiImagePricing, XaiVideoPricing } from "./xai";
-export { ALL_MODEL_CATALOG, OPENAI_MODEL_CATALOG, ANTHROPIC_MODEL_CATALOG, GOOGLE_MODEL_CATALOG, XAI_MODEL_CATALOG, USAGE_MARKUP_PERCENT } from "./catalog";
-export type { ModelCatalogEntry, ModelType, ModelPricing as CatalogModelPricing } from "./catalog";
+export { ALL_MODEL_CATALOG, OPENAI_MODEL_CATALOG, ANTHROPIC_MODEL_CATALOG, GOOGLE_MODEL_CATALOG, XAI_MODEL_CATALOG, USAGE_MARKUP_PERCENT } from "./models";
+export type { ModelCatalogEntry, ModelType, ModelPricing as CatalogModelPricing } from "./types";

package/src/clients/pricing/{catalog.ts → models.ts}

@@ -12,38 +12,9 @@ import { OpenAiTextPricing } from "./openai";
 import { AnthropicTextPricing } from "./anthropic";
 import { GeminiPricing } from "./google";
 import { XaiTextPricing, XaiImagePricing, XaiVideoPricing } from "./xai";
+import { ModelPricing, ModelType, ModelCatalogEntry } from "./types";
 
-export type ModelType =
-  | "completion"
-  | "embedding"
-  | "image"
-  | "audio"
-  | "video"
-  | "transaction";
-
-export interface ModelPricing {
-  input: number;
-  output: number;
-  cached_input?: number;
-  cache_write?: number;
-  cache_hit?: number;
-  input_audio?: number;
-  output_audio?: number;
-  input_gt_200k?: number;
-  output_gt_200k?: number;
-  image_generation?: number;
-  video_generation?: number;
-}
-
-export interface ModelCatalogEntry {
-  id: string;
-  provider: string;
-  type: ModelType;
-  displayName: string;
-  pricing: ModelPricing;
-  /** Markup applied on top of base pricing (as a fraction, e.g. 0.025 = 2.5%) */
-  markupPercent: number;
-}
+export { ModelPricing, ModelType, ModelCatalogEntry };
 
 // ─── Platform markup ──────────────────────────────────────────────────────────
 
@@ -69,7 +40,6 @@ function completion(
     provider,
     type: "completion",
     displayName,
-    markupPercent: USAGE_MARKUP_PERCENT,
     pricing: {
       input: 0,
       output: 0,
@@ -90,7 +60,6 @@ function embedding(
     provider,
     type: "embedding",
     displayName,
-    markupPercent: USAGE_MARKUP_PERCENT,
     pricing: { input, output: 0 },
   };
 }
@@ -106,7 +75,6 @@ function image(
     provider,
     type: "image",
     displayName,
-    markupPercent: USAGE_MARKUP_PERCENT,
     pricing: { input: 0, output: 0, ...pricing },
   };
 }
@@ -122,7 +90,6 @@ function video(
     provider,
     type: "video",
     displayName,
-    markupPercent: USAGE_MARKUP_PERCENT,
     pricing: { input: 0, output: 0, video_generation },
   };
 }
@@ -138,7 +105,6 @@ function audio(
     provider,
     type: "audio",
     displayName,
-    markupPercent: USAGE_MARKUP_PERCENT,
     pricing: { input: 0, output: 0, ...pricing },
   };
 }
@@ -154,7 +120,6 @@ function transaction(
     provider,
     type: "transaction",
     displayName,
-    markupPercent: USAGE_MARKUP_PERCENT,
     pricing: { input: 0, output: 0, ...pricing },
   };
 }
@@ -271,10 +236,10 @@ export const XAI_MODEL_CATALOG: ModelCatalogEntry[] = [
   completion(Models.xai.Grok3FastBeta, "xai", "Grok 3 Fast Beta"),
   completion(Models.xai.Grok21212, "xai", "Grok 2"),
   // Image generation
-  image(Models.xai.GrokImagineImage, "xai", "Grok Imagine Image", { image_generation: XaiImagePricing["grok-imagine-image"] ?? 0.02 }),
-  image("grok-2-image-1212", "xai", "Grok 2 Image", { image_generation: XaiImagePricing["grok-2-image-1212"] ?? 0.07 }),
+  image(Models.xai.GrokImagineImage, "xai", "Grok Imagine Image", { image_generation: XaiImagePricing["grok-imagine-image"]?.image_generation ?? 0.02 }),
+  image("grok-2-image-1212", "xai", "Grok 2 Image", { image_generation: XaiImagePricing["grok-2-image-1212"]?.image_generation ?? 0.07 }),
   // Video generation
-  video(Models.xai.GrokImagineVideo, "xai", "Grok Imagine Video", XaiVideoPricing["grok-imagine-video"] ?? 0.05),
+  video(Models.xai.GrokImagineVideo, "xai", "Grok Imagine Video", XaiVideoPricing["grok-imagine-video"]?.video_generation ?? 0.05),
 ];
 
 // ─── Combined catalog ─────────────────────────────────────────────────────────

package/src/clients/pricing/types.ts

@@ -0,0 +1,29 @@
+export type ModelType =
+  | "completion"
+  | "embedding"
+  | "image"
+  | "audio"
+  | "video"
+  | "transaction";
+
+export interface ModelPricing {
+  input?: number;
+  output?: number;
+  cached_input?: number;
+  cache_write?: number;
+  cache_hit?: number;
+  input_audio?: number;
+  output_audio?: number;
+  input_gt_200k?: number;
+  output_gt_200k?: number;
+  image_generation?: number;
+  video_generation?: number;
+}
+
+export interface ModelCatalogEntry {
+  id: string;
+  provider: string;
+  type: ModelType;
+  displayName: string;
+  pricing: ModelPricing;
+}

package/src/clients/pricing/xai.ts

@@ -1,4 +1,5 @@
 import { Models } from "../../types";
+import { ModelPricing } from "./types";
 
 export const XaiTextPricing = {
 
@@ -60,14 +61,14 @@ export const XaiTextPricing = {
 
 // Image generation pricing: per image
 // Based on https://docs.x.ai/developers/models
-export const XaiImagePricing = {
-  "grok-imagine-image-pro": 0.07,
-  "grok-imagine-image": 0.02,
-  "grok-2-image-1212": 0.07,
+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 },
 };
 
 // Video generation pricing: $0.05 per second
 // Based on https://docs.x.ai/developers/models
-export const XaiVideoPricing = {
-  "grok-imagine-video": 0.05, // per second
+export const XaiVideoPricing: Record<string, ModelPricing> = {
+  "grok-imagine-video": { video_generation: 0.05 }, // per second
 };

package/src/clients/xai.ts

@@ -175,7 +175,7 @@ export class GenericXAIClient implements GenericClient {
     // Calculate cost based on model name
     const imageModel = options.model || "grok-imagine-image";
     const costPerImage =
-      XaiImagePricing[imageModel as keyof typeof XaiImagePricing] || 0.02;
+      XaiImagePricing[imageModel as keyof typeof XaiImagePricing]?.image_generation || 0.02;
     const usdCost = (options.n || 1) * costPerImage;
 
     return {
@@ -250,7 +250,7 @@ export class GenericXAIClient implements GenericClient {
     // Return immediately with the jobId – do NOT poll here.
     // Use getVideoStatus() to poll and downloadVideo() to fetch the result.
     const duration = options.duration || 5;
-    const pricePerSecond = XaiVideoPricing[model] || 0.07;
+    const pricePerSecond = XaiVideoPricing[model]?.video_generation || 0.07;
     const usdCost = duration * pricePerSecond;
 
     return {

package/src/services/SyncedAgentWatcher.ts

@@ -5,11 +5,6 @@
 
 import { Message } from "../clients/types";
 import { EventService } from "./EventService";
-import * as fs from "fs";
-import * as fsPromises from "fs/promises";
-import * as path from "path";
-import { messagesToRenderEvents } from "../chat/renderer/messagesToRenderEvents";
-import { KnowhowSimpleClient } from "./KnowhowClient";
 
 export interface SyncedAgentWatcher {
   /** Start watching for changes, emitting agent events */
@@ -27,7 +22,13 @@ export interface SyncedAgentWatcher {
   /** EventService that emits agent lifecycle events (toolCall, toolUsed, agentSay, threadUpdate, done) */
   agentEvents: EventService;
   /** Event type constants mirroring BaseAgent.eventTypes */
-  eventTypes: { done: string; toolCall: string; toolUsed: string; agentSay: string; threadUpdate: string };
+  eventTypes: {
+    done: string;
+    toolCall: string;
+    toolUsed: string;
+    agentSay: string;
+    threadUpdate: string;
+  };
   /** Pause the remote agent */
   pause(): Promise<void>;
   /** Unpause/resume the remote agent */
@@ -44,7 +45,12 @@ export interface SyncedAgentWatcher {
 export interface AttachableAgent {
   name: string;
   agentEvents: EventService;
-  eventTypes: { done: string; toolCall?: string; toolUsed?: string; agentSay?: string };
+  eventTypes: {
+    done: string;
+    toolCall?: string;
+    toolUsed?: string;
+    agentSay?: string;
+  };
   getTotalCostUsd(): number;
   pause(): void | Promise<void>;
   unpause(): void | Promise<void>;
@@ -104,294 +110,3 @@ export class WatcherBackedAgent implements AttachableAgent {
       });
   }
 }
-
-/**
- * Watches an agent running in another process via the filesystem.
- * Reads .knowhow/processes/agents/<taskId>/metadata.json for changes.
- * Sends messages by writing to .knowhow/processes/agents/<taskId>/input.txt
- */
-export class FsSyncedAgentWatcher implements SyncedAgentWatcher {
-  public taskId: string = "";
-  private taskPath: string = "";
-  private watcher: fs.FSWatcher | null = null;
-  private lastThreadLength: number = 0;
-  public agentName: string = "unknown";
-  private debounceTimer: NodeJS.Timeout | null = null;
-  public agentEvents = new EventService();
-  public eventTypes = {
-    done: "done",
-    toolCall: "tool:pre_call",
-    toolUsed: "tool:post_call",
-    agentSay: "agent:say",
-    threadUpdate: "thread_update",
-  };
-
-  async startWatching(taskId: string): Promise<void> {
-    this.taskId = taskId;
-    this.taskPath = path.join(".knowhow/processes/agents", taskId);
-
-    // Load initial state to track current thread length (for delta rendering)
-    const metadata = await this.readMetadata();
-    if (metadata) {
-      const threads: any[][] = metadata.threads || [];
-      const lastThread = threads[threads.length - 1] || [];
-      this.agentName = metadata.agentName || taskId;
-      this.lastThreadLength = lastThread.length;
-    }
-
-    // Watch the directory for metadata.json changes
-    try {
-      this.watcher = fs.watch(this.taskPath, (event, filename) => {
-        if (filename === "metadata.json" || filename === null) {
-          // Debounce rapid file writes
-          if (this.debounceTimer) clearTimeout(this.debounceTimer);
-          this.debounceTimer = setTimeout(() => {
-            this.onMetadataChanged().catch(() => {});
-          }, 200);
-        }
-      });
-    } catch (err: any) {
-      console.warn(`⚠️  Could not watch ${this.taskPath}: ${err.message}`);
-    }
-
-    console.log(`👁️  Watching fs-synced agent: ${taskId} (${this.agentName})`);
-    console.log(
-      `   Type /logs 20 to see recent messages, or type to send a message`
-    );
-  }
-
-  private async onMetadataChanged(): Promise<void> {
-    const metadata = await this.readMetadata();
-    if (!metadata?.threads) return;
-
-    const threads: any[][] = metadata.threads;
-    const lastThread = threads[threads.length - 1] || [];
-
-    // Only render NEW messages since last check
-    const newMessages = lastThread.slice(this.lastThreadLength);
-    if (newMessages.length > 0) {
-      const renderEvents = messagesToRenderEvents(
-        newMessages,
-        this.taskId,
-        this.agentName
-      );
-      for (const event of renderEvents) {
-        if (event.type === "toolCall") {
-          this.agentEvents.emit(this.eventTypes.toolCall, {
-            toolCall: (event as any).toolCall,
-          });
-        } else if (event.type === "toolResult") {
-          this.agentEvents.emit(this.eventTypes.toolUsed, {
-            toolCall: (event as any).toolCall,
-            functionResp: (event as any).result,
-          });
-        } else if (event.type === "agentMessage") {
-          this.agentEvents.emit(this.eventTypes.agentSay, {
-            message: (event as any).message,
-          });
-        }
-      }
-      this.agentEvents.emit(this.eventTypes.threadUpdate, lastThread);
-      this.lastThreadLength = lastThread.length;
-    }
-
-    // Emit done if the agent has completed and has a result
-    const status = metadata.status;
-    const result = metadata.result;
-    if ((status === "completed" || status === "killed") && result != null) {
-      this.stopWatching();
-      this.agentEvents.emit(this.eventTypes.done, result);
-    }
-  }
-
-  async sendMessage(message: string): Promise<void> {
-    const inputPath = path.join(this.taskPath, "input.txt");
-    await fsPromises.writeFile(inputPath, message, "utf8");
-  }
-
-  async getThreads(): Promise<any[][]> {
-    const metadata = await this.readMetadata();
-    return metadata?.threads || [];
-  }
-
-  stopWatching(): void {
-    if (this.debounceTimer) {
-      clearTimeout(this.debounceTimer);
-      this.debounceTimer = null;
-    }
-    this.watcher?.close();
-    this.watcher = null;
-    console.log(`🔌 Stopped watching agent: ${this.taskId}`);
-  }
-
-  async pause(): Promise<void> {
-    const statusPath = path.join(this.taskPath, "status.txt");
-    await fsPromises.writeFile(statusPath, "paused", "utf8");
-    console.log(`⏸️  Paused remote agent: ${this.taskId}`);
-  }
-
-  async unpause(): Promise<void> {
-    const statusPath = path.join(this.taskPath, "status.txt");
-    await fsPromises.writeFile(statusPath, "running", "utf8");
-    console.log(`▶️  Unpaused remote agent: ${this.taskId}`);
-  }
-
-  async kill(): Promise<void> {
-    const statusPath = path.join(this.taskPath, "status.txt");
-    await fsPromises.writeFile(statusPath, "killed", "utf8");
-    console.log(`🛑 Killed remote agent: ${this.taskId}`);
-  }
-
-  private async readMetadata(): Promise<any> {
-    try {
-      const metaPath = path.join(this.taskPath, "metadata.json");
-      const content = await fsPromises.readFile(metaPath, "utf8");
-      return JSON.parse(content);
-    } catch {
-      return null;
-    }
-  }
-}
-
-/**
- * Watches an agent running on Knowhow Web via polling the API.
- * Polls GET /tasks/<taskId> every 3 seconds for thread updates.
- * Sends messages via the client's sendMessageToAgent method.
- */
-export class WebSyncedAgentWatcher implements SyncedAgentWatcher {
-  public taskId: string = "";
-  private client: KnowhowSimpleClient;
-  private pollInterval: NodeJS.Timeout | null = null;
-  private lastThreadLength: number = 0;
-  public agentName: string = "remote-agent";
-  private stopped: boolean = false;
-  public agentEvents = new EventService();
-  public eventTypes = {
-    done: "done",
-    toolCall: "tool:pre_call",
-    toolUsed: "tool:post_call",
-    agentSay: "agent:say",
-    threadUpdate: "thread_update",
-  };
-
-  constructor(client?: KnowhowSimpleClient) {
-    this.client = client || new KnowhowSimpleClient();
-  }
-
-  async startWatching(taskId: string): Promise<void> {
-    this.taskId = taskId;
-    this.stopped = false;
-
-    // Load initial state to track current thread length
-    try {
-      const details = await this.client.getTaskDetails(taskId);
-      const threads: any[][] = details?.data?.threads || [];
-      const lastThread = threads[threads.length - 1] || [];
-      this.agentName = "remote-agent";
-      this.lastThreadLength = lastThread.length;
-    } catch (err: any) {
-      console.warn(
-        `⚠️  Could not load initial state for task ${taskId}: ${err.message}`
-      );
-    }
-
-    // Poll every 3 seconds for updates
-    this.pollInterval = setInterval(async () => {
-      if (!this.stopped) {
-        await this.onPoll().catch(() => {});
-      }
-    }, 3000);
-
-    console.log(`🌐 Watching web-synced agent: ${taskId} (${this.agentName})`);
-    console.log(
-      `   Type /logs 20 to see recent messages, or type to send a message`
-    );
-  }
-
-  private async onPoll(): Promise<void> {
-    if (this.stopped) return;
-    try {
-      const details = await this.client.getTaskDetails(this.taskId);
-      const threads: any[][] = details?.data?.threads || [];
-      const lastThread = threads[threads.length - 1] || [];
-
-      const newMessages = lastThread.slice(this.lastThreadLength);
-      if (newMessages.length > 0) {
-        const renderEvents = messagesToRenderEvents(
-          newMessages,
-          this.taskId,
-          this.agentName
-        );
-        for (const event of renderEvents) {
-          if (event.type === "toolCall") {
-            this.agentEvents.emit(this.eventTypes.toolCall, {
-              toolCall: (event as any).toolCall,
-            });
-          } else if (event.type === "toolResult") {
-            this.agentEvents.emit(this.eventTypes.toolUsed, {
-              toolCall: (event as any).toolCall,
-              functionResp: (event as any).result,
-            });
-          } else if (event.type === "agentMessage") {
-            this.agentEvents.emit(this.eventTypes.agentSay, {
-              message: (event as any).message,
-            });
-          }
-        }
-        this.agentEvents.emit(this.eventTypes.threadUpdate, lastThread);
-        this.lastThreadLength = lastThread.length;
-      }
-
-      // Stop polling and emit done if task is complete with a result
-      const status = details?.data?.status;
-      const result = details?.data?.result;
-      if (status === "completed" || status === "killed") {
-        this.stopWatching();
-        if (result != null) {
-          this.agentEvents.emit(this.eventTypes.done, result);
-        } else {
-          console.log(`\n✅ Remote agent ${this.taskId} status: ${status} (no result)`);
-        }
-      }
-    } catch {
-      // Silently continue on poll errors
-    }
-  }
-
-  async sendMessage(message: string): Promise<void> {
-    await this.client.sendMessageToAgent(this.taskId, message);
-  }
-
-  async getThreads(): Promise<any[][]> {
-    try {
-      const details = await this.client.getTaskDetails(this.taskId);
-      return details?.data?.threads || [];
-    } catch {
-      return [];
-    }
-  }
-
-  stopWatching(): void {
-    this.stopped = true;
-    if (this.pollInterval) {
-      clearInterval(this.pollInterval);
-      this.pollInterval = null;
-    }
-    console.log(`🔌 Stopped watching web agent: ${this.taskId}`);
-  }
-
-  async pause(): Promise<void> {
-    await this.client.pauseAgent(this.taskId);
-    console.log(`⏸️  Paused remote web agent: ${this.taskId}`);
-  }
-
-  async unpause(): Promise<void> {
-    await this.client.resumeAgent(this.taskId);
-    console.log(`▶️  Unpaused remote web agent: ${this.taskId}`);
-  }
-
-  async kill(): Promise<void> {
-    await this.client.killAgent(this.taskId);
-    console.log(`🛑 Killed remote web agent: ${this.taskId}`);
-  }
-}

package/src/services/index.ts

@@ -32,6 +32,7 @@ export * from "./SessionManager";
 export * from "./TaskRegistry";
 export * from "./SyncedAgentWatcher";
 export * from "./SyncerService";
+export * from "./watchers";
 export { Clients } from "../clients";
 
 let Singletons = {} as {