@tyvm/knowhow 0.0.104 → 0.0.106

package/src/types.ts

@@ -4,7 +4,6 @@ import { WebSocket } from "ws";
 export type Hashes = {
   [file: string]: {
     [promptHash: string]: string;
-
     promptHash: string;
     fileHash: string;
   };
@@ -38,37 +37,25 @@ export type Config = {
   openaiBaseUrl?: string;
   promptsDir: string;
   lintCommands?: { [fileExtension: string]: string };
-
+  orgId?: string;
   syncRemote?: boolean;
-
   micCommand?: string;
   defaultMic?: string;
-
   sources: GenerationSource[];
   embedSources: EmbedSource[];
   embeddingModel: string;
-
   skills?: string[];
-
   plugins: { enabled: string[]; disabled: string[] };
-
   chat?: {
-    /** Path to a custom root chat module (npm package or local file) */
     rootModule?: string;
-    /** Path to a custom renderer (npm package or local file, can be .ts) */
     renderer?: string;
-    /** Additional chat modules to load (npm packages or local files, can be .ts) */
     modules?: string[];
   };
-
   modules: string[];
-
   pluginPackages?: Record<string, string>;
-
   agents: Assistant[];
   mcps: McpConfig[];
   modelProviders: ModelProvider[];
-
   ycmd?: {
     enabled?: boolean;
     installPath?: string;
@@ -76,13 +63,11 @@ export type Config = {
     logLevel?: "debug" | "info" | "warning" | "error";
     completionTimeout?: number;
   };
-
   files?: {
-    remotePath: string; // path in Knowhow FS, e.g. "/docs/readme.md" or "/configs/"
-    localPath: string; // local path to write to, e.g. "./docs/readme.md" or "./configs/"
-    direction?: "download" | "upload" | "sync"; // default: "download"
+    remotePath: string;
+    localPath: string;
+    direction?: "download" | "upload" | "sync";
   }[];
-
   worker?: {
     allowedTools?: string[];
     workerId?: string;
@@ -92,24 +77,20 @@ export type Config = {
     auth?: {
       required?: boolean;
       passkey?: {
-        publicKey?: string; // base64-encoded public key
-        credentialId?: string; // base64-encoded credential ID
-        algorithm?: string; // e.g. "ES256"
+        publicKey?: string;
+        credentialId?: string;
+        algorithm?: string;
       };
       sessionDurationHours?: number;
     };
-    commandAuth?: {
-      [toolName: string]: "always" | "session" | "never";
-    };
+    commandAuth?: { [toolName: string]: "always" | "session" | "never" };
     tunnel?: {
       enabled?: boolean;
       allowedPorts?: number[];
       maxConcurrentStreams?: number;
-      portMapping?: {
-        [containerPort: number]: number; // containerPort -> hostPort
-      };
-      localHost?: string; // Default: "127.0.0.1", can be "host.docker.internal" for Docker
-      enableUrlRewriting?: boolean; // Enable URL rewriting for localhost URLs (default: true)
+      portMapping?: { [containerPort: number]: number };
+      localHost?: string;
+      enableUrlRewriting?: boolean;
     };
   };
 };
@@ -124,7 +105,7 @@ export type Assistant = {
 
 export type McpConfig = {
   name: string;
-  autoConnect?: boolean; // Default: true - connect at startup. Set to false for on-demand connection
+  autoConnect?: boolean;
   command?: string;
   url?: string;
   args?: string[];
@@ -140,6 +121,10 @@ export type ModelProvider = {
   envKey?: string;
   headers?: { [key: string]: string };
   jwtFile?: string;
+  timeout?: number;
+  extra_body?: Record<string, any>;
+  /** Optional pricing map (model id → per-million-token prices) passed to HttpClient.setPrices() */
+  pricing?: Record<string, { input?: number; output?: number; cached_input?: number; cache_hit?: number }>;
 };
 
 export type AssistantConfig = {
@@ -153,17 +138,13 @@ export interface Embeddable<T = any> {
   metadata: T;
 }
 
-export type MinimalEmbedding<T = any> = Pick<
-  Embeddable<T>,
-  "id" | "text" | "metadata"
->;
+export type MinimalEmbedding<T = any> = Pick<Embeddable<T>, "id" | "text" | "metadata">;
 
 export interface EmbeddingBase<T = any> extends Embeddable<T> {
   similarity?: number;
 }
 
 export type GptQuestionEmbedding = any & EmbeddingBase;
-
 export type DatasourceType = "file" | "url" | "text";
 
 export interface IDatasource {
@@ -186,150 +167,55 @@ export type ChatInteraction = {
   taskId: string;
 };
 
-export const Models = {
-  anthropic: {
-    Opus4_6: "claude-opus-4-6",
-    Sonnet4_6: "claude-sonnet-4-6",
-    Opus4_5: "claude-opus-4-5",
-    Opus4: "claude-opus-4",
-    Opus4_1: "claude-opus-4-1",
-    Sonnet4_5: "claude-sonnet-4-5",
-    Haiku4_5: "claude-haiku-4-5",
-    Sonnet4: "claude-sonnet-4",
-    Sonnet3_7: "claude-3-7-sonnet",
-    Sonnet3_5: "claude-3-5-sonnet",
-    Opus3: "claude-3-opus",
-    Haiku3: "claude-3-haiku",
-  },
-  xai: {
-    Grok_4_20_Reasoning: "grok-4.20-0309-reasoning",
-    Grok_4_20_NonReasoning: "grok-4.20-0309-non-reasoning",
-    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",
-    Grok21212: "grok-2-1212",
-    Grok2Vision1212: "grok-2-vision-1212",
-    GrokImagineImage: "grok-imagine-image",
-    GrokImagineVideo: "grok-imagine-video",
-  },
-  openai: {
-    GPT_5_2: "gpt-5.2",
-    GPT_5_1: "gpt-5.1",
-    GPT_54: "gpt-5.4",
-    GPT_54_Mini: "gpt-5.4-mini",
-    GPT_54_Nano: "gpt-5.4-nano",
-    GPT_54_Pro: "gpt-5.4-pro",
-    GPT_53_Chat: "gpt-5.3-chat-latest",
-    GPT_53_Codex: "gpt-5.3-codex",
-    GPT_5: "gpt-5",
-    GPT_5_Mini: "gpt-5-mini",
-    GPT_5_Nano: "gpt-5-nano",
-    GPT_41: "gpt-4.1-2025-04-14",
-    GPT_41_Mini: "gpt-4.1-mini-2025-04-14",
-    GPT_41_Nano: "gpt-4.1-nano-2025-04-14",
-    GPT_45: "gpt-4.5-preview-2025-02-27",
-    GPT_4o: "gpt-4o-2024-08-06",
-    GPT_4o_Audio: "gpt-4o-audio-preview-2024-12-17",
-    GPT_4o_Realtime: "gpt-4o-realtime-preview-2024-12-17",
-    GPT_4o_Mini: "gpt-4o-mini-2024-07-18",
-    GPT_4o_Mini_Audio: "gpt-4o-mini-audio-preview-2024-12-17",
-    GPT_4o_Mini_Realtime: "gpt-4o-mini-realtime-preview-2024-12-17",
-    o1: "o1-2024-12-17",
-    o1_Pro: "o1-pro-2025-03-19",
-    o3: "o3-2025-04-16",
-    o3_Pro: "o3-pro-2025-01-31",
-    o4_Mini: "o4-mini-2025-04-16",
-    o3_Mini: "o3-mini-2025-01-31",
-    o1_Mini: "o1-mini-2024-09-12",
-    GPT_4o_Mini_Search: "gpt-4o-mini-search-preview-2025-03-11",
-    GPT_4o_Search: "gpt-4o-search-preview-2025-03-11",
+// ─── Model IDs ────────────────────────────────────────────────────────────────
+// Each provider's pricing file is the single source of truth.
+
+import { AnthropicModels, AnthropicTextModels } from "./clients/pricing/anthropic";
+import {
+  OpenAiModels, OpenAiEmbeddingModels,
+  OpenAiReasoningModels, OpenAiChatModels, OpenAiEmbeddingModelsList,
+  OpenAiResponsesOnlyModels, OpenAiImageModels, OpenAiVideoModels,
+  OpenAiTTSModels, OpenAiTranscriptionModels, OpenAiRealtimeModels,
+} from "./clients/pricing/openai";
+import {
+  GoogleModels, GoogleEmbeddingModels,
+  GoogleTextModels, GoogleImageModels, GoogleVideoModels,
+  GoogleTTSModels, GoogleEmbeddingModelsList, GoogleThinkingLevelModels, GoogleThinkingBudgetModels,
+} from "./clients/pricing/google";
+import {
+  XaiModels, XaiTextModels, XaiImageModels, XaiVideoModels, XaiResponsesOnlyModels, XaiReasoningModels,
+} from "./clients/pricing/xai";
 
-    GPT_4o_Transcribe: "gpt-4o-transcribe",
-    GPT_4o_Mini_Transcribe: "gpt-4o-mini-transcribe",
-    GPT_Realtime_15: "gpt-realtime-1.5",
-    GPT_Realtime_Mini: "gpt-realtime-mini",
-    GPT_Image_15: "gpt-image-1.5",
-    GPT_Image_1_Mini: "gpt-image-1-mini",
-    TTS_1: "tts-1",
-    Whisper_1: "whisper-1",
-    DALL_E_3: "dall-e-3",
-    DALL_E_2: "dall-e-2",
-    Sora: "sora",
-    Sora_2: "sora-2",
-    Sora_2_Pro: "sora-2-pro",
-    // Computer_Use: "computer-use-preview-2025-03-11",
-    // Codex_Mini: "codex-mini-latest",
-  },
-  google: {
-    // Gemini 3.x
-    Gemini_31_Pro_Preview: "gemini-3.1-pro-preview",
-    Gemini_31_Flash_Image_Preview: "gemini-3.1-flash-image-preview",
-    Gemini_31_Flash_Lite_Preview: "gemini-3.1-flash-lite-preview",
-    Gemini_31_Flash_Live_Preview: "gemini-3.1-flash-live-preview",
-    Gemini_3_Flash_Preview: "gemini-3-flash-preview",
-    Gemini_3_Pro_Image_Preview: "gemini-3-pro-image-preview",
-    // Gemini 2.5
-    Gemini_25_Pro: "gemini-2.5-pro",
-    Gemini_25_Flash: "gemini-2.5-flash",
-    Gemini_25_Flash_Lite: "gemini-2.5-flash-lite",
-    Gemini_25_Flash_Preview: "gemini-2.5-flash-preview-05-20",
-    Gemini_25_Pro_Preview: "gemini-2.5-pro-preview-05-06",
-    Gemini_25_Flash_Image: "gemini-2.5-flash-image",
-    Gemini_25_Flash_Live: "gemini-2.5-flash-live-preview",
-    Gemini_25_Flash_Native_Audio:
-      "gemini-2.5-flash-native-audio-preview-12-2025",
-    Gemini_25_Pro_TTS: "gemini-2.5-pro-preview-tts",
-    // Gemini 2.0 (deprecated)
-    Gemini_20_Flash: "gemini-2.0-flash",
-    Gemini_20_Flash_Preview_Image_Generation:
-      "gemini-2.0-flash-exp-image-generation",
-    // Gemini 1.5 (legacy)
-    Gemini_15_Flash: "gemini-1.5-flash",
-    Gemini_15_Flash_8B: "gemini-1.5-flash-8b",
-    Gemini_15_Pro: "gemini-1.5-pro",
-    // Media generation
-    Imagen_3: "imagen-4.0-generate-001",
-    Imagen_4_Fast: "imagen-4.0-fast-generate-001",
-    Imagen_4_Ultra: "imagen-4.0-ultra-generate-001",
-    Veo_2: "veo-2.0-generate-001",
-    Veo_3: "veo-3.0-generate-001",
-    Veo_3_Fast: "veo-3.0-fast-generate-001",
-    Veo_3_1: "veo-3.1-generate-preview",
-    Veo_3_1_Fast: "veo-3.1-fast-generate-preview",
-    // Audio / Live
-    Gemini_20_Flash_Live: "gemini-2.0-flash-live-001",
-    Gemini_25_Flash_TTS: "gemini-2.5-flash-preview-tts",
-    Gemini_20_Flash_TTS: "gemini-2.0-flash-preview-tts",
-  },
+export const Models = {
+  anthropic: AnthropicModels,
+  xai: XaiModels,
+  openai: OpenAiModels,
+  google: GoogleModels,
 };
 
 export const EmbeddingModels = {
-  openai: {
-    EmbeddingAda2: "text-embedding-ada-002",
-    EmbeddingLarge3: "text-embedding-3-large",
-    EmbeddingSmall3: "text-embedding-3-small",
-  },
-  google: {
-    Gemini_Embedding: "gemini-embedding-exp",
-    Gemini_Embedding_001: "gemini-embedding-001",
-  },
+  openai: OpenAiEmbeddingModels,
+  google: GoogleEmbeddingModels,
+};
+
+// Re-export modality arrays for consumers
+export {
+  OpenAiReasoningModels, OpenAiChatModels, OpenAiEmbeddingModelsList,
+  OpenAiResponsesOnlyModels, OpenAiImageModels, OpenAiVideoModels,
+  OpenAiTTSModels, OpenAiTranscriptionModels, OpenAiRealtimeModels,
+  GoogleTextModels as GoogleReasoningModels,
+  GoogleImageModels, GoogleVideoModels, GoogleTTSModels, GoogleEmbeddingModelsList,
+  GoogleThinkingLevelModels, GoogleThinkingBudgetModels,
+  AnthropicTextModels,
+  XaiTextModels, XaiImageModels, XaiVideoModels, XaiResponsesOnlyModels, XaiReasoningModels,
 };
 
-export function getEnabledPlugins(
-  plugins: Config["plugins"] | undefined
-): string[] {
+export function getEnabledPlugins(plugins: Config["plugins"] | undefined): string[] {
   if (!plugins) return [];
   return plugins.enabled ?? [];
 }
 
-export function getDisabledPlugins(
-  plugins: Config["plugins"] | undefined
-): string[] {
+export function getDisabledPlugins(plugins: Config["plugins"] | undefined): string[] {
   if (!plugins) return [];
   return plugins.disabled ?? [];
 }
@@ -338,112 +224,3 @@ export const Providers = Object.keys(Models).reduce((obj, key) => {
   obj[key] = key;
   return obj;
 }, {}) as { [key in keyof typeof Models]: keyof typeof Models };
-
-export const OpenAiReasoningModels = [
-  Models.openai.o1,
-  Models.openai.o1_Mini,
-  Models.openai.o3_Mini,
-  Models.openai.o3,
-  Models.openai.o3_Pro,
-  Models.openai.o4_Mini,
-  Models.openai.GPT_54,
-  Models.openai.GPT_54_Mini,
-  Models.openai.GPT_54_Nano,
-  Models.openai.GPT_54_Pro,
-  Models.openai.GPT_53_Chat,
-  Models.openai.GPT_53_Codex,
-  Models.openai.GPT_5,
-  Models.openai.GPT_5_Mini,
-  Models.openai.GPT_5_Nano,
-  Models.openai.GPT_5_1,
-  Models.openai.GPT_5_2,
-];
-
-export const OpenAiEmbeddingModels = [
-  EmbeddingModels.openai.EmbeddingAda2,
-  EmbeddingModels.openai.EmbeddingLarge3,
-  EmbeddingModels.openai.EmbeddingSmall3,
-];
-
-// Models that ONLY support the Responses API (not Chat Completions)
-export const OpenAiResponsesOnlyModels = [
-  Models.openai.GPT_53_Codex,
-  Models.openai.GPT_54,
-  Models.openai.GPT_54_Mini,
-  Models.openai.GPT_54_Nano,
-  Models.openai.GPT_54_Pro,
-];
-
-export const GoogleReasoningModels = [
-  Models.google.Gemini_31_Pro_Preview,
-  Models.google.Gemini_31_Flash_Lite_Preview,
-  Models.google.Gemini_3_Flash_Preview,
-  Models.google.Gemini_25_Pro,
-  Models.google.Gemini_25_Flash,
-  Models.google.Gemini_25_Flash_Lite,
-  Models.google.Gemini_25_Flash_Preview,
-  Models.google.Gemini_25_Pro_Preview,
-  Models.google.Gemini_20_Flash,
-  Models.google.Gemini_15_Flash,
-  Models.google.Gemini_15_Flash_8B,
-  Models.google.Gemini_15_Pro,
-];
-
-export const GoogleImageModels = [
-  Models.google.Gemini_31_Flash_Image_Preview,
-  Models.google.Gemini_3_Pro_Image_Preview,
-  Models.google.Gemini_25_Flash_Image,
-  Models.google.Gemini_20_Flash_Preview_Image_Generation,
-  Models.google.Imagen_3,
-  Models.google.Imagen_4_Fast,
-  Models.google.Imagen_4_Ultra,
-];
-
-export const OpenAiImageModels = [
-  Models.openai.DALL_E_3,
-  Models.openai.DALL_E_2,
-  Models.openai.GPT_Image_15,
-  Models.openai.GPT_Image_1_Mini,
-];
-
-export const OpenAiVideoModels = [
-  Models.openai.Sora,
-  Models.openai.Sora_2,
-  Models.openai.Sora_2_Pro,
-];
-
-export const OpenAiTTSModels = [Models.openai.TTS_1];
-
-export const XaiImageModels = [Models.xai.GrokImagineImage];
-export const OpenAiTranscriptionModels = [
-  Models.openai.Whisper_1,
-  Models.openai.GPT_4o_Transcribe,
-  Models.openai.GPT_4o_Mini_Transcribe,
-];
-
-export const OpenAiRealtimeModels = [
-  Models.openai.GPT_4o_Realtime,
-  Models.openai.GPT_4o_Mini_Realtime,
-  Models.openai.GPT_Realtime_15,
-  Models.openai.GPT_Realtime_Mini,
-];
-export const XaiVideoModels = [Models.xai.GrokImagineVideo];
-
-export const GoogleTTSModels = [
-  Models.google.Gemini_25_Flash_TTS,
-  Models.google.Gemini_25_Pro_TTS,
-  Models.google.Gemini_20_Flash_TTS,
-];
-
-export const GoogleVideoModels = [
-  Models.google.Veo_2,
-  Models.google.Veo_3,
-  Models.google.Veo_3_Fast,
-  Models.google.Veo_3_1,
-  Models.google.Veo_3_1_Fast,
-];
-
-export const GoogleEmbeddingModels = [
-  EmbeddingModels.google.Gemini_Embedding,
-  EmbeddingModels.google.Gemini_Embedding_001,
-];

package/src/worker.ts

@@ -578,3 +578,177 @@ export async function worker(options?: {
     await wait(5000);
   }
 }
+
+/**
+ * Run tunnel-only mode: connects to the Knowhow tunnel WebSocket without
+ * registering any MCP tools. Useful for users who only want the web tunnel
+ * feature to expose local ports to the cloud.
+ */
+export async function tunnel(options?: {
+  share?: boolean;
+  unshare?: boolean;
+}) {
+  const config = await getConfig();
+
+  const isInsideDocker = process.env.KNOWHOW_DOCKER === "true";
+
+  // Determine localHost based on environment
+  let tunnelLocalHost = config.worker?.tunnel?.localHost;
+  if (!tunnelLocalHost) {
+    if (isInsideDocker) {
+      tunnelLocalHost = "host.docker.internal";
+      console.log(
+        "🐳 Docker detected: tunnel will use host.docker.internal to reach host services"
+      );
+    } else {
+      tunnelLocalHost = "127.0.0.1";
+    }
+  }
+
+  // Check for port mapping configuration
+  const portMapping = config.worker?.tunnel?.portMapping || {};
+  if (Object.keys(portMapping).length > 0) {
+    console.log("🔀 Port mapping configured:");
+    for (const [containerPort, hostPort] of Object.entries(portMapping)) {
+      console.log(`   Container port ${containerPort} → Host port ${hostPort}`);
+    }
+  }
+
+  const tunnelPorts = config.worker?.tunnel?.allowedPorts || [];
+  if (tunnelPorts.length === 0) {
+    console.warn(
+      "⚠️  No allowedPorts configured. Add worker.tunnel.allowedPorts to knowhow.json"
+    );
+  } else {
+    console.log(`🌐 Tunnel mode for ports: ${tunnelPorts.join(", ")}`);
+  }
+
+  // Extract tunnel domain from API_URL
+  function extractTunnelDomain(apiUrl: string): {
+    domain: string;
+    useHttps: boolean;
+  } {
+    try {
+      const url = new URL(apiUrl);
+      const useHttps = url.protocol === "https:";
+      if (url.hostname === "localhost" || url.hostname === "127.0.0.1") {
+        return {
+          domain: `worker.${url.hostname}:${url.port || "80"}`,
+          useHttps,
+        };
+      }
+      return { domain: `worker.${url.hostname}`, useHttps };
+    } catch (err) {
+      console.error("Failed to parse API_URL for tunnel domain:", err);
+      return { domain: "worker.localhost:4000", useHttps: false };
+    }
+  }
+
+  let connected = false;
+  let tunnelHandler: TunnelHandler | null = null;
+  let lastJwt: string | null = null;
+  let unauthorizedJwt: string | null = null;
+
+  async function connectTunnel() {
+    const jwt = await loadJwt();
+    lastJwt = jwt;
+    console.log(`Connecting tunnel to ${API_URL}`);
+
+    const dir = process.cwd();
+    const homedir = os.homedir();
+    const hostname = process.env.WORKER_HOSTNAME || os.hostname();
+    const root =
+      process.env.WORKER_ROOT ||
+      (dir === homedir ? "~" : dir.replace(homedir, "~"));
+
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${jwt}`,
+      "User-Agent": `knowhow-tunnel/1.0.0/${hostname}`,
+      Root: root,
+    };
+
+    if (options?.share) {
+      headers.Shared = "true";
+      console.log("🔓 Tunnel shared with organization");
+    } else if (options?.unshare) {
+      headers.Shared = "false";
+      console.log("🔒 Tunnel is now private (unshared)");
+    } else {
+      console.log("🔒 Tunnel is private (only you can use it)");
+    }
+
+    const { domain: tunnelDomain, useHttps: tunnelUseHttps } =
+      extractTunnelDomain(API_URL);
+
+    const tunnelConnection = new WebSocket(`${API_URL}/ws/tunnel`, { headers });
+
+    tunnelConnection.on("open", () => {
+      console.log("🌐 Tunnel WebSocket connected");
+      connected = true;
+
+      const allowedPorts = config.worker?.tunnel?.allowedPorts || [];
+      const urlRewriter = (port: number, metadata?: any) => {
+        const workerId = metadata?.workerId;
+        const secret = metadata?.secret;
+        const subdomain = secret ? `${secret}-p${port}` : `${workerId}-p${port}`;
+        return `${subdomain}.${tunnelDomain}`;
+      };
+
+      const tunnelConfig = {
+        allowedPorts,
+        maxConcurrentStreams: config.worker?.tunnel?.maxConcurrentStreams || 50,
+        tunnelUseHttps,
+        localHost: tunnelLocalHost,
+        urlRewriter,
+        enableUrlRewriting: config.worker?.tunnel?.enableUrlRewriting !== false,
+        portMapping,
+        logLevel: "debug" as const,
+      };
+
+      tunnelHandler = createTunnelHandler(tunnelConnection, tunnelConfig);
+      console.log("🌐 Tunnel handler initialized");
+      console.log(tunnelConfig);
+    });
+
+    tunnelConnection.on("close", (code, reason) => {
+      console.log(`Tunnel WebSocket closed. Code: ${code}, Reason: ${reason.toString()}`);
+      if (code === 1008) {
+        unauthorizedJwt = lastJwt;
+        console.error("❌ Tunnel received Unauthorized (1008). The JWT may be expired.");
+        console.error("   Run 'knowhow login' to refresh your token, then restart.");
+        console.error("   Pausing reconnection until JWT changes...");
+      } else {
+        console.log("Tunnel connection will reconnect on next cycle...");
+      }
+      if (tunnelHandler) {
+        tunnelHandler.cleanup();
+        tunnelHandler = null;
+      }
+      connected = false;
+    });
+
+    tunnelConnection.on("error", (error) => {
+      console.error("Tunnel WebSocket error:", error);
+      connected = false;
+    });
+
+    return tunnelConnection;
+  }
+
+  while (true) {
+    if (!connected) {
+      if (unauthorizedJwt !== null) {
+        const currentJwt = await loadJwt().catch(() => null);
+        if (currentJwt === unauthorizedJwt) {
+          await wait(5000);
+          continue;
+        }
+        console.log("🔄 JWT has changed, attempting to reconnect tunnel...");
+        unauthorizedJwt = null;
+      }
+      console.log("Attempting to connect tunnel...");
+      await connectTunnel();
+    }
+    await wait(5000);
+  }
+}

package/tests/clients/pricing.test.ts

@@ -5,6 +5,9 @@
  * Models that are image-only, video-only, TTS, transcription, realtime, or live streaming
  * are exempt from text pricing requirements — they should have their own pricing entries
  * in the appropriate pricing tables (image, video, audio, etc.).
+ * 
+ * Also verifies that every model in Models.* and EmbeddingModels.* has a catalog entry,
+ * ensuring the catalog stays in sync with the model definitions.
  */
 
 import {
@@ -27,6 +30,7 @@ import {
   GeminiTextPricing,
   AnthropicTextPricing,
   XaiTextPricing,
+  ALL_MODEL_CATALOG,
   XaiImagePricing,
   XaiVideoPricing,
 } from "../../src/clients/pricing";
@@ -140,5 +144,38 @@ describe("Model Pricing Coverage", () => {
         expect(entry).toBeDefined();
       });
     }
+
+describe("Model Catalog Coverage", () => {
+  /**
+   * Every model defined in Models.* and EmbeddingModels.* must have an entry
+   * in ALL_MODEL_CATALOG. This ensures the catalog stays in sync and is the
+   * single source of truth for model metadata and pricing.
+   */
+  const catalogIds = new Set(ALL_MODEL_CATALOG.map((m) => m.id));
+
+  describe("All Models.* entries are in the catalog", () => {
+    for (const [provider, providerModels] of Object.entries(Models)) {
+      for (const [modelKey, modelId] of Object.entries(
+        providerModels as Record<string, string>
+      )) {
+        it(`Models.${provider}.${modelKey} (${modelId}) is in ALL_MODEL_CATALOG`, () => {
+          expect(catalogIds.has(modelId)).toBe(true);
+        });
+      }
+    }
+  });
+
+  describe("All EmbeddingModels.* entries are in the catalog", () => {
+    for (const [provider, providerModels] of Object.entries(EmbeddingModels)) {
+      for (const [modelKey, modelId] of Object.entries(
+        providerModels as Record<string, string>
+      )) {
+        it(`EmbeddingModels.${provider}.${modelKey} (${modelId}) is in ALL_MODEL_CATALOG`, () => {
+          expect(catalogIds.has(modelId)).toBe(true);
+        });
+      }
+    }
+  });
+});
   });
 });