@tyvm/knowhow 0.0.83 → 0.0.85

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.83",
+  "version": "0.0.85",
   "description": "ai cli with plugins and agents",
   "main": "ts_build/src/index.js",
   "bin": {
@@ -40,14 +40,15 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
     "@aws-sdk/client-s3": "^3.588.0",
-    "@tyvm/knowhow-tunnel": "0.0.3",
     "@google/genai": "^0.14.1",
     "@inquirer/editor": "^4.2.18",
     "@linear/sdk": "^12.0.0",
     "@modelcontextprotocol/sdk": "^1.13.3",
     "@notionhq/client": "^2.2.14",
     "@octokit/rest": "^20.0.2",
+    "@simplewebauthn/server": "^13.3.0",
     "@types/react": "^19.1.8",
+    "@tyvm/knowhow-tunnel": "0.0.3",
     "asana": "^3.0.16",
     "axios": "^1.5.0",
     "cheerio": "^1.0.0",
@@ -61,6 +62,7 @@
     "ink": "^6.0.1",
     "isolated-vm": "^5.0.4",
     "jira-client": "^8.2.2",
+    "jiti": "^2.6.1",
     "marked": "^10.0.0",
     "marked-terminal": "^6.2.0",
     "minimatch": "^10.1.2",

package/src/agents/base/base.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from "events";
+import { EventEmitter } from "events";  // kept for reference; agentEvents now uses EventService
 import {
   GenericClient,
   Message,
@@ -64,13 +64,15 @@ export abstract class BaseAgent implements IAgent {
   protected summaries = [] as string[];
   protected currentTaskId: string | null = null;
 
-  public agentEvents = new EventEmitter();
+  public agentEvents = new EventService();
   public eventTypes = {
     newThread: "new_thread",
     threadUpdate: "thread_update",
     costUpdate: "cost_update",
+    agentLog: "agent:log",
     toolCall: "tool:pre_call",
     toolUsed: "tool:post_call",
+    agentStatus: "agent:status",
     notStarted: "not_started",
     inProgress: "in_progress",
     done: "done",
@@ -106,7 +108,8 @@ export abstract class BaseAgent implements IAgent {
     }
 
     // Subscribe to "agent:msg" events for dynamic context loading
-    this.events.on(this.eventTypes.agentMsg, (eventData: any) => {
+    // Use setListener with a key so re-creating the agent doesn't double-subscribe
+    this.events.setListener({ key: `agent:msg:${this.constructor.name}`, event: this.eventTypes.agentMsg }, (eventData: any) => {
       if (
         this.status === this.eventTypes.inProgress ||
         this.status === this.eventTypes.pause
@@ -120,6 +123,16 @@ export abstract class BaseAgent implements IAgent {
     });
   }
 
+  protected log(message: string, level: "info" | "warn" | "error" = "info"): void {
+    this.agentEvents.emit(this.eventTypes.agentLog, {
+      agentName: this.name,
+      message,
+      level,
+      timestamp: Date.now(),
+      taskId: this.currentTaskId,
+    });
+  }
+
   setMaxTurns(maxTurns: number | null) {
     this.maxTurns = maxTurns;
   }
@@ -196,12 +209,12 @@ export abstract class BaseAgent implements IAgent {
   getClient() {
     if (!this.client) {
       if (this.provider) {
-        console.log("Getting client for provider", this.provider);
+        this.log(`Getting client for provider ${this.provider}`);
         this.client = this.clientService.getClient(this.provider)?.client;
       }
 
       if (!this.client) {
-        console.log("Getting client for model", this.modelName);
+        this.log(`Getting client for model ${this.modelName}`);
         this.client = this.clientService.getClient(
           undefined,
           this.modelName
@@ -246,17 +259,17 @@ export abstract class BaseAgent implements IAgent {
   private checkLimits(): boolean {
     // Check turn limit
     if (this.maxTurns !== null && this.turnCount >= this.maxTurns) {
-      console.log(`Turn limit reached: ${this.turnCount}/${this.maxTurns}`);
+      this.log(`Turn limit reached: ${this.turnCount}/${this.maxTurns}`, "warn");
       return true;
     }
 
     // Check spend limit
     if (this.maxSpend !== null && this.totalCostUsd >= this.maxSpend) {
-      console.log(
+      this.log(
         `Spend limit reached: $${this.totalCostUsd.toFixed(
           4
         )}/$${this.maxSpend.toFixed(4)}`
-      );
+      , "warn");
       return true;
     }
 
@@ -264,8 +277,9 @@ export abstract class BaseAgent implements IAgent {
     if (this.maxRunTimeMs !== null && this.startTimeMs !== null) {
       const currentRunTimeMs = this.runTime();
       if (currentRunTimeMs >= this.maxRunTimeMs) {
-        console.log(
-          `Runtime limit reached: ${currentRunTimeMs}ms/${this.maxRunTimeMs}ms`
+        this.log(
+          `Runtime limit reached: ${currentRunTimeMs}ms/${this.maxRunTimeMs}ms`,
+          "warn"
         );
         return true;
       }
@@ -343,7 +357,6 @@ export abstract class BaseAgent implements IAgent {
         this.agentEvents.emit(this.eventTypes.agentSay, {
           message: message.content,
         });
-        console.log("\n", "💬 " + message.content, "\n");
       }
     }
   }
@@ -385,7 +398,7 @@ export abstract class BaseAgent implements IAgent {
       });
       return true;
     } catch (e) {
-      console.error(e);
+      this.log(String(e), "error");
       return false;
     }
   }
@@ -417,10 +430,8 @@ export abstract class BaseAgent implements IAgent {
       return false;
     }
 
-    console.log(
-      `Required tool: [${this.requiredToolNames}] not available, checking for finalAnswer`,
-      this.getEnabledToolNames(),
-      this.requiredToolNames
+    this.log(
+      `Required tool: [${this.requiredToolNames}] not available, checking for finalAnswer. Enabled: ${this.getEnabledToolNames().join(", ")}`
     );
 
     // Otherwise we're missing the required tool, lets use finalAnswer if we have it
@@ -430,9 +441,9 @@ export abstract class BaseAgent implements IAgent {
 
     // We have the final answer tool, but it wasn't required
     if (hasFinalAnswer && !requiredFinalAnswer) {
-      console.warn(
+      this.log(
         "Required tool not available, setting finalAnswer as required tool"
-      );
+      , "warn");
       this.requiredToolNames.push("finalAnswer");
       return false;
     }
@@ -445,22 +456,22 @@ export abstract class BaseAgent implements IAgent {
   }
 
   pause() {
-    console.log("Pausing agent");
+    this.log("Pausing agent");
     this.agentEvents.emit(this.eventTypes.pause, this);
     this.status = this.eventTypes.pause;
   }
 
   unpause() {
-    console.log("Unpausing agent");
+    this.log("Unpausing agent");
     this.agentEvents.emit(this.eventTypes.unpause, this);
     this.status = this.eventTypes.inProgress;
   }
 
   async unpaused() {
     return new Promise((resolve) => {
-      console.log("Waiting for agent to unpause");
+      this.log("Waiting for agent to unpause");
       this.agentEvents.once(this.eventTypes.unpause, () => {
-        console.log("Agent resumed");
+        this.log("Agent resumed");
         resolve(true);
       });
       this.agentEvents.once(this.eventTypes.done, () => {
@@ -470,7 +481,7 @@ export abstract class BaseAgent implements IAgent {
   }
 
   async kill() {
-    console.log("Killing agent");
+    this.log("Killing agent");
     this.agentEvents.emit(this.eventTypes.kill, this);
     this.status = this.eventTypes.kill;
 
@@ -550,15 +561,15 @@ export abstract class BaseAgent implements IAgent {
       });
 
       if (response?.usd_cost === undefined) {
-        console.warn(
-          "Response cost is undefined",
-          JSON.stringify(response, null, 2)
+        this.log(
+          `Response cost is undefined: ${JSON.stringify(response, null, 2)}`,
+          "warn"
         );
         const error = response as any;
         if ("response" in error && "data" in error.response) {
-          console.warn(
-            "Response data",
-            JSON.stringify(error.response.data, null, 2)
+          this.log(
+            `Response data: ${JSON.stringify(error.response.data, null, 2)}`,
+            "warn"
           );
         }
       }
@@ -650,7 +661,7 @@ export abstract class BaseAgent implements IAgent {
         const error = `Required tool: ${JSON.stringify(
           this.requiredToolNames
         )} not available, options are ${this.getEnabledToolNames().join(", ")}`;
-        console.error(error);
+        this.log(error, "error");
         this.status = this.eventTypes.done;
         this.agentEvents.emit(this.eventTypes.done, error);
         return error;
@@ -661,7 +672,7 @@ export abstract class BaseAgent implements IAgent {
         this.pendingUserMessages.length === 0 &&
         this.status === this.eventTypes.kill
       ) {
-        console.log("Agent killed, stopping execution");
+        this.log("Agent killed, stopping execution");
         this.status = this.eventTypes.done;
         this.agentEvents.emit(this.eventTypes.done, firstMessage.content);
         return firstMessage.content;
@@ -672,11 +683,8 @@ export abstract class BaseAgent implements IAgent {
         messages.length > 30
       ) {
         const taskBreakdown = await this.getTaskBreakdown(messages);
-        console.log(
-          "Compressing messages",
-          this.getMessagesLength(messages),
-          "exceeds",
-          compressThreshold
+        this.log(
+          `Compressing messages: ${this.getMessagesLength(messages)} exceeds ${compressThreshold}`
         );
         messages = await this.compressMessages(messages, startIndex, endIndex);
         this.startNewThread(messages);
@@ -722,9 +730,9 @@ export abstract class BaseAgent implements IAgent {
 
       if (isRetriable && retryCount < 3) {
         const delay = 1000 * Math.pow(2, retryCount);
-        console.warn(
-          `Agent request failed (attempt ${retryCount + 1}/3), retrying in ${delay}ms...`,
-          e.message
+        this.log(
+          `Agent request failed (attempt ${retryCount + 1}/3), retrying in ${delay}ms: ${e.message}`,
+          "warn"
         );
         await new Promise((resolve) => setTimeout(resolve, delay));
         return this.call(userInput, _messages, retryCount + 1);
@@ -732,12 +740,12 @@ export abstract class BaseAgent implements IAgent {
 
       }
 
-      console.error("Agent failed", e);
+      this.log(`Agent failed: ${e}`, "error");
 
       if ("response" in e && "data" in e.response) {
-        console.error(
-          "Error response data:",
-          JSON.stringify(e.response.data, null, 2)
+        this.log(
+          `Error response data: ${JSON.stringify(e.response.data, null, 2)}`,
+          "error"
         );
       }
 
@@ -783,14 +791,26 @@ export abstract class BaseAgent implements IAgent {
 
   logStatus() {
     const statusMessage = this.getStatusMessage();
-    console.log(
-      `\n● ${this.name} status: ${statusMessage}`
-    );
+    this.agentEvents.emit(this.eventTypes.agentStatus, {
+      agentName: this.name,
+      taskId: this.currentTaskId,
+      statusMessage,
+      details: {
+        totalCostUsd: this.getTotalCostUsd(),
+        elapsedMs: this.runTime(),
+        remainingTimeMs: this.maxRunTimeMs && this.startTimeMs
+          ? this.maxRunTimeMs - (Date.now() - this.startTimeMs)
+          : undefined,
+        remainingTurns: this.maxTurns ? this.maxTurns - this.turnCount : undefined,
+        remainingBudget: this.maxSpend ? this.maxSpend - this.totalCostUsd : undefined,
+      },
+      timestamp: Date.now(),
+    });
   }
 
   addPendingMessage(message: Message) {
     if (this.status === this.eventTypes.done) {
-      console.warn("Agent is done, cannot take more messages");
+      this.log("Agent is done, cannot take more messages", "warn");
     } else {
       const pendingMessages = this.pendingUserMessages.map((m) => m.content);
       if (pendingMessages.includes(message.content)) {
@@ -839,7 +859,7 @@ export abstract class BaseAgent implements IAgent {
 
     this.adjustTotalCostUsd(response.usd_cost);
 
-    console.log(response);
+    this.log(String(response));
 
     this.taskBreakdown = response.choices[0].message.content;
     return this.taskBreakdown;
@@ -850,13 +870,8 @@ export abstract class BaseAgent implements IAgent {
     startIndex: number,
     endIndex: number
   ) {
-    console.log(
-      "Compressing messages from",
-      startIndex,
-      "to",
-      endIndex,
-      "total messages:",
-      messages.length
+    this.log(
+      `Compressing messages from ${startIndex} to ${endIndex}, total messages: ${messages.length}`
     );
     const toCompress = messages.slice(startIndex, endIndex);
     const toCompressPrompt = `We are compressing our conversation to save memory.
@@ -921,13 +936,8 @@ export abstract class BaseAgent implements IAgent {
       100
     ).toFixed(2);
 
-    console.log(
-      "Compressed messages from",
-      oldLength,
-      "to",
-      newLength,
-      compressionRatio + "%",
-      "reduction in size"
+    this.log(
+      `Compressed messages from ${oldLength} to ${newLength}, ${compressionRatio}% reduction in size`
     );
 
     return newMessages;

package/src/agents/index.ts

@@ -16,21 +16,37 @@ export * from "./researcher/researcher";
 export * as tools from "./tools";
 export { includedTools } from "./tools/list";
 
-let singletons = {} as {
-  Developer: DeveloperAgent;
-  Patcher: PatchingAgent;
-  Researcher: ResearcherAgent;
-  Setup: SetupAgent;
+export type AgentName = "Developer" | "Patcher" | "Researcher" | "Setup";
+
+/**
+ * Registry of agent constructors (not instances).
+ * Use createAgent() to get a fresh instance per task, avoiding stale event listener issues.
+ */
+export const agentConstructors: Record<AgentName, new (context: AgentContext) => any> = {
+  Developer: DeveloperAgent,
+  Patcher: PatchingAgent,
+  Researcher: ResearcherAgent,
+  Setup: SetupAgent,
 };
 
-export function agents(agentContext: AgentContext = services()) {
-  if (Object.keys(singletons).length === 0) {
-    singletons = {
-      Developer: new DeveloperAgent(agentContext),
-      Patcher: new PatchingAgent(agentContext),
-      Researcher: new ResearcherAgent(agentContext),
-      Setup: new SetupAgent(agentContext),
-    };
+/**
+ * Create a fresh agent instance by name.
+ * Always returns a new instance to avoid shared state / stale listeners between tasks.
+ */
+export function createAgent(agentName: AgentName, agentContext: AgentContext = services()) {
+  const AgentClass = agentConstructors[agentName];
+  if (!AgentClass) {
+    throw new Error(`Agent "${agentName}" not found. Available agents: ${Object.keys(agentConstructors).join(", ")}`);
   }
-  return singletons;
+  return new AgentClass(agentContext);
+}
+
+/** @deprecated Use createAgent() for per-task instances to avoid event listener leaks */
+export function agents(agentContext: AgentContext = services()) {
+  return {
+    Developer: new DeveloperAgent(agentContext),
+    Patcher: new PatchingAgent(agentContext),
+    Researcher: new ResearcherAgent(agentContext),
+    Setup: new SetupAgent(agentContext),
+  };
 }

package/src/agents/researcher/researcher.ts

@@ -8,7 +8,7 @@ export class ResearcherAgent extends BaseAgent {
 
   constructor(context: AgentContext) {
     super(context);
-    this.setModel(Models.google.Gemini_20_Flash);
+    this.setModel(Models.google.Gemini_3_Flash_Preview);
     this.setProvider("google");
     this.disableTool("patchFile");
     this.disableTool("writeFile");
@@ -106,4 +106,3 @@ export class ResearcherAgent extends BaseAgent {
     ] as Message[];
   }
 }
-

package/src/agents/tools/aiClient.ts

@@ -128,3 +128,51 @@ export async function listAllEmbeddingModels(): Promise<Record<string, string[]>
 
   return contextClients.listAllEmbeddingModels();
 }
+
+export async function listAllImageModels(): Promise<Record<string, string[]>> {
+  // Get context from bound ToolsService
+  const toolService = (
+    this instanceof ToolsService ? this : services().Tools
+  ) as ToolsService;
+
+  const toolContext = toolService.getContext();
+  const { Clients: contextClients } = toolContext;
+
+  if (!contextClients) {
+    throw new Error("Clients not available in tool context");
+  }
+
+  return contextClients.listAllImageModels();
+}
+
+export async function listAllAudioModels(): Promise<Record<string, string[]>> {
+  // Get context from bound ToolsService
+  const toolService = (
+    this instanceof ToolsService ? this : services().Tools
+  ) as ToolsService;
+
+  const toolContext = toolService.getContext();
+  const { Clients: contextClients } = toolContext;
+
+  if (!contextClients) {
+    throw new Error("Clients not available in tool context");
+  }
+
+  return contextClients.listAllAudioModels();
+}
+
+export async function listAllVideoModels(): Promise<Record<string, string[]>> {
+  // Get context from bound ToolsService
+  const toolService = (
+    this instanceof ToolsService ? this : services().Tools
+  ) as ToolsService;
+
+  const toolContext = toolService.getContext();
+  const { Clients: contextClients } = toolContext;
+
+  if (!contextClients) {
+    throw new Error("Clients not available in tool context");
+  }
+
+  return contextClients.listAllVideoModels();
+}

package/src/agents/tools/list.ts

@@ -506,6 +506,63 @@ export const includedTools = [
     },
   },
 
+  {
+    type: "function",
+    function: {
+      name: "listAllImageModels",
+      description:
+        "List all available image generation models using the knowhow ai client. Use this to discover which providers and models support image generation.",
+      parameters: {
+        type: "object",
+        properties: {},
+        required: [],
+      },
+      returns: {
+        type: "object",
+        description:
+          "A dictionary of all available image generation models for each provider",
+      },
+    },
+  },
+
+  {
+    type: "function",
+    function: {
+      name: "listAllAudioModels",
+      description:
+        "List all available audio generation models (TTS/transcription) using the knowhow ai client. Use this to discover which providers and models support audio generation.",
+      parameters: {
+        type: "object",
+        properties: {},
+        required: [],
+      },
+      returns: {
+        type: "object",
+        description:
+          "A dictionary of all available audio generation models for each provider",
+      },
+    },
+  },
+
+  {
+    type: "function",
+    function: {
+      name: "listAllVideoModels",
+      description:
+        "List all available video generation models using the knowhow ai client. Use this to discover which providers and models support video generation.",
+      parameters: {
+        type: "object",
+        properties: {},
+        required: [],
+      },
+      returns: {
+        type: "object",
+        description:
+          "A dictionary of all available video generation models for each provider",
+      },
+    },
+  },
+
   {
     type: "function",
     function: {

package/src/agents/tools/startAgentTask.ts

@@ -32,7 +32,9 @@ function generateTaskId(prompt: string): string {
     .slice(0, 9);
   const wordPart = words.join("-") || "task";
   const epochSeconds = Math.floor(Date.now() / 1000);
-  return `${epochSeconds}-${wordPart}`;
+  const fullId = `${epochSeconds}-${wordPart}`;
+  // Truncate to 80 chars to avoid ENAMETOOLONG filesystem errors
+  return fullId.slice(0, 80);
 }
 
 /**

package/src/chat/CliChatService.ts

@@ -317,13 +317,29 @@ export class CliChatService implements ChatService {
     console.log("Commands:", commandNames.join(", "));
 
     while (true) {
+      // Recompute available commands each iteration so mode changes are reflected in autocomplete
+      const currentCommandNames = this.getCommandsForActiveModes().map((cmd) => `/${cmd.name}`);
+
+      // Check active modes for a promptText first, then fall back to context.promptText, then default
+      const activeModeWithPrompt = this.modes
+        .filter((m) => m.active && m.promptText)
+        .slice(-1)[0]; // last active mode with a promptText wins
+
+      let modePrompt: string | undefined;
+      if (activeModeWithPrompt?.promptText) {
+        const p = activeModeWithPrompt.promptText;
+        modePrompt = typeof p === "function" ? p() : p;
+      }
+
       const promptText =
-        this.context.agentMode && this.context.currentAgent
+        modePrompt ||
+        this.context.promptText ||
+        (this.context.agentMode && this.context.currentAgent
           ? `\nAsk knowhow ${this.context.currentAgent}: `
-          : `\nAsk knowhow: `;
+          : `\nAsk knowhow: `);
       try {
         // Pass command names as autocomplete options
-        const input = await this.getInput(promptText, commandNames);
+        const input = await this.getInput(promptText, currentCommandNames);
 
         if (input.trim() === "") {
           continue;
@@ -336,7 +352,7 @@ export class CliChatService implements ChatService {
           // Default chat behavior - this would be handled by a chat module
           const interaction = {
             input,
-            output: `I didn't understand that command. Available commands: ${commandNames.join(
+            output: `I didn't understand that command. Available commands: ${currentCommandNames.join(
               ", "
             )}`,
           } as ChatInteraction;