@tyvm/knowhow 0.0.128 → 0.0.130

package/src/services/KnowhowClient.ts

@@ -61,7 +61,7 @@ export interface CreateMessageTaskResponse {
 
 export interface UpdateOrgTaskRequest {
   threads: Message[][];
-  totalCostUsd: number;
+  totalUsdCost: number;
   inProgress: boolean;
   result?: string;
 }
@@ -799,4 +799,65 @@ export class KnowhowSimpleClient {
     );
     return response.data;
   }
+
+  // ============================================
+  // Org Behaviors Methods
+  // ============================================
+
+  /**
+   * List all behaviors for the current org
+   */
+  async getOrgBehaviors() {
+    await this.checkJwt();
+    return http.get<Record<string, unknown>[]>(
+      `${this.baseUrl}/api/org-behaviors`,
+      { headers: this.headers }
+    );
+  }
+
+  /**
+   * List all skills (isSkill=true) for the current org
+   */
+  async getOrgSkills(includeInternal = true) {
+    await this.checkJwt();
+    return http.get<Record<string, unknown>[]>(
+      `${this.baseUrl}/api/org-behaviors/skills?includeInternal=${includeInternal}`,
+      { headers: this.headers }
+    );
+  }
+
+  /**
+   * Create a new org behavior
+   */
+  async createOrgBehavior(data: Record<string, unknown>) {
+    await this.checkJwt();
+    return http.post<Record<string, unknown>>(
+      `${this.baseUrl}/api/org-behaviors`,
+      data,
+      { headers: this.headers }
+    );
+  }
+
+  /**
+   * Update an existing org behavior by ID
+   */
+  async updateOrgBehavior(id: string, data: Record<string, unknown>) {
+    await this.checkJwt();
+    return http.put<Record<string, unknown>>(
+      `${this.baseUrl}/api/org-behaviors/${id}`,
+      data,
+      { headers: this.headers }
+    );
+  }
+
+  /**
+   * Get triggered behaviors for a given user input string
+   */
+  async getTriggeredBehaviors(userInput: string) {
+    await this.checkJwt();
+    return http.get<{ triggered: Record<string, unknown>[]; trigger_type: string }>(
+      `${this.baseUrl}/api/org-behaviors/triggered?userInput=${encodeURIComponent(userInput)}`,
+      { headers: this.headers }
+    );
+  }
 }

package/src/services/LazyToolsService.ts

@@ -9,6 +9,18 @@ import {
 } from "../agents/tools/lazy";
 import { definitions } from "../agents/tools/lazy/definitions";
 
