onbuzz 3.9.8 → 4.0.0

package/src/tools/openaiFunctionSchemas.js

@@ -0,0 +1,270 @@
+/**
+ * OpenAI-compatible function schemas for the CLI's tool catalog.
+ *
+ * Purpose:
+ * Reasoning models on the Responses API (codex, o-series, gpt-5-pro) are
+ * RLHFed against the CLI's inline JSON-block protocol and need native
+ * function declarations to emit tool calls. The CLI owns these schemas
+ * (tools + their rendering are a CLI concern, never a backend concern) and
+ * passes them through the chat payload's `options.tools` field. The Azure
+ * backend forwards them verbatim to the Responses API and converts incoming
+ * function_call SSE events back into the CLI's inline JSON-block format.
+ *
+ * Shape convention:
+ * Each schema mirrors the `parsedData` shape expected by (a) the tool's
+ * `execute()` / `parseParameters()` in src/tools/*.js, and (b) the matching
+ * renderer in web-ui/src/components/toolRenderers/*.jsx. Keeping all three
+ * in sync here means specific renderers (TaskManagerRenderer, TerminalRenderer,
+ * etc.) render their native visualizations without the backend needing to
+ * know anything about UI.
+ *
+ * When you add a new tool to the CLI, add its schema here. The backend
+ * remains tool-agnostic.
+ */
+
+export const OPENAI_FUNCTION_SCHEMAS = [
+  // TaskManager — actions-array with flat task fields per action.
+  // Field names mirror the tool's system-prompt protocol (src/tools/taskManagerTool.js
+  // doc block) and the tool's runtime read-sites, so Responses-API models and
+  // chat-completion models produce identical payloads.
+  //   create:            {type, title, description?, priority?}
+  //   update:            {type, taskId, title?, description?, priority?, status?}
+  //   complete|cancel:   {type, taskId}
+  //   list|clear:        {type}
+  // One call = one task action. Parallel tool calls cover multi-task cases.
+  {
+    type: 'function',
+    name: 'taskmanager',
+    description: 'Create, update, complete, cancel, list, or clear tasks. One call per action. For create: provide title. For update/complete/cancel: provide taskId.',
+    parameters: {
+      type: 'object',
+      properties: {
+        actions: {
+          type: 'array',
+          description: 'Array with a single action object.',
+          items: {
+            type: 'object',
+            properties: {
+              type:        { type: 'string', enum: ['create', 'update', 'complete', 'cancel', 'list', 'clear'] },
+              taskId:      { type: 'string', description: 'Task id — required for update/complete/cancel. Omit for create/list/clear.' },
+              title:       { type: 'string', description: 'Task title — required for create; optional for update.' },
+              description: { type: 'string' },
+              priority:    { type: 'string', enum: ['high', 'medium', 'low'], description: 'Only set for create/update. Omit for list — do NOT use as a filter.' },
+              status:      { type: 'string', enum: ['pending', 'in_progress', 'completed'], description: 'Only set for update. Omit for create (defaults to pending) and for list (returns all tasks).' },
+            },
+            required: ['type'],
+          },
+          minItems: 1,
+          maxItems: 1,
+        },
+      },
+      required: ['actions'],
+    },
+  },
+  // JobDone — actions-array with action+summary.
+  {
+    type: 'function',
+    name: 'jobdone',
+    description: 'Signal that all tasks are complete and the agent should stop.',
+    parameters: {
+      type: 'object',
+      properties: {
+        actions: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              action:  { type: 'string', enum: ['complete'] },
+              summary: { type: 'string', description: 'Brief summary of what was accomplished' },
+            },
+            required: ['action', 'summary'],
+          },
+        },
+      },
+      required: ['actions'],
+    },
+  },
+  // Filesystem — actions-array with per-action-typed field names (filePath /
+  // outputPath / sourcePath + destPath / directory). Aligned with the tool's
+  // system-prompt protocol (src/tools/fileSystemTool.js doc block) and the
+  // tool's validate/execute read-sites.
+  //   read|delete|exists|stats:   {type, filePath}
+  //   write:                      {type, outputPath, content}
+  //   append:                     {type, filePath, content}
+  //   copy|move:                  {type, sourcePath, destPath}
+  //   create-dir:                 {type, directory}
+  //   list:                       {type, directory}
+  {
+    type: 'function',
+    name: 'filesystem',
+    description: 'Read, write, create, delete, copy/move, append, or list files and directories. Emit one action object per file operation (multiple allowed in the actions array).',
+    parameters: {
+      type: 'object',
+      properties: {
+        actions: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              type:        { type: 'string', enum: ['read', 'write', 'append', 'delete', 'copy', 'move', 'exists', 'stats', 'create-dir', 'list'], description: 'The filesystem operation to perform.' },
+              filePath:    { type: 'string', description: 'Target file path. Required for: read, append, delete, exists, stats.' },
+              outputPath:  { type: 'string', description: 'Destination file path. Required for: write.' },
+              sourcePath:  { type: 'string', description: 'Source file path. Required for: copy, move.' },
+              destPath:    { type: 'string', description: 'Destination file path. Required for: copy, move.' },
+              directory:   { type: 'string', description: 'Directory path. Required for: create-dir, list.' },
+              content:     { type: 'string', description: 'File content. Required for: write, append.' },
+            },
+            required: ['type'],
+          },
+        },
+      },
+      required: ['actions'],
+    },
+  },
+  // Terminal — actions-array. Tool supports run-command, change-directory,
+  // list-directory, create-directory, get-working-directory (see
+  // src/tools/terminalTool.js switch on action.type).
+  {
+    type: 'function',
+    name: 'terminal',
+    description: 'Run shell commands, change/list/create working directories, or report the current working directory.',
+    parameters: {
+      type: 'object',
+      properties: {
+        actions: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              type:      { type: 'string', enum: ['run-command', 'change-directory', 'list-directory', 'create-directory', 'get-working-directory'], description: 'The terminal operation to perform.' },
+              command:   { type: 'string', description: 'Shell command to run. Required for: run-command.' },
+              directory: { type: 'string', description: 'Directory path. Required for: change-directory, list-directory, create-directory.' },
+              timeout:   { type: 'number', description: 'Timeout in ms for run-command. Default 30000.' },
+            },
+            required: ['type'],
+          },
+        },
+      },
+      required: ['actions'],
+    },
+  },
+  // Seek — uses filePaths + searchTerms (matches tool's and renderer's flat shape).
+  {
+    type: 'function',
+    name: 'seek',
+    description: 'Search for text/patterns across project files (grep-like).',
+    parameters: {
+      type: 'object',
+      properties: {
+        searchTerms: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Patterns to search for (regex supported)',
+        },
+        filePaths: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Directories or files to search in (defaults to project root)',
+        },
+      },
+      required: ['searchTerms'],
+    },
+  },
+  // File-content-replace — files array with nested replacements.
+  // Field names mirror src/tools/fileContentReplaceTool.js runtime (file.path,
+  // replacement.oldContent/newContent) so the same payload shape works for
+  // both native function calls and the system-prompt inline protocol.
+  {
+    type: 'function',
+    name: 'file-content-replace',
+    description: 'Find and replace exact text spans within one or more files.',
+    parameters: {
+      type: 'object',
+      properties: {
+        files: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              path: { type: 'string', description: 'File path relative to the project root.' },
+              replacements: {
+                type: 'array',
+                items: {
+                  type: 'object',
+                  properties: {
+                    oldContent: { type: 'string', description: 'Exact text to find (whitespace-sensitive).' },
+                    newContent: { type: 'string', description: 'Replacement text.' },
+                    all:        { type: 'boolean', description: 'Replace every occurrence. Default false (replace first only).' },
+                  },
+                  required: ['oldContent', 'newContent'],
+                },
+              },
+            },
+            required: ['path', 'replacements'],
+          },
+        },
+      },
+      required: ['files'],
+    },
+  },
+  // File-tree — flat params using `directory` + `maxDepth`.
+  {
+    type: 'function',
+    name: 'file-tree',
+    description: 'Get a tree-view of the project directory structure.',
+    parameters: {
+      type: 'object',
+      properties: {
+        directory:  { type: 'string', description: 'Root directory (defaults to project root)' },
+        maxDepth:   { type: 'number', description: 'Max depth (default 3)' },
+        showHidden: { type: 'boolean' },
+      },
+    },
+  },
+  // Memory — flat params (no actions array). Field names mirror the tool's
+  // validate/execute sites in src/tools/memoryTool.js (params.action/id/title/
+  // content/description/query/level).
+  //   add:             {action, title, content, description?}
+  //   update:          {action, id, title?, content?, description?}
+  //   delete|read:     {action, id}
+  //   list:            {action, level?}
+  //   search:          {action, query, level?}
+  {
+    type: 'function',
+    name: 'memory',
+    description: 'Store and retrieve persistent memories across sessions.',
+    parameters: {
+      type: 'object',
+      properties: {
+        action:      { type: 'string', enum: ['add', 'update', 'delete', 'read', 'list', 'search'] },
+        id:          { type: 'string', description: 'Memory id. Required for: update, delete, read.' },
+        title:       { type: 'string', description: 'Short title. Required for: add. Optional for: update.' },
+        content:     { type: 'string', description: 'Full memory content. Required for: add. Optional for: update.' },
+        description: { type: 'string', description: 'Short summary. Optional for: add, update.' },
+        query:       { type: 'string', description: 'Search query. Required for: search.' },
+        level:       { type: 'string', enum: ['titles', 'descriptions', 'full'], description: 'Detail level for list/search output.' },
+      },
+      required: ['action'],
+    },
+  },
+];
+
+/**
+ * Build the tools array for a specific agent based on its enabled capabilities.
+ * Keeps the model's tool list minimal — it sees only what the agent actually
+ * has access to, which also reduces prompt size and ambiguity.
+ *
+ * @param {string[]} capabilities - Agent capabilities (matches tool ids)
+ * @returns {Array} Function schemas the agent is allowed to invoke
+ */
+export function getToolSchemasForAgent(capabilities = []) {
+  if (!Array.isArray(capabilities) || capabilities.length === 0) {
+    // Agent has no capability list — give it the full catalog rather than
+    // leaving it tool-less. Matches the CLI's existing "include all" fallback.
+    return OPENAI_FUNCTION_SCHEMAS;
+  }
+  const allowed = new Set(capabilities.map(c => String(c).toLowerCase()));
+  return OPENAI_FUNCTION_SCHEMAS.filter(s => allowed.has(s.name.toLowerCase()));
+}
+
+export default OPENAI_FUNCTION_SCHEMAS;

