@tyvm/knowhow 0.0.97 → 0.0.99

package/src/services/KnowhowClient.ts

@@ -144,7 +144,6 @@ export class KnowhowSimpleClient {
         const currentOrg = orgs.find((org) => {
           return org.organizationId === orgId;
         });
-
       } catch (error) {
         throw new Error("Invalid JWT. Please login again.");
       }
@@ -203,13 +202,9 @@ export class KnowhowSimpleClient {
     }
   ) {
     await this.checkJwt();
-    return http.put(
-      `${this.baseUrl}/api/org-embeddings/${id}`,
-      data,
-      {
-        headers: this.headers,
-      }
-    );
+    return http.put(`${this.baseUrl}/api/org-embeddings/${id}`, data, {
+      headers: this.headers,
+    });
   }
 
   async createChatCompletion(options: CompletionOptions) {
@@ -234,9 +229,9 @@ export class KnowhowSimpleClient {
     );
   }
 
-  async getModels() {
+  async getModels(type = "all") {
     await this.checkJwt();
-    return http.get(`${this.baseUrl}/api/proxy/v1/models?type=all`, {
+    return http.get(`${this.baseUrl}/api/proxy/v1/models?type=${type}`, {
       headers: this.headers,
     });
   }
@@ -609,7 +604,11 @@ export class KnowhowSimpleClient {
       throw new Error(`File not found: ${filePath}`);
     }
 
-    await http.post(`${this.baseUrl}/api/org-files/upload/${file.id}/complete`, {}, { headers: this.headers });
+    await http.post(
+      `${this.baseUrl}/api/org-files/upload/${file.id}/complete`,
+      {},
+      { headers: this.headers }
+    );
   }
 
   /**
@@ -624,7 +623,8 @@ export class KnowhowSimpleClient {
 
     // Extract just the filename from the path
     const lastSlash = filePath.lastIndexOf("/");
-    const fileName = lastSlash >= 0 ? filePath.substring(lastSlash + 1) : filePath;
+    const fileName =
+      lastSlash >= 0 ? filePath.substring(lastSlash + 1) : filePath;
 
     // Get upload URL using the file ID
     const response = await http.post<{ uploadUrl: string }>(
@@ -648,4 +648,48 @@ export class KnowhowSimpleClient {
     );
     return response.data;
   }
+
+  // ============================================
+  // Cloud Worker Methods
+  // ============================================
+
+  /**
+   * List all cloud workers for the current user's org
+   */
+  async listCloudWorkers() {
+    await this.checkJwt();
+    return http.get<
+      { id: string; name: string; status: string; workerConfigJson?: Record<string, unknown> }[]
+    >(`${this.baseUrl}/api/cloud-workers`, { headers: this.headers });
+  }
+
+  /**
+   * Create a new cloud worker
+   */
+  async createCloudWorker(data: {
+    name: string;
+    workerConfigJson?: Record<string, unknown>;
+  }) {
+    await this.checkJwt();
+    return http.post<{ id: string; name: string; status: string; workerConfigJson?: Record<string, unknown> }>(
+      `${this.baseUrl}/api/cloud-workers`,
+      data,
+      { headers: this.headers }
+    );
+  }
+
+  /**
+   * Update an existing cloud worker
+   */
+  async updateCloudWorker(
+    id: string,
+    data: { workerConfigJson?: Record<string, unknown> }
+  ) {
+    await this.checkJwt();
+    return http.put<{ id: string; name: string; status: string; workerConfigJson?: Record<string, unknown> }>(
+      `${this.baseUrl}/api/cloud-workers/${id}`,
+      data,
+      { headers: this.headers }
+    );
+  }
 }

package/src/services/LazyToolsService.ts

@@ -125,23 +125,24 @@ export class LazyToolsService extends ToolsService {
   async callTool(toolCall: ToolCall, enabledTools?: string[]) {
     const functionName = toolCall.function.name;
 
-    // If no explicit enabledTools list was provided and the tool isn't currently
-    // visible, check if it exists in allTools and auto-enable it
-    if (!enabledTools) {
-      const isCurrentlyEnabled = this.tools.some(
-        (t) => t.function.name === functionName
-      );
-      const existsInAll = this.allTools.some(
-        (t) => t.function.name === functionName
-      );
+    // If the tool isn't currently visible but exists in allTools, auto-enable it.
+    // This handles the case where the agent explicitly calls a tool without first
+    // enabling it via listAvailableTools/enableTools.
+    const isCurrentlyEnabled = this.tools.some(
+      (t) => t.function.name === functionName
+    );
+    const existsInAll = this.allTools.some(
+      (t) => t.function.name === functionName
+    );
 
-      if (!isCurrentlyEnabled && existsInAll) {
-        // Auto-enable by adding the tool name as an exact pattern
-        this.enableTools([functionName]);
-      }
+    if (!isCurrentlyEnabled && existsInAll) {
+      // Auto-enable by adding the tool name as an exact pattern
+      this.enableTools([functionName]);
     }
 
-    return super.callTool(toolCall, enabledTools ?? this.getToolNames());
+    // Always use the current enabled tool names after any auto-enable above,
+    // so the base class check sees the freshly-enabled tool in the allowed list.
+    return super.callTool(toolCall, this.getToolNames());
   }
 
   // Internal: Update visible tools based on patterns

package/src/services/Tools.ts

@@ -73,7 +73,12 @@ export class ToolsService {
     this.addTools(tools);
 
     for (const name of toolNames) {
-      this.setFunction(name, toolsService.getFunction(name));
+      const fn = toolsService.getFunction(name);
+      if (!fn) {
+        continue;
+      }
+
+      this.setFunction(name, fn);
     }
   }
 
@@ -118,6 +123,10 @@ export class ToolsService {
 
   setFunctions(names: string[], funcs: ((...args: any) => any)[]) {
     for (let i = 0; i < names.length; i++) {
+      if (!names[i] || typeof funcs[i] !== "function") {
+        console.warn("Ignoring invalid function entry at index", i, "with name", names[i]);
+        continue;
+      }
       this.setFunction(names[i], funcs[i]);
     }
   }

package/src/types.ts

@@ -132,8 +132,9 @@ export type McpConfig = {
 };
 
 export type ModelProvider = {
-  url: string;
+  url?: string;
   provider: string;
+  envKey?: string;
   headers?: { [key: string]: string };
   jwtFile?: string;
 };
@@ -359,7 +360,15 @@ export const OpenAiEmbeddingModels = [
   EmbeddingModels.openai.EmbeddingLarge3,
   EmbeddingModels.openai.EmbeddingSmall3,
 ];
-// export const OpenAiResponseOnlyModels = [Models.openai.Codex_Mini];
+
+// 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,

package/src/utils/InputQueueManager.ts

@@ -16,6 +16,9 @@ export class InputQueueManager {
   private static rl: readline.Interface | null = null;
   private static keypressListenerSetup = false;
 
+  // Tab completion state
+  private lastKeypressWasTab = false;
+
   // We keep one "live" buffer shared across stacked questions
   // (so typing is preserved when questions change)
   private currentLine = "";
@@ -57,27 +60,11 @@ export class InputQueueManager {
       historySize: 0,
 
       /**
-       * Use readline's built-in completion system so Tab does NOT insert a literal tab.
+       * Disable readline's built-in completion display - we handle Tab ourselves
+       * in the keypress listener to avoid readline's kRefreshLine overwriting
+       * small completion lists (lists that fit in 1-2 lines get erased).
        */
-      completer: (line: string) => {
-        const current = this.peek();
-        const opts = current?.options ?? [];
-        if (opts.length === 0) return [[], line];
-
-        // Identify the "word" at the end of the line that we want to complete
-        // (default readline behavior is word-based completion)
-        const lastSpace = Math.max(
-          line.lastIndexOf(" "),
-          line.lastIndexOf("\t")
-        );
-        const word = line.slice(lastSpace + 1); // the token to complete
-
-        const hits = opts.filter((c) => c.startsWith(word));
-
-        // Return [matches, wordToReplace]
-        // Readline will replace `word` with the selected match (or extend if unique)
-        return [hits, word];
-      },
+      completer: (line: string) => [[], line],
     });
 
     // When user presses Enter, buffer the line for paste detection
@@ -177,6 +164,16 @@ export class InputQueueManager {
           instance.savedLineBeforeHistory = "";
         }
 
+        // Handle Tab completion ourselves to avoid readline's kRefreshLine
+        // overwriting small completion lists (1-2 line lists get erased by readline).
+        if (key?.name === "tab") {
+          instance.handleTabCompletion();
+          return;
+        }
+
+        // Any non-tab keypress resets the "last was tab" state
+        instance.lastKeypressWasTab = false;
+
         // Custom Up/Down history navigation using only passed-in history
         if (key?.name === "up") {
           const history = instance.getHistory();
@@ -311,6 +308,120 @@ export class InputQueueManager {
     return out;
   }
 
+  /**
+   * Handle Tab key completion manually.
+   *
+   * We do this ourselves instead of using readline's built-in completer because
+   * readline's kRefreshLine (called after displaying completions) uses
+   * clearScreenDown which erases small completion lists (1-2 lines) that fit
+   * within the terminal's current scroll region. Large lists scroll past and
+   * survive, but small lists get wiped out before the user can read them.
+   *
+   * Behavior:
+   * - First Tab: extend line to longest common prefix of matches (if possible)
+   * - Second consecutive Tab (no extension possible): print the matches list
+   */
+  private handleTabCompletion(): void {
+    const current = this.peek();
+    const opts = current?.options ?? [];
+
+    // Sync current line from readline before we do anything
+    this.syncFromReadline();
+    const line = this.currentLine;
+
+    if (opts.length === 0) {
+      this.lastKeypressWasTab = false;
+      return;
+    }
+
+    // Find the "word" to complete (everything after last space/tab)
+    const lastSpace = Math.max(line.lastIndexOf(" "), line.lastIndexOf("\t"));
+    const word = line.slice(lastSpace + 1);
+
+    const hits = opts.filter((c) => c.startsWith(word));
+
+    let effectiveHits: string[];
+    let completionWord: string; // the replacement for `word` in the line
+
+    if (hits.length > 0) {
+      // Exact prefix matches: use normal longest-common-prefix logic
+      effectiveHits = hits;
+      completionWord = this.longestCommonPrefix(effectiveHits);
+    } else {
+      // Contains matches: find options that contain the typed word somewhere
+      const containsHits = opts.filter((c) => c.includes(word));
+      effectiveHits = containsHits;
+
+      if (containsHits.length > 0) {
+        // If there's only one match, complete to the full option string
+        if (containsHits.length === 1) {
+          completionWord = containsHits[0];
+        } else {
+        // For each match, find the position of `word` inside it, then take
+        // the substring from that position and find the longest common prefix
+        // of all those suffixes. This gives us the longest unambiguous extension
+        // starting from the user's typed word.
+        const suffixes = containsHits.map((c) => {
+          const idx = c.indexOf(word);
+          return c.slice(idx); // e.g. "opus-4-5" from "anthropic/claude-opus-4-5"
+        });
+        completionWord = this.longestCommonPrefix(suffixes);
+        }
+      } else {
+        completionWord = word;
+      }
+    }
+
+    if (effectiveHits.length === 0) {
+      this.lastKeypressWasTab = false;
+      return;
+    }
+
+    if (completionWord.length > word.length) {
+      // Can extend - replace word with the longer completion
+      const before = line.slice(0, lastSpace + 1);
+      const newLine = before + completionWord;
+      this.replaceLine(newLine);
+      this.currentLine = newLine;
+      this.lastKeypressWasTab = false;
+      return;
+    }
+
+    // No extension possible - show list on second consecutive Tab
+    if (!this.lastKeypressWasTab) {
+      // First tab with no extension: just set flag, user needs to tab again
+      this.lastKeypressWasTab = true;
+      return;
+    }
+
+    // Second consecutive tab: print the completions list
+    this.lastKeypressWasTab = false;
+    const columns = process.stdout.columns || 80;
+    const maxWidth = Math.max(...effectiveHits.map((h) => h.length)) + 2;
+    const numCols = Math.max(1, Math.floor(columns / maxWidth));
+    const rows: string[] = [];
+    for (let i = 0; i < effectiveHits.length; i += numCols) {
+      const row = effectiveHits.slice(i, i + numCols);
+      rows.push(row.map((h) => h.padEnd(maxWidth)).join(""));
+    }
+    // Write completions. We intentionally do NOT call rl.prompt() here because
+    // readline tracks the cursor row internally. When prompt(true) is called,
+    // readline moves the cursor back UP to where it thinks the prompt is and
+    // redraws — overwriting any completion output that fit within the same scroll
+    // region (i.e., small lists that didn't cause the terminal to scroll).
+    //
+    // Instead, we write the completions and then a fresh prompt line manually,
+    // without involving readline's cursor tracking at all.
+    const promptText = current!.question;
+    const inputText = this.currentLine;
+    process.stdout.write("\r\n" + rows.join("\r\n") + "\r\n" + promptText + inputText);
+    // Now sync readline's internal state to match what we drew manually.
+    // We replace the line content via ctrl+u then re-type it so readline's
+    // internal `line` buffer and cursor position are correct.
+    InputQueueManager.rl?.write(null, { ctrl: true, name: "u" });
+    if (inputText) InputQueueManager.rl?.write(inputText);
+  }
+
   private render(): void {
     if (!InputQueueManager.rl) return;
     const current = this.peek();

package/test-ai-completion.ts

@@ -0,0 +1,39 @@
+/**
+ * Direct test of createAiCompletion outside the script sandbox
+ */
+import { createAiCompletion } from './src/agents/tools/aiClient';
+import { services } from './src/services';
+
+async function main() {
+  // Initialize services
+  const svc = services();
+  
+  // Wait for clients to initialize
+  await new Promise(resolve => setTimeout(resolve, 2000));
+
+  console.log('Testing createAiCompletion directly...');
+  
+  // Test with anthropic (empty provider - auto-detect from model)
+  try {
+    const result = await createAiCompletion.call(svc.Tools, 'anthropic', {
+      model: 'claude-3-5-haiku-20241022',
+      messages: [{ role: 'user', content: 'Say hello in 5 words' }]
+    });
+    console.log('Direct call result:', result?.choices?.[0]?.message?.content);
+  } catch(e) {
+    console.error('Direct call error:', e.message);
+  }
+  
+  // Test with empty provider
+  try {
+    const result2 = await createAiCompletion.call(svc.Tools, '', {
+      model: 'claude-3-5-haiku-20241022',
+      messages: [{ role: 'user', content: 'Say hello in 5 words' }]
+    });
+    console.log('Empty provider result:', result2?.choices?.[0]?.message?.content);
+  } catch(e) {
+    console.error('Empty provider error:', e.message);
+  }
+}
+
+main().catch(console.error).finally(() => process.exit(0));

package/test-mcp-args.ts

@@ -0,0 +1,71 @@
+/**
+ * Test how McpServer's toZodSchema + Object.values parses createAiCompletion args
+ */
+import { McpServerService } from './src/services/McpServer';
+import { ToolsService } from './src/services/Tools';
+import { services } from './src/services';
+
+// Simulate the properties from createAiCompletion tool definition
+const createAiCompletionProps = {
+  provider: {
+    type: "string",
+    description: "The AI provider to use",
+  },
+  options: {
+    type: "object",
+    description: "Provider-specific completion options",
+    properties: {
+      model: { type: "string", description: "The model to use" },
+      messages: {
+        type: "array",
+        description: "The chat history",
+        items: {
+          type: "object",
+          properties: {
+            role: { type: "string" },
+            content: { type: "string" },
+          },
+        },
+      },
+      max_tokens: { type: "number" },
+    },
+    required: ["model", "messages"],
+  },
+};
+
+const outerRequired = ["provider"];
+
+async function main() {
+  const svc = services();
+  const mcpServer = new McpServerService(svc.Tools);
+  
+  // Simulate toZodSchema
+  const zodSchema = mcpServer.toZodSchema(createAiCompletionProps as any, outerRequired);
+  
+  // Simulate what MCP SDK passes as args after zod parsing
+  const incomingArgs = {
+    provider: "",
+    options: {
+      model: "gpt-5-nano",
+      messages: [{ role: "user", content: "hello" }],
+      max_tokens: 5000
+    }
+  };
+  
+  try {
+    const parsed = zodSchema.parse(incomingArgs);
+    console.log('Parsed args:', JSON.stringify(parsed, null, 2));
+    console.log('Object.values(parsed):', JSON.stringify(Object.values(parsed), null, 2));
+    console.log('Keys order:', Object.keys(parsed));
+    
+    // Simulate what McpServer does
+    const [providerArg, optionsArg] = Object.values(parsed) as any[];
+    console.log('provider arg:', JSON.stringify(providerArg));
+    console.log('options arg:', JSON.stringify(optionsArg));
+    console.log('options.model:', optionsArg?.model);
+  } catch(e) {
+    console.error('Zod parse error:', e.message);
+  }
+}
+
+main().catch(console.error).finally(() => process.exit(0));

package/test-tools-service.ts

@@ -0,0 +1,45 @@
+/**
+ * Test ToolsService.callTool for createAiCompletion directly
+ */
+import { services } from './src/services';
+
+async function main() {
+  const svc = services();
+  
+  // Wait for services to init
+  await new Promise(resolve => setTimeout(resolve, 2000));
+
+  const toolsService = svc.Tools;
+  
+  // Check tool definition
+  const toolDef = toolsService.getTool('createAiCompletion');
+  console.log('Tool found:', !!toolDef);
+  console.log('positional:', toolDef?.function?.parameters?.positional);
+  console.log('properties keys:', Object.keys(toolDef?.function?.parameters?.properties || {}));
+  
+  // Simulate what SandboxContext.callTool does
+  const toolCall = {
+    id: 'test-123',
+    type: 'function' as const,
+    function: {
+      name: 'createAiCompletion',
+      arguments: JSON.stringify({
+        provider: '',
+        options: {
+          model: 'claude-3-haiku-20240307',
+          messages: [{ role: 'user', content: 'Say hello in 5 words' }]
+        }
+      })
+    }
+  };
+
+  try {
+    const result = await toolsService.callTool(toolCall);
+    console.log('Result functionResp:', JSON.stringify(result?.functionResp)?.substring(0, 200));
+    console.log('Tool messages content:', result?.toolMessages?.[0]?.content?.substring(0, 200));
+  } catch(e) {
+    console.error('Error:', e.message);
+  }
+}
+
+main().catch(console.error).finally(() => process.exit(0));

package/ts_build/package.json

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

package/ts_build/src/agents/base/base.js

@@ -166,11 +166,17 @@ class BaseAgent {
         if (!this.client) {
             if (this.provider) {
                 this.log(`Getting client for provider ${this.provider}`);
-                this.client = this.clientService.getClient(this.provider)?.client;
+                const clientInfo = this.clientService.getClient(this.getProvider());
+                if (clientInfo) {
+                    this.client = clientInfo.client;
+                }
             }
             if (!this.client) {
                 this.log(`Getting client for model ${this.modelName}`);
-                this.client = this.clientService.getClient(undefined, this.modelName)?.client;
+                const clientInfo = this.clientService.getClient(undefined, this.getModel());
+                if (clientInfo) {
+                    this.client = clientInfo.client;
+                }
             }
         }
         return this.client;