+/*
+ *
+ * This ToolService design allows an agent to start with a few enabled tools,
+ * search and enable additional tools
+ *
+ * One drawback: enabling a tool will bust the cache, causing you to have to pay extra after enabling new tools
+ * Benefit: for providers with limits on how many tools you can support, this tool service allows you to have the minimal set of tools you need to use in the tools array. Smaller context usage
+ *
+ * In a longer running session, where the agent's tools accumulate over multiple interactions, the cache busting is minimized
+ * In web sessions where you get a new ToolService each interaction, then the cache busting is going to happen with each enable
+ *
+ */
 export class LazyToolsService extends ToolsService {
   private allTools: Tool[] = [];
   // Start with lazy tools enabled by default

package/src/services/MinimalToolsService.ts

@@ -0,0 +1,167 @@
+import { ToolsService, ToolContext } from "./Tools";
+import { Tool, ToolCall } from "../clients/types";
+import { callTool } from "../agents/tools/minimal/callTool";
+import { inspectTools } from "../agents/tools/minimal/inspectTools";
+import { minimalDefinitions } from "../agents/tools/minimal/definitions";
+import { finalAnswer } from "../agents/tools/finalAnswer";
+import { includedTools } from "../agents/tools/list";
+
+/*
+ * MinimalToolsService
+ *
+ * A cache-stable ToolService: the `tools:` array sent to the AI is always the
+ * same small set of base tools (callTool, inspectTools, finalAnswer + any
+ * explicitly registered base tools). All other tools live in `allTools` and
+ * are callable via callTool(name, args).
+ *
+ * Benefits over LazyToolsService:
+ * - The `tools:` array NEVER changes during a session → zero cache busts from tool changes.
+ * - Works on all providers and older models (no provider-specific defer_loading needed).
+ * - Agents discover tools via inspectTools() and call them via callTool().
+ */
+export class MinimalToolsService extends ToolsService {
+  /** Full catalog of every registered tool (base + extended). */
+  private allToolsCatalog: Tool[] = [];
+
+  constructor(context?: ToolContext) {
+    super(context);
+    this.registerMinimalTools();
+  }
+
+  /**
+   * Registers the immutable base tools.
+   * These are the only tools that ever appear in the `tools:` array.
+   */
+  private registerMinimalTools(): void {
+    // finalAnswer definition is sourced from the included tools list
+    const finalAnswerDef = includedTools.find(
+      (t) => t.function.name === "finalAnswer"
+    );
+
+    const baseDefs: Tool[] = [
+      ...(finalAnswerDef ? [finalAnswerDef as Tool] : []),
+      ...minimalDefinitions,
+    ];
+
+    // Add base tool defs to both catalogs
+    this.allToolsCatalog.push(...baseDefs);
+    super.addTools(baseDefs);
+
+    // Register implementations
+    this.addFunctions({
+      finalAnswer: finalAnswer.bind(this),
+      callTool: callTool.bind(this),
+      inspectTools: inspectTools.bind(this),
+    });
+  }
+
+  /**
+   * Override addTools so that newly-registered tools go into the full catalog
+   * but NOT into the visible `tools` array (which stays stable).
+   */
+  addTools(tools: Tool[]): void {
+    const existingNames = this.allToolsCatalog.map((t) => t.function.name);
+    const newTools = tools.filter(
+      (t) => !existingNames.includes(t.function.name)
+    );
+    this.allToolsCatalog.push(...newTools);
+    // Do NOT call super.addTools() — base tools array stays frozen.
+  }
+
+  addTool(tool: Tool): void {
+    this.addTools([tool]);
+  }
+
+  /**
+   * Returns only the stable base tools (what gets sent in `tools:` to the AI).
+   */
+  getTools(): Tool[] {
+    return super.getTools();
+  }
+
+  /**
+   * Returns every tool in the catalog (base + extended). Used by callTool /
+   * inspectTools for dispatching and schema lookup.
+   */
+  getAllTools(): Tool[] {
+    return this.allToolsCatalog;
+  }
+
+  /**
+   * Calls a tool by its resolved name, bypassing the enabled-tools check that
+   * the base class applies. Used internally by the callTool dispatch function.
+   * Returns the raw functionResp (unwrapped), used by the callTool meta-tool.
+   */
+  async callToolByName(
+    toolCall: ToolCall,
+    resolvedName: string
+  ): Promise<any> {
+    const result = await this.dispatchToTool(toolCall, resolvedName);
+    return result.functionResp;
+  }
+
+  /**
+   * Shared dispatch logic: temporarily surfaces the target tool (if it's not
+   * already visible) so the base ToolsService.callTool can find its
+   * definition and implementation, then restores the visible set.
+   * Used both by direct calls (agent calls the tool by its real name) and by
+   * the callTool meta-tool (agent calls callTool({ name, args })).
+   */
+  private async dispatchToTool(toolCall: ToolCall, resolvedName: string) {
+    // Temporarily surface the target tool in the visible list so base
+    // ToolsService.callTool can find its definition, then restore state.
+    const alreadyVisible = super
+      .getTools()
+      .some((t) => t.function.name === resolvedName);
+
+    if (!alreadyVisible) {
+      const toolDef = this.allToolsCatalog.find(
+        (t) => t.function.name === resolvedName
+      );
+      if (toolDef) {
+        super.addTools([toolDef]);
+      }
+    }
+
+    const result = await super.callTool(toolCall, [resolvedName]);
+
+    // Remove the temporarily-added tool to keep the visible set stable
+    if (!alreadyVisible) {
+      this.tools = this.tools.filter((t) => t.function.name !== resolvedName);
+    }
+
+    return result;
+  }
+
+  /**
+   * Delegates to the full catalog for resolution, then runs via callToolByName.
+   */
+  async callTool(toolCall: ToolCall, enabledTools?: string[]): Promise<any> {
+    const functionName = toolCall.function.name;
+
+    // Base tools (callTool, inspectTools, finalAnswer) → standard dispatch
+    const isBaseTool = super
+      .getTools()
+      .some((t) => t.function.name === functionName);
+
+    if (isBaseTool) {
+      return super.callTool(toolCall, this.getToolNames());
+    }
+
+    // Extended tools: called directly by name (not via the callTool meta-tool).
+    // These live only in allToolsCatalog, not in the frozen visible `tools`
+    // array, so we must temporarily surface them the same way callToolByName
+    // does, otherwise base ToolsService.getTool() won't find the definition
+    // and will throw "Tool ... not found" even though it's a registered tool.
+    const existsInCatalog = this.allToolsCatalog.some(
+      (t) => t.function.name === functionName
+    );
+
+    if (existsInCatalog) {
+      return this.dispatchToTool(toolCall, functionName);
+    }
+
+    // Not found anywhere - let the base class produce the standard error.
+    return super.callTool(toolCall, [functionName]);
+  }
+}