@tyvm/knowhow 0.0.32 → 0.0.34

package/src/processors/CustomVariables.ts

@@ -0,0 +1,425 @@
+import { Message } from "../clients/types";
+import { MessageProcessorFunction } from "../services/MessageProcessor";
+import { ToolsService } from "../services";
+import { Tool } from "../clients";
+
+interface VariableStorage {
+  [name: string]: any;
+}
+
+export class CustomVariables {
+  private variables: VariableStorage = {};
+  private setVariableToolName = "setVariable";
+  private getVariableToolName = "getVariable";
+  private storeToolCallToolName = "storeToolCallToVariable";
+  private listVariablesToolName = "listVariables";
+  private deleteVariableToolName = "deleteVariable";
+
+  constructor(private toolsService: ToolsService) {
+    this.registerTools(toolsService);
+  }
+
+  /**
+   * Validates variable names - alphanumeric and underscore allowed
+   */
+  private isValidVariableName(name: string): boolean {
+    return /^[a-zA-Z0-9_]+$/.test(name);
+  }
+
+  /**
+   * Sets a variable value
+   */
+  private setVariable(name: string, contents: any): string {
+    if (!this.isValidVariableName(name)) {
+      return `Error: Invalid variable name "${name}". Only alphanumeric characters and underscores are allowed.`;
+    }
+
+    this.variables[name] = contents;
+    return `Variable "${name}" has been set successfully.`;
+  }
+
+  /**
+   * Gets a variable value
+   */
+  private getVariable(varName: string): string {
+    if (!this.isValidVariableName(varName)) {
+      return `Error: Invalid variable name "${varName}". Only alphanumeric characters and underscores are allowed.`;
+    }
+
+    if (!(varName in this.variables)) {
+      return `Error: Variable "${varName}" is not defined. Available variables: ${Object.keys(
+        this.variables
+      ).join(", ")}`;
+    }
+
+    const value = this.variables[varName];
+    if (typeof value === "string") {
+      return value;
+    }
+    return JSON.stringify(value, null, 2);
+  }
+
+  /**
+   * Stores the result of a tool call to a variable
+   */
+  private async storeToolCallToVariable(
+    varName: string,
+    toolName: string,
+    toolArgs: string
+  ): Promise<string> {
+    if (!this.isValidVariableName(varName)) {
+      return `Error: Invalid variable name "${varName}". Only alphanumeric characters and underscores are allowed.`;
+    }
+
+    try {
+      // Parse tool arguments
+      let parsedArgs: any;
+      try {
+        parsedArgs = JSON.parse(toolArgs);
+      } catch {
+        return `Error: Invalid JSON in toolArgs parameter: ${toolArgs}`;
+      }
+
+      const result = await this.toolsService.callTool({
+        id: `${toolName}-${Date.now()}`,
+        type: "function",
+        function: {
+          name: toolName,
+          arguments: parsedArgs,
+        },
+      });
+      this.variables[varName] = result;
+
+      return `Tool call result for "${toolName}" has been stored in variable "${varName}".`;
+    } catch (error: any) {
+      return `Error storing tool call result: ${error.message}`;
+    }
+  }
+
+  /**
+   * Lists all stored variables with their values
+   */
+  private listVariables(): string {
+    const variableNames = Object.keys(this.variables);
+    
+    if (variableNames.length === 0) {
+      return "No variables are currently stored.";
+    }
+
+    const variableList = variableNames.map(name => {
+      const value = this.variables[name];
+      const preview = typeof value === "string" 
+        ? (value.length > 50 ? value.substring(0, 50) + "..." : value)
+        : JSON.stringify(value).substring(0, 50) + (JSON.stringify(value).length > 50 ? "..." : "");
+      return `- ${name}: ${preview}`;
+    }).join("\n");
+
+    return `Currently stored variables (${variableNames.length}):\n${variableList}`;
+  }
+
+  /**
+   * Deletes a specific variable
+   */
+  private deleteVariable(varName: string): string {
+    if (!this.isValidVariableName(varName)) {
+      return `Error: Invalid variable name "${varName}". Only alphanumeric characters and underscores are allowed.`;
+    }
+
+    if (!(varName in this.variables)) {
+      return `Error: Variable "${varName}" is not defined. Available variables: ${Object.keys(
+        this.variables
+      ).join(", ")}`;
+    }
+
+    delete this.variables[varName];
+    return `Variable "${varName}" has been deleted successfully.`;
+  }
+
+  /**
+   * Recursively processes a value to substitute {{variable}} patterns
+   */
+  private substituteVariables(
+    value: any,
+    processedVars: Set<string> = new Set()
+  ): any {
+    if (typeof value === "string") {
+      // Find all {{variable}} patterns
+      return value.replace(/\{\{([a-zA-Z0-9_]+)\}\}/g, (match, varName) => {
+        // Prevent infinite recursion
+        if (processedVars.has(varName)) {
+          return `{{ERROR: Circular reference detected for variable "${varName}"}}`;
+        }
+
+        if (!(varName in this.variables)) {
+          return `{{ERROR: Variable "${varName}" is not defined}}`;
+        }
+
+        const varValue = this.variables[varName];
+
+        // If the variable value is a string, recursively process it
+        if (typeof varValue === "string") {
+          const newProcessedVars = new Set(processedVars);
+          newProcessedVars.add(varName);
+          return this.substituteVariables(varValue, newProcessedVars);
+        }
+
+        // For non-string values, convert to JSON
+        return JSON.stringify(varValue);
+      });
+    }
+
+    if (Array.isArray(value)) {
+      return value.map((item) => this.substituteVariables(item, processedVars));
+    }
+
+    if (value && typeof value === "object") {
+      const result: any = {};
+      for (const [key, val] of Object.entries(value)) {
+        result[key] = this.substituteVariables(val, processedVars);
+      }
+      return result;
+    }
+
+    return value;
+  }
+
+  /**
+   * Processes messages to substitute variables in content and tool call arguments
+   */
+  private processMessage(message: Message): Message {
+    // Create a copy of the message to avoid mutating the original
+    const processedMessage: Message = { ...message };
+
+    // Process message content
+    if (typeof processedMessage.content === "string") {
+      processedMessage.content = this.substituteVariables(
+        processedMessage.content
+      );
+    }
+
+    // Process tool calls if they exist
+    if (processedMessage.tool_calls) {
+      processedMessage.tool_calls = processedMessage.tool_calls.map(
+        (toolCall) => ({
+          ...toolCall,
+          function: {
+            ...toolCall.function,
+            arguments: this.substituteVariables(toolCall.function.arguments),
+          },
+        })
+      );
+    }
+
+    return processedMessage;
+  }
+
+  /**
+   * Creates a message processor function that substitutes variables in messages
+   */
+  createProcessor(
+    filterFn?: (msg: Message) => boolean
+  ): MessageProcessorFunction {
+    return async (originalMessages: Message[], modifiedMessages: Message[]) => {
+      // Process messages in place - substitute variables before tool calls are executed
+      for (let i = 0; i < modifiedMessages.length; i++) {
+        const message = modifiedMessages[i];
+
+        if (filterFn && !filterFn(message)) {
+          continue;
+        }
+
+        // Apply variable substitution
+        modifiedMessages[i] = this.processMessage(message);
+      }
+    };
+  }
+
+  /**
+   * Registers all custom variable tools with the ToolsService
+   */
+  private registerTools(toolsService: ToolsService): void {
+    // Register setVariable tool
+    if (!toolsService.getTool(this.setVariableToolName)) {
+      toolsService.addTool(setVariableToolDefinition);
+      toolsService.addFunctions({
+        [this.setVariableToolName]: (name: string, contents: any) => {
+          return this.setVariable(name, contents);
+        },
+      });
+    }
+
+    // Register getVariable tool
+    if (!toolsService.getTool(this.getVariableToolName)) {
+      toolsService.addTool(getVariableToolDefinition);
+      toolsService.addFunctions({
+        [this.getVariableToolName]: (varName: string) => {
+          return this.getVariable(varName);
+        },
+      });
+    }
+
+    // Register storeToolCallToVariable tool
+    if (!toolsService.getTool(this.storeToolCallToolName)) {
+      toolsService.addTool(storeToolCallToVariableDefinition);
+      toolsService.addFunctions({
+        [this.storeToolCallToolName]: async (
+          varName: string,
+          toolName: string,
+          toolArgs: string
+        ) => {
+          return await this.storeToolCallToVariable(
+            varName,
+            toolName,
+            toolArgs
+          );
+        },
+      });
+    }
+
+    // Register listVariables tool
+    if (!toolsService.getTool(this.listVariablesToolName)) {
+      toolsService.addTool(listVariablesToolDefinition);
+      toolsService.addFunctions({
+        [this.listVariablesToolName]: () => {
+          return this.listVariables();
+        },
+      });
+    }
+
+    // Register deleteVariable tool
+    if (!toolsService.getTool(this.deleteVariableToolName)) {
+      toolsService.addTool(deleteVariableToolDefinition);
+      toolsService.addFunctions({
+        [this.deleteVariableToolName]: (varName: string) => {
+          return this.deleteVariable(varName);
+        },
+      });
+    }
+  }
+
+  /**
+   * Gets all variable names
+   */
+  getVariableNames(): string[] {
+    return Object.keys(this.variables);
+  }
+
+  /**
+   * Clears all variables
+   */
+  clearVariables(): void {
+    this.variables = {};
+  }
+
+  /**
+   * Gets the number of stored variables
+   */
+  getVariableCount(): number {
+    return Object.keys(this.variables).length;
+  }
+}
+
+export const setVariableToolDefinition: Tool = {
+  type: "function",
+  function: {
+    name: "setVariable",
+    description:
+      "Store a value in a variable for later use. The variable can then be referenced using {{variableName}} syntax in messages or tool calls.",
+    parameters: {
+      type: "object",
+      positional: true,
+      properties: {
+        name: {
+          type: "string",
+          description:
+            "The name of the variable (alphanumeric and underscore only)",
+        },
+        contents: {
+          type: "string",
+          description: "The value to store in the variable",
+        },
+      },
+      required: ["name", "contents"],
+    },
+  },
+};
+
+export const getVariableToolDefinition: Tool = {
+  type: "function",
+  function: {
+    name: "getVariable",
+    description: "Retrieve the value of a previously stored variable.",
+    parameters: {
+      type: "object",
+      positional: true,
+      properties: {
+        varName: {
+          type: "string",
+          description: "The name of the variable to retrieve",
+        },
+      },
+      required: ["varName"],
+    },
+  },
+};
+
+export const storeToolCallToVariableDefinition: Tool = {
+  type: "function",
+  function: {
+    name: "storeToolCallToVariable",
+    description:
+      "Execute a tool call and store its result in a variable for later use.",
+    parameters: {
+      type: "object",
+      positional: true,
+      properties: {
+        varName: {
+          type: "string",
+          description: "The name of the variable to store the result in",
+        },
+        toolName: {
+          type: "string",
+          description: "The name of the tool to call",
+        },
+        toolArgs: {
+          type: "string",
+          description: "The arguments for the tool call as a JSON string",
+        },
+      },
+      required: ["varName", "toolName", "toolArgs"],
+    },
+  },
+};
+
+export const listVariablesToolDefinition: Tool = {
+  type: "function",
+  function: {
+    name: "listVariables",
+    description: "List all currently stored variables with their values.",
+    parameters: {
+      type: "object",
+      positional: false,
+      properties: {},
+      required: [],
+    },
+  },
+};
+
+export const deleteVariableToolDefinition: Tool = {
+  type: "function",
+  function: {
+    name: "deleteVariable",
+    description: "Delete a specific variable from storage.",
+    parameters: {
+      type: "object",
+      positional: true,
+      properties: {
+        varName: {
+          type: "string",
+          description: "The name of the variable to delete",
+        },
+      },
+      required: ["varName"],
+    },
+  },
+};

