@tyvm/knowhow 0.0.32 → 0.0.34

package/src/agents/tools/aiClient.ts

@@ -1,4 +1,4 @@
-import { Clients } from "../../clients";
+import { ToolsService } from "../../services/Tools";
 import {
   GenericClient,
   CompletionOptions,
@@ -6,31 +6,97 @@ import {
   EmbeddingOptions,
   EmbeddingResponse,
 } from "../../clients/types";
+import { services } from "../../services";
 
 export function createAiCompletion(
+  this: ToolsService,
   provider: string,
   options: CompletionOptions
 ): Promise<CompletionResponse> {
-  return Clients.createCompletion(provider, options);
+  // 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.createCompletion(provider, options);
 }
 
 export function createEmbedding(
+  this: ToolsService,
   provider: string,
   options: EmbeddingOptions
 ): Promise<EmbeddingResponse> {
-  return Clients.createEmbedding(provider, options);
+  // 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.createEmbedding(provider, options);
 }
 
 export async function listModelsForProvider(
+  this: ToolsService,
   provider: string
 ): Promise<string[]> {
-  return Clients.getRegisteredModels(provider);
+  // 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.getRegisteredModels(provider);
 }
 
-export async function listAllModels(): Promise<Record<string, string[]>> {
-  return Clients.listAllModels();
+export async function listAllModels(
+  this: ToolsService
+): 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.listAllModels();
 }
 
-export async function listAllProviders(): Promise<string[]> {
-  return Clients.listAllProviders();
+export async function listAllProviders(this: ToolsService): Promise<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.listAllProviders();
 }

package/src/agents/tools/execCommand.ts

@@ -4,9 +4,9 @@ import { promisify } from "util";
 const execAsync = promisify(exec);
 
 export interface ExecCommandOptions {
-  timeout?: number; // Timeout in milliseconds
-  killOnTimeout?: boolean; // Whether to kill the command on timeout (default: false)
-  waitForCompletion?: boolean; // Whether to wait for full completion (default: true)
+  timeout?: number; // Timeout in milliseconds (default: 5000)
+  continueInBackground?: boolean; // Whether to let command continue in background on timeout (default: false)
+  waitForCompletion?: boolean; // Whether to wait for full completion regardless of timeout (default: false)
 }
 
 // Enhanced exec function with timeout support
@@ -19,13 +19,10 @@ const execWithTimeout = async (
   timedOut: boolean;
   killed: boolean;
 }> => {
-  const { timeout, killOnTimeout = false } = options;
+  const { timeout = 5000, continueInBackground = false, waitForCompletion = false } = options;
 
-  // If no timeout is specified, default to waiting for completion
-  const { waitForCompletion = !timeout } = options;
-
-  if (!timeout || waitForCompletion) {
-    // Default behavior - wait for completion
+  // If waitForCompletion is explicitly true, ignore timeout and wait indefinitely
+  if (waitForCompletion === true) {
     try {
       const result = await execAsync(command);
       return { ...result, timedOut: false, killed: false };
@@ -39,7 +36,7 @@ const execWithTimeout = async (
     }
   }
 
-  // Timeout behavior
+  // Timeout behavior when waitForCompletion is false
   return new Promise((resolve) => {
     const childProcess = exec(command, (error, stdout, stderr) => {
       if (error && !error.killed) {
@@ -60,7 +57,8 @@ const execWithTimeout = async (
     });
 
     const timeoutId = setTimeout(() => {
-      if (killOnTimeout) {
+      if (!continueInBackground) {
+        // Kill the process if continueInBackground is false (default behavior)
         childProcess.kill("SIGTERM");
         // Force kill after additional 5 seconds if still running
         setTimeout(() => {
@@ -75,6 +73,7 @@ const execWithTimeout = async (
           killed: true,
         });
       } else {
+        // Let command continue in background
         resolve({
           stdout: "",
           stderr: `Command timed out after ${timeout}ms but is still running in background`,
@@ -95,7 +94,7 @@ const execWithTimeout = async (
 export const execCommand = async (
   command: string,
   timeout?: number,
-  killOnTimeout?: boolean,
+  continueInBackground?: boolean,
   waitForCompletion?: boolean
 ): Promise<string> => {
   let output = "";
@@ -103,7 +102,7 @@ export const execCommand = async (
 
   const { stdout, stderr, timedOut, killed } = await execWithTimeout(command, {
     timeout,
-    killOnTimeout,
+    continueInBackground,
     waitForCompletion,
   });
 
@@ -133,4 +132,4 @@ export const execCommand = async (
     : "";
 
   return trimmedOutput.join("\n").slice(0, maxCharacters) + trimmedMessage;
-};
+};

package/src/agents/tools/executeScript/README.md

@@ -2,6 +2,22 @@
 
 The `executeScript` tool provides secure, isolated execution of TypeScript scripts with access to the Knowhow platform's tools and AI capabilities.
 
+## Requirements
+
+### Node.js Version and Configuration
+
+**Important**: For Node.js 20.x and later, the `--no-node-snapshot` flag is required due to isolated-vm compatibility requirements.
+
+```bash
+# Required for Node.js 20+
+node --no-node-snapshot your-app.js
+
+# Or set in package.json scripts
+"scripts": {
+  "start": "node --no-node-snapshot dist/index.js"
+}
+```
+
 ## Features
 
 - **Secure Sandbox**: Scripts run in isolated-vm with no access to Node.js APIs

package/src/agents/tools/index.ts

@@ -24,3 +24,5 @@ export * from "./googleSearch";
 export * from "./loadWebpage";
 export * from "./stringReplace";
 export * from "./executeScript";
+export * from "./startAgentTask";
+export * from "./ycmd";

package/src/agents/tools/list.ts

@@ -5,9 +5,11 @@ import { Plugins } from "../../plugins/plugins";
 const pluginNames = Plugins.listPlugins().join(", ");
 import * as github from "./github/definitions";
 import * as asana from "./asana/definitions";
+import * as ycmd from "./ycmd/definitions";
 import * as language from "./language/definitions";
 import { googleSearchDefinition } from "./googleSearch";
 import { executeScriptDefinition } from "./executeScript/definition";
+import { startAgentTaskDefinition } from "./startAgentTask";
 
 export const includedTools = [
   {
@@ -51,17 +53,17 @@ export const includedTools = [
           timeout: {
             type: "number",
             description:
-              "Timeout in milliseconds (optional). If not provided, waits indefinitely.",
+              "Timeout in milliseconds (optional). If not provided, defaults to 5000ms.",
           },
-          killOnTimeout: {
+          continueInBackground: {
             type: "boolean",
             description:
-              "Whether to kill the command when timeout is reached (default: false). If false, command continues running in background.",
+              "Whether to let command continue in background on timeout (default: false). If false, command is killed on timeout.",
           },
           waitForCompletion: {
             type: "boolean",
             description:
-              "Whether to wait for full completion regardless of timeout (default: true). Overrides timeout behavior.",
+              "Whether to wait for full completion regardless of timeout (default: false). When true, overrides timeout behavior.",
           },
         },
         required: ["command"],
@@ -141,6 +143,16 @@ export const includedTools = [
             type: "string",
             description: "The prompt related to the image",
           },
+          provider: {
+            type: "string",
+            description: "The AI provider to use (default: 'openai')",
+            default: "openai",
+          },
+          model: {
+            type: "string",
+            description: "The model to use (default: 'gpt-4o')",
+            default: "gpt-4o",
+          },
         },
         required: ["imageUrl", "question"],
       },
@@ -366,7 +378,7 @@ export const includedTools = [
     type: "function",
     function: {
       name: "createAiCompletion",
-      description: "Create a completion using the knowhow ai client",
+      description: "Create a completion using the knowhow AI client",
       parameters: {
         type: "object",
         positional: true,
@@ -374,39 +386,82 @@ export const includedTools = [
           provider: {
             type: "string",
             description:
-              "The AI provider to use (e.g., 'openai', 'anthropic'). Use listAllModels to figure out which provider to use if you don't know",
+              "The AI provider to use (e.g., 'openai', 'anthropic'). Use listAllModels to discover providers.",
           },
+
           options: {
             type: "object",
-            description: "The completion options",
+            description: "Provider-specific completion options",
             properties: {
-              model: { type: "string", description: "The model to use" },
+              model: {
+                type: "string",
+                description: "The model to use",
+              },
+
               messages: {
                 type: "array",
-                description: "The messages for the completion",
-                items: {
-                  type: "object",
-                  properties: {
-                    role: { type: "string" },
-                    content: { type: "string" },
-                  },
-                },
+                description: "The chat history for the completion",
+                items: { $ref: "#/definitions/message" },
+                minItems: 1,
               },
+
               max_tokens: {
                 type: "number",
                 description: "Maximum number of tokens to generate",
               },
+
+              tools: {
+                type: "array",
+                description: "Tool definitions the model may call",
+                items: { $ref: "#/definitions/tool" },
+              },
             },
             required: ["model", "messages"],
           },
         },
         required: ["provider"],
       },
+
       returns: {
         type: "object",
         description: "The completion response from the AI provider",
       },
     },
+
+    definitions: {
+      message: {
+        type: "object",
+        properties: {
+          role: {
+            type: "string",
+            enum: ["system", "user", "assistant", "tool"],
+          },
+          content: { type: "string" },
+        },
+        required: ["role", "content"],
+      },
+
+      tool: {
+        type: "object",
+        properties: {
+          type: {
+            type: "string",
+            enum: ["function"],
+          },
+          function: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              description: { type: "string" },
+              parameters: { type: "object" },
+              returns: { type: "object" },
+            },
+            required: ["name", "description", "parameters"],
+          },
+        },
+        required: ["type", "function"],
+      },
+    },
   },
 
   {
@@ -555,7 +610,9 @@ export const includedTools = [
   },
   executeScriptDefinition,
   googleSearchDefinition,
+  startAgentTaskDefinition,
   ...asana.definitions,
+  ...ycmd.definitions,
   ...github.definitions,
   ...language.definitions,
 ] as Tool[];

package/src/agents/tools/startAgentTask.ts

@@ -0,0 +1,109 @@
+import { Tool } from "../../clients/types";
+import { execCommand } from "./execCommand";
+
+interface StartAgentTaskParams {
+  messageId: string;
+  prompt: string;
+  provider?: string;
+  model?: string;
+  agentName?: string;
+  maxTimeLimit?: number;
+  maxSpendLimit?: number;
+}
+
+/**
+ * Creates a chat task in Knowhow based on a message ID and prompt.
+ * This allows external agents to start tasks that can receive real-time updates.
+ */
+export async function startAgentTask(params: StartAgentTaskParams) {
+  const {
+    messageId,
+    prompt,
+    provider,
+    model,
+    agentName,
+    maxTimeLimit,
+    maxSpendLimit,
+  } = params;
+
+  if (!messageId) {
+    throw new Error("messageId is required to create a chat task");
+  }
+
+  if (!prompt) {
+    throw new Error("prompt is required to create a chat task");
+  }
+
+  const escapedPrompt = prompt.replace(/"/g, '\\"');
+
+  // Build the command with all optional parameters
+  let command = `knowhow agent --input "${escapedPrompt}" --message-id ${messageId}`;
+
+  if (provider) {
+    command += ` --provider ${provider}`;
+  }
+
+  if (model) {
+    command += ` --model "${model}"`;
+  }
+
+  if (agentName) {
+    command += ` --agent-name "${agentName}"`;
+  }
+
+  if (maxTimeLimit !== undefined) {
+    command += ` --max-time-limit ${maxTimeLimit}`;
+  }
+
+  if (maxSpendLimit !== undefined) {
+    command += ` --max-spend-limit ${maxSpendLimit}`;
+  }
+
+  return execCommand(command, 60000, true);
+}
+
+export const startAgentTaskDefinition: Tool = {
+  type: "function",
+  function: {
+    name: "startAgentTask",
+    description:
+      "Create a new chat task in Knowhow based on a message ID and prompt. This allows worker agents to start tasks and update knowhow's backend with all CLI agent options",
+    parameters: {
+      type: "object",
+      properties: {
+        messageId: {
+          type: "string",
+          description:
+            "The ID of the message in Knowhow to associate with this task",
+        },
+        prompt: {
+          type: "string",
+          description: "The prompt or description for the task to be created",
+        },
+        provider: {
+          type: "string",
+          description:
+            "AI provider (openai, anthropic, google, xai). Default: openai",
+        },
+        model: {
+          type: "string",
+          description: "Specific model for the provider",
+        },
+        agentName: {
+          type: "string",
+          description: "Which agent to use. Default: Patcher",
+        },
+        maxTimeLimit: {
+          type: "number",
+          description: "Time limit for agent execution in minutes. Default: 30",
+        },
+        maxSpendLimit: {
+          type: "number",
+          description: "Cost limit for agent execution in dollars. Default: 10",
+        },
+      },
+      required: ["messageId", "prompt"],
+    },
+  },
+};
+

package/src/agents/tools/textSearch.ts

@@ -3,7 +3,7 @@ import { execCommand } from "./execCommand";
 
 export async function textSearch(searchTerm) {
   try {
-    const command = `ag -m 3 "${searchTerm}"`;
+    const command = `ag -m 3 -Q "${searchTerm}"`;
     const output = await execCommand(command);
     return output;
   } catch (err) {

package/src/agents/tools/visionTool.ts

@@ -1,6 +1,35 @@
+import { services, ToolsService } from "../../services";
 import { askGptVision } from "../../ai";
+import { Models } from "../../types";
 
-export async function visionTool(imageUrl: string, question: string) {
-  const response = await askGptVision(imageUrl, question);
+export async function visionTool(
+  imageUrl: string,
+  question: string,
+  provider = "openai",
+  model = Models.openai.GPT_4o
+) {
+  const toolService =
+    this instanceof ToolsService ? (this as ToolsService) : services().Tools;
+
+  const { Clients } = toolService.getContext();
+
+  const response = await Clients.createCompletion(provider, {
+    model,
+    max_tokens: 2500,
+    messages: [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: question },
+          {
+            type: "image_url",
+            image_url: {
+              url: imageUrl,
+            },
+          },
+        ],
+      },
+    ],
+  });
   return response.choices[0].message.content;
 }