@tyvm/knowhow 0.0.159 → 0.0.160

package/src/services/MessageProcessor.ts

@@ -1,114 +0,0 @@
-import { Message } from "../clients/types";
-import { TraceAll } from "../util/Trace";
-
-export type ProcessorLifecycle =
-  | "initial_call"
-  | "pre_call"
-  | "post_call"
-  | "pre_tools"
-  | "post_tools";
-
-export type MessageProcessorFunction = (
-  originalMessages: Message[],
-  modifiedMessages: Message[]
-) => Promise<void> | void;
-
-export interface ProcessorRegistration {
-  processor: MessageProcessorFunction;
-  priority: number;
-}
-
-@TraceAll()
-export class MessageProcessor {
-  private processors: Map<ProcessorLifecycle, ProcessorRegistration[]> =
-    new Map();
-
-  constructor() {
-    // Initialize lifecycle maps
-    this.clearProcessors();
-  }
-
-  setProcessors(
-    lifecycle: ProcessorLifecycle,
-    processors: MessageProcessorFunction[]
-  ): void {
-    const registrations: ProcessorRegistration[] = processors.map((proc) => ({
-      processor: proc,
-      priority: 0, // Default priority
-    }));
-
-    // Sort by priority (higher priority first)
-    registrations.sort((a, b) => b.priority - a.priority);
-
-    this.processors.set(lifecycle, registrations);
-  }
-
-  registerProcessor(
-    lifecycle: ProcessorLifecycle,
-    processor: MessageProcessorFunction,
-    priority: number = 0
-  ): void {
-    const registrations = this.processors.get(lifecycle) || [];
-    registrations.push({ processor, priority });
-
-    // Sort by priority (higher priority first)
-    registrations.sort((a, b) => b.priority - a.priority);
-
-    this.processors.set(lifecycle, registrations);
-  }
-
-  removeProcessor(
-    lifecycle: ProcessorLifecycle,
-    processor: MessageProcessorFunction
-  ): void {
-    const registrations = this.processors.get(lifecycle) || [];
-    const filtered = registrations.filter((reg) => reg.processor !== processor);
-    this.processors.set(lifecycle, filtered);
-  }
-
-  async processMessages(
-    messages: Message[],
-    lifecycle: ProcessorLifecycle
-  ): Promise<Message[]> {
-    const registrations = this.processors.get(lifecycle) || [];
-
-    if (registrations.length === 0) {
-      return messages;
-    }
-
-    // Create a deep copy of the messages to avoid modifying the original
-    const modifiedMessages = JSON.parse(JSON.stringify(messages));
-
-    // Execute processors in priority order
-    for (const registration of registrations) {
-      try {
-        await registration.processor(messages, modifiedMessages);
-      } catch (error) {
-        console.error(`Message processor error in ${lifecycle}:`, error);
-        // Continue with other processors even if one fails
-      }
-    }
-
-    return modifiedMessages;
-  }
-
-  getProcessorsForLifecycle(
-    lifecycle: ProcessorLifecycle
-  ): MessageProcessorFunction[] {
-    const registrations = this.processors.get(lifecycle) || [];
-    return registrations.map((reg) => reg.processor);
-  }
-
-  clearProcessors(lifecycle?: ProcessorLifecycle): void {
-    if (lifecycle) {
-      this.processors.set(lifecycle, []);
-    } else {
-      this.processors.clear();
-      this.processors.set("initial_call", []);
-      this.processors.set("pre_call", []);
-      this.processors.set("post_call", []);
-      this.processors.set("pre_tools", []);
-      this.processors.set("post_tools", []);
-    }
-  }
-}

package/src/services/MinimalToolsService.ts

@@ -1,177 +0,0 @@
-import { ToolsService, ToolContext, ToolCallContext } 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";
-import { TraceAll } from "../util/Trace";
-
-/*
- * 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().
- */
-@TraceAll()
-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,
-    callContext?: ToolCallContext
-  ) {
-    // 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], callContext);
-
-    // 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[],
-    callContext?: ToolCallContext
-  ): 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(), callContext);
-    }
-
-    // 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, callContext);
-    }
-
-    // Not found anywhere - let the base class produce the standard error.
-    return super.callTool(toolCall, [functionName], callContext);
-  }
-}

package/src/services/RuntimeReloadService.ts

@@ -1,31 +0,0 @@
-export interface RuntimeReloadResult {
-  tools: number;
-  mcps: number;
-  modules: number;
-}
-
-/** Coordinates in-place runtime refreshes and coalesces concurrent requests. */
-export class RuntimeReloadService {
-  private handler?: () => Promise<RuntimeReloadResult>;
-  private pending?: Promise<RuntimeReloadResult>;
-
-  configure(handler: () => Promise<RuntimeReloadResult>): void {
-    this.handler = handler;
-  }
-
-  isConfigured(): boolean {
-    return !!this.handler;
-  }
-
-  reload(): Promise<RuntimeReloadResult> {
-    if (!this.handler) {
-      return Promise.reject(new Error("Runtime reload is unavailable for this command"));
-    }
-    if (!this.pending) {
-      this.pending = this.handler().finally(() => {
-        this.pending = undefined;
-      });
-    }
-    return this.pending;
-  }
-}

package/src/services/S3.ts

@@ -1,61 +0,0 @@
-import * as fs from "fs";
-import { createWriteStream, createReadStream } from "fs";
-import { pipeline, Readable } from "stream";
-import * as util from "util";
-
-const pipelineAsync = util.promisify(pipeline);
-
-export class S3Service {
-  async uploadToPresignedUrl(
-    presignedUrl: string,
-    filePath: string
-  ): Promise<void> {
-    try {
-      const fileContent = fs.readFileSync(filePath);
-      const fileStats = await fs.promises.stat(filePath);
-
-      const response = await fetch(presignedUrl, {
-        method: "PUT",
-        headers: {
-          "Content-Length": String(fileStats.size),
-        },
-        body: fileContent,
-        // @ts-ignore
-        duplex: "half",
-      });
-
-      if (!response.ok) {
-        const text = await response.text();
-        throw new Error(`Upload failed with status code: ${response.status} - ${text}`);
-      }
-
-      console.log("File uploaded successfully to pre-signed URL");
-    } catch (error) {
-      console.error("Error uploading file to pre-signed URL:", error);
-      throw error;
-    }
-  }
-
-  async downloadFromPresignedUrl(
-    presignedUrl: string,
-    destinationPath: string
-  ): Promise<void> {
-    try {
-      const response = await fetch(presignedUrl);
-
-      if (!response.ok) {
-        throw new Error(`Download failed with status code: ${response.status}`);
-      }
-
-      const fileStream = createWriteStream(destinationPath);
-      await pipelineAsync(Readable.from(response.body as any), fileStream);
-
-      console.log(
-        `File downloaded successfully from pre-signed URL to ${destinationPath}`
-      );
-    } catch (error) {
-      console.error("Error downloading file from pre-signed URL:", error);
-      throw error;
-    }
-  }
-}