package/src/processors/HarmonyToolProcessor.ts

@@ -0,0 +1,264 @@
+import { Message, ToolCall } from "../clients/types";
+import { MessageProcessorFunction } from "../services/MessageProcessor";
+
+export class HarmonyToolProcessor {
+  private static instance: HarmonyToolProcessor;
+
+  /**
+   * Get singleton instance
+   */
+  static getInstance(): HarmonyToolProcessor {
+    if (!HarmonyToolProcessor.instance) {
+      HarmonyToolProcessor.instance = new HarmonyToolProcessor();
+    }
+    return HarmonyToolProcessor.instance;
+  }
+
+  /**
+   * Detects Harmony tool call patterns in text content
+   * Looks for patterns like: <|channel|>commentary to=functions.toolName <|constrain|>json<|message|>{"args":"value"}
+   */
+  private detectHarmonyToolCalls(
+    content: string
+  ): { toolName: string; arguments: string; fullMatch: string }[] {
+    const toolCalls: {
+      toolName: string;
+      arguments: string;
+      fullMatch: string;
+    }[] = [];
+
+    // Pattern to match Harmony tool calls:
+    // <|channel|>commentary to=functions.toolName <|constrain|>json<|message|>{"args":"value"}
+    // Updated to handle multiline JSON with balanced braces
+    const harmonyPattern =
+      /<\|channel\|>commentary\s+to=functions\.([a-zA-Z_][a-zA-Z0-9_]*)\s*<\|constrain\|>json<\|message\|>([\s\S]*?)(?=<\|(?!message\|)|$)/g;
+
+    let match;
+    while ((match = harmonyPattern.exec(content)) !== null) {
+      const [fullMatch, toolName, potentialJson] = match;
+
+      // Extract JSON from the potential content
+      const jsonArgs = this.extractJsonFromContent(potentialJson.trim());
+
+      // Validate that we have both tool name and valid JSON arguments
+      if (toolName && jsonArgs) {
+        toolCalls.push({
+          toolName: toolName.trim(),
+          arguments: jsonArgs,
+          fullMatch,
+        });
+      }
+    }
+
+    return toolCalls;
+  }
+
+  /**
+   * Detects Harmony final patterns in text content
+   * Looks for patterns like: <|channel|>final<|message|>content or <|final|>
+   */
+  private detectHarmonyFinalCalls(
+    content: string
+  ): { toolName: string; arguments: string; fullMatch: string }[] {
+    const toolCalls: {
+      toolName: string;
+      arguments: string;
+      fullMatch: string;
+    }[] = [];
+
+    // Pattern 1: <|channel|>final<|message|>content
+    const finalChannelPattern = /<\|channel\|>final<\|message\|>([\s\S]*?)(?=<\||$)/g;
+    let match;
+    while ((match = finalChannelPattern.exec(content)) !== null) {
+      const [fullMatch, messageContent] = match;
+      toolCalls.push({
+        toolName: "finalAnswer",
+        arguments: JSON.stringify({ answer: messageContent.trim() }),
+        fullMatch,
+      });
+    }
+
+    // Pattern 2: <|final|> (use remaining content as answer)
+    const finalTokenPattern = /<\|final\|>([\s\S]*?)(?=<\||$)/g;
+    while ((match = finalTokenPattern.exec(content)) !== null) {
+      const [fullMatch, messageContent] = match;
+      toolCalls.push({
+        toolName: "finalAnswer",
+        arguments: JSON.stringify({ answer: messageContent.trim() || "Done" }),
+        fullMatch,
+      });
+    }
+
+    return toolCalls;
+  }
+
+  /**
+   * Extracts JSON from content that may contain JSON along with other text
+   */
+  private extractJsonFromContent(content: string): string | null {
+    // Try to find the JSON object boundaries
+    const jsonMatch = content.match(/(\{[\s\S]*\})/);
+    if (jsonMatch) {
+      const jsonCandidate = jsonMatch[1].trim();
+
+      // Validate it's proper JSON
+      try {
+        JSON.parse(jsonCandidate);
+        return jsonCandidate;
+      } catch (error) {
+        // If invalid, return null so it gets skipped
+        return null;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Validates and cleans JSON arguments
+   */
+  private validateAndCleanArguments(jsonString: string): string {
+    try {
+      // Parse and re-stringify to ensure valid JSON
+      const parsed = JSON.parse(jsonString);
+      return JSON.stringify(parsed);
+    } catch (error) {
+      // If JSON is invalid, try to fix common issues
+      try {
+        // Remove trailing commas
+        let cleaned = jsonString.replace(/,(\s*[}\]])/g, "$1");
+
+        // Fix unquoted keys
+        cleaned = cleaned.replace(
+          /([{,]\s*)([a-zA-Z_][a-zA-Z0-9_]*)\s*:/g,
+          '$1"$2":'
+        );
+
+        const parsed = JSON.parse(cleaned);
+        return JSON.stringify(parsed);
+      } catch (secondError) {
+        // If all else fails, wrap in a generic structure
+        return JSON.stringify({ input: jsonString });
+      }
+    }
+  }
+
+  /**
+   * Generates a unique tool call ID
+   */
+  private generateToolCallId(): string {
+    return `harmony_call_${Date.now()}_${Math.random()
+      .toString(36)
+      .substr(2, 9)}`;
+  }
+
+  /**
+   * Converts Harmony tool call matches to proper ToolCall objects
+   */
+  private convertHarmonyToToolCalls(
+    matches: { toolName: string; arguments: string; fullMatch: string }[]
+  ): ToolCall[] {
+    const toolCalls: ToolCall[] = [];
+
+    for (const match of matches) {
+      const { toolName, arguments: jsonArgs } = match;
+
+      if (!toolName) continue;
+
+      const toolCall: ToolCall = {
+        id: this.generateToolCallId(),
+        type: "function",
+        function: {
+          name: toolName,
+          arguments: this.validateAndCleanArguments(jsonArgs),
+        },
+      };
+
+      toolCalls.push(toolCall);
+    }
+
+    return toolCalls;
+  }
+
+  /**
+   * Checks if content contains Harmony format patterns
+   */
+  private isHarmonyFormat(content: string): boolean {
+    // Look for key Harmony format indicators
+    return (
+      (content.includes("<|channel|>") &&
+        content.includes("to=functions.") &&
+        content.includes("<|constrain|>json<|message|>")) ||
+      // Also detect final patterns
+      content.includes("<|channel|>final<|message|>") ||
+      content.includes("<|final|>") ||
+      // Also detect finalAnswer channel pattern
+      content.includes("<|channel|>finalAnswer<|message|>")
+    );
+  }
+
+  /**
+   * Processes a single message to detect and transform Harmony tool calls
+   */
+  private processMessage(message: Message): void {
+    // Only process assistant messages that might contain Harmony tool calls
+    if (message.role !== "assistant") {
+      return;
+    }
+
+    // Only process string content
+    if (typeof message.content !== "string") {
+      return;
+    }
+
+    // Skip if message already has tool calls
+    if (message?.tool_calls?.length) {
+      return;
+    }
+
+    // Skip if this doesn't look like Harmony format
+    if (!this.isHarmonyFormat(message.content)) {
+      return;
+    }
+
+    const matches = this.detectHarmonyToolCalls(message.content);
+
+    // Also check for final patterns
+    const finalMatches = this.detectHarmonyFinalCalls(message.content);
+    
+    // Combine all matches
+    const allMatches = [...matches, ...finalMatches];
+
+    if (allMatches.length === 0) {
+      return;
+    }
+
+    // Convert matches to proper tool calls
+    const toolCalls = this.convertHarmonyToToolCalls(allMatches);
+
+    if (allMatches.length === 0) {
+      return;
+    }
+
+    // Add tool calls to the message (merge with existing if any)
+    if (message.tool_calls) {
+      message.tool_calls.push(...toolCalls);
+    } else {
+      message.tool_calls = toolCalls;
+    }
+  }
+
+  /**
+   * Creates a message processor function for post_call processing
+   */
+  createProcessor(): MessageProcessorFunction {
+    return (originalMessages: Message[], modifiedMessages: Message[]): void => {
+      // Process each message in the modified messages array
+      for (const message of modifiedMessages) {
+        this.processMessage(message);
+      }
+    };
+  }
+}
+
+// Global instance for easy access
+export const globalHarmonyToolProcessor = new HarmonyToolProcessor();