package/src/tools/taskManagerTool.js

@@ -410,6 +410,33 @@ Always use a detailed task description to provide context for the task, and leve
         }
       }
 
+      // Alias `id` → `taskId`. The OpenAI function schema for taskmanager
+      // uses `id` (shorter, matches the schema's per-action field) but the
+      // internal action methods (updateTask, completeTask, cancelTask,
+      // createDependency) all read `params.taskId`. Without this alias,
+      // update/complete/cancel silently fail with "Task ID is required".
+      // Kept non-destructive: only sets taskId when absent, so legacy callers
+      // that pass taskId directly continue to work unchanged.
+      if (params.id && !params.taskId) {
+        params.taskId = params.id;
+      }
+
+      // `priority` and `status` are shared per-action properties in the
+      // OpenAI function schema so the model can set them on create/update.
+      // Reasoning models routinely fill them with default-looking enum values
+      // ("low", "pending") for OTHER actions too — meaningless for list, and
+      // catastrophic there because listTasks would filter the task list down
+      // to rows matching those defaults (often zero).
+      //
+      // Scope the strip to model entries ONLY (requests that arrived via the
+      // `actions` array). Direct callers that use `execute({action:'list',
+      // status:'pending'})` still get their filter honored — that API path
+      // reflects deliberate intent, not schema-default leakage.
+      if (params.actions && params.action?.toLowerCase() === 'list') {
+        delete params.priority;
+        delete params.status;
+      }
+
       const { agentId, agentName } = context;
 
       if (!agentId) {
@@ -749,8 +776,14 @@ Always use a detailed task description to provide context for the task, and leve
       task.priority = priority.toLowerCase();
     }
 
-    if (title !== undefined) task.title = title;
-    if (description !== undefined) task.description = description;
+    // Reasoning models on the Responses API routinely fill every string
+    // property declared in the schema — even on update actions that only
+    // intend to change status/priority — with an empty string. A naive
+    // `if (title !== undefined)` assignment wipes the real title with "".
+    // Treat empty / whitespace-only strings as "not provided" so updates
+    // only mutate fields the model actually set to a meaningful value.
+    if (typeof title === 'string' && title.trim().length > 0) task.title = title;
+    if (typeof description === 'string' && description.trim().length > 0) task.description = description;
     
     task.updatedAt = new Date().toISOString();
 

package/src/tools/terminalTool.js

@@ -962,13 +962,34 @@ After each invocation you will get a tool-result embedded in the following user
   async changeDirectory(targetDir, currentDir, accessConfig) {
     try {
       let newDirectory;
-      
+
       if (path.isAbsolute(targetDir)) {
         newDirectory = targetDir;
       } else {
         newDirectory = path.resolve(currentDir, targetDir);
       }
-      
+
+      // Guard against doubled directory nesting. Reasoning models frequently
+      // forget that `change-directory` persists the CWD for the session, so
+      // after cd-ing into `foo` they issue another `change-directory foo`,
+      // which resolves to `.../foo/foo` and either (a) fails here, or (b)
+      // succeeds because some earlier typo created that nested directory,
+      // silently entrenching the confusion. Detect the duplicate-segment
+      // pattern and refuse with a clear, actionable error that tells the
+      // agent it's already inside the target and should drop this action.
+      const segs = newDirectory.split(/[\\/]/).filter(Boolean);
+      for (let i = 1; i < segs.length; i++) {
+        if (segs[i].toLowerCase() === segs[i - 1].toLowerCase()) {
+          throw new Error(
+            `Refused to enter duplicated path segment "${segs[i]}". ` +
+            `Resolved path would be ${newDirectory}. ` +
+            `You are already inside "${segs[i]}" (current directory: ${currentDir}). ` +
+            `Do NOT prepend the project folder name again — relative paths are resolved from the current directory. ` +
+            `Use \`get-working-directory\` if you need to confirm where you are.`
+          );
+        }
+      }
+
       // Verify directory exists
       const stats = await fs.stat(newDirectory);
       if (!stats.isDirectory()) {