feat: ✨ Implement Claude memory tool

.github/workflows/cli-pr-checks.yml

@@ -33,11 +33,15 @@ jobs:
 
       - name: Setup packages
         uses: ./.github/actions/setup-packages
+        env:
+          GITHUB_TOKEN: ${{ secrets.CI_GITHUB_TOKEN }}
       - name: Setup core component
         uses: ./.github/actions/setup-component
         with:
           component: core
           include-root: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.CI_GITHUB_TOKEN }}
 
       - name: Build core
         run: |
@@ -48,6 +52,8 @@ jobs:
         run: |
           cd extensions/cli
           npm ci --include=optional
+        env:
+          GITHUB_TOKEN: ${{ secrets.CI_GITHUB_TOKEN }}
 
       - name: Run linting
         run: |
@@ -81,11 +87,15 @@ jobs:
 
       - name: Setup packages
         uses: ./.github/actions/setup-packages
+        env:
+          GITHUB_TOKEN: ${{ secrets.CI_GITHUB_TOKEN }}
       - name: Setup core component
         uses: ./.github/actions/setup-component
         with:
           component: core
           include-root: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.CI_GITHUB_TOKEN }}
 
       - name: Build core
         run: |
@@ -96,6 +106,8 @@ jobs:
         run: |
           cd extensions/cli
           npm ci --include=optional
+        env:
+          GITHUB_TOKEN: ${{ secrets.CI_GITHUB_TOKEN }}
 
       - name: Build
         run: |

.vscode/launch.json

@@ -149,10 +149,15 @@
       "internalConsoleOptions": "neverOpen",
       "skipFiles": ["<node_internals>/**"],
       "sourceMaps": true,
-      "outFiles": ["${workspaceFolder}/extensions/cli/dist/**/*.js"],
+      "outFiles": [
+        "${workspaceFolder}/extensions/cli/dist/**/*.js",
+        "${workspaceFolder}/core/out/**/*.js",
+        "${workspaceFolder}/packages/*/out/**/*.js"
+      ],
       "sourceMapPathOverrides": {
         "../src/*": "${workspaceFolder}/extensions/cli/src/*",
-        "../../core/*": "${workspaceFolder}/core/*"
+        "../../core/*": "${workspaceFolder}/core/*",
+        "../../packages/*/src/*": "${workspaceFolder}/packages/*/src/*"
       },
       "resolveSourceMapLocations": [
         "${workspaceFolder}/**",
@@ -179,10 +184,15 @@
       "internalConsoleOptions": "neverOpen",
       "skipFiles": ["<node_internals>/**"],
       "sourceMaps": true,
-      "outFiles": ["${workspaceFolder}/extensions/cli/dist/**/*.js"],
+      "outFiles": [
+        "${workspaceFolder}/extensions/cli/dist/**/*.js",
+        "${workspaceFolder}/core/out/**/*.js",
+        "${workspaceFolder}/packages/*/out/**/*.js"
+      ],
       "sourceMapPathOverrides": {
         "../src/*": "${workspaceFolder}/extensions/cli/src/*",
-        "../../core/*": "${workspaceFolder}/core/*"
+        "../../core/*": "${workspaceFolder}/core/*",
+        "../../packages/*/src/*": "${workspaceFolder}/packages/*/src/*"
       },
       "resolveSourceMapLocations": [
         "${workspaceFolder}/**",

core/index.d.ts

@@ -1095,6 +1095,7 @@ export interface Tool {
   type: "function";
   function: {
     name: string;
+    type?: string;
     description?: string;
     parameters?: Record<string, any>;
     strict?: boolean | null;

core/llm/llms/Bedrock.ts

@@ -39,6 +39,27 @@ interface PromptCachingMetrics {
   cacheWriteInputTokens: number;
 }
 
+/**
+ * Checks if a model supports the memory tool (Claude 4+ models only)
+ */
+function supportsMemoryTool(modelName: string | undefined): boolean {
+  if (!modelName) {
+    return false;
+  }
+
+  const normalized = modelName.toLowerCase();
+
+  const supportedModels = [
+    "claude-sonnet-4-5-20250929", // Claude Sonnet 4.5
+    "claude-sonnet-4-20250514", // Claude Sonnet 4
+    "claude-haiku-4-5-20251001", // Claude Haiku 4.5
+    "claude-opus-4-1-20250805", // Claude Opus 4.1
+    "claude-opus-4-20250514", // Claude Opus 4
+  ];
+
+  return supportedModels.some((model) => normalized.includes(model));
+}
+
 class Bedrock extends BaseLLM {
   static providerName = "bedrock";
   static defaultOptions: Partial<LLMOptions> = {
@@ -281,21 +302,31 @@ class Bedrock extends BaseLLM {
     let toolConfig: undefined | ToolConfiguration = undefined;
     const availableTools = new Set<string>();
     if (supportsTools && options.tools && options.tools.length > 0) {
-      toolConfig = {
-        tools: options.tools.map((tool) => ({
+      const isClaudeModel = options.model.includes("claude");
+
+      // For Claude models, filter out tools with a type property
+      // For other models, include all tools
+      const toolSpecs = options.tools
+        .filter((tool) => !isClaudeModel || !tool.function.type)
+        .map((tool) => ({
           toolSpec: {
             name: tool.function.name,
             description: tool.function.description,
             inputSchema: {
               json: tool.function.parameters,
             },
           },
-        })),
-      } as ToolConfiguration;
-      const shouldCacheToolsConfig = this.completionOptions.promptCaching;
-      if (shouldCacheToolsConfig) {
-        toolConfig.tools!.push({ cachePoint: { type: "default" } });
+        }));
+
+      if (toolSpecs.length > 0) {
+        toolConfig = { tools: toolSpecs } as ToolConfiguration;
+        const shouldCacheToolsConfig = this.completionOptions.promptCaching;
+        if (shouldCacheToolsConfig) {
+          toolConfig.tools!.push({ cachePoint: { type: "default" } });
+        }
       }
+
+      // Add all tool names to availableTools set
       options.tools.forEach((tool) => {
         availableTools.add(tool.function.name);
       });
@@ -329,14 +360,40 @@ class Bedrock extends BaseLLM {
           .slice(0, 4),
       },
       additionalModelRequestFields: {
+        tools:
+          options.model.includes("claude") && options.tools
+            ? options.tools
+                .filter((tool) => {
+                  if (!tool.function.type) {
+                    return false;
+                  }
+                  // Check if this is a memory tool - only allow for Claude 4+ models
+                  if (tool.function.type.startsWith("memory_")) {
+                    if (!supportsMemoryTool(options.model)) {
+                      console.warn(
+                        `Bedrock: Memory tool "${tool.function.name}" (${tool.function.type}) is only supported on Claude 4+ models, skipping for model: ${options.model}`,
+                      );
+                      return false;
+                    }
+                  }
+                  return true;
+                })
+                .map((tool) => ({
+                  name: tool.function.name,
+                  type: tool.function.type,
+                }))
+            : undefined,
         thinking: options.reasoning
           ? {
               type: "enabled",
               budget_tokens: options.reasoningBudgetTokens,
             }
           : undefined,
         anthropic_beta: options.model.includes("claude")
-          ? ["fine-grained-tool-streaming-2025-05-14"]
+          ? [
+              "fine-grained-tool-streaming-2025-05-14",
+              "context-management-2025-06-27",
+            ]
           : undefined,
       },
     };

core/tools/builtIn.ts

@@ -16,6 +16,7 @@ export enum BuiltInToolNames {
   RequestRule = "request_rule",
   FetchUrlContent = "fetch_url_content",
   CodebaseTool = "codebase",
+  Memory = "memory",
 
   // excluded from allTools for now
   ViewRepoMap = "view_repo_map",

core/tools/callTool.ts

@@ -22,6 +22,7 @@ import { searchWebImpl } from "./implementations/searchWeb";
 import { viewDiffImpl } from "./implementations/viewDiff";
 import { viewRepoMapImpl } from "./implementations/viewRepoMap";
 import { viewSubdirectoryImpl } from "./implementations/viewSubdirectory";
+import { memoryToolImpl } from "./implementations/memory";
 import { safeParseToolCallArgs } from "./parseArgs";
 
 async function callHttpTool(
@@ -167,6 +168,8 @@ export async function callBuiltInTool(
       return await searchWebImpl(args, extras);
     case BuiltInToolNames.FetchUrlContent:
       return await fetchUrlContentImpl(args, extras);
+    case BuiltInToolNames.Memory:
+      return await memoryToolImpl(args, extras);
     case BuiltInToolNames.ViewDiff:
       return await viewDiffImpl(args, extras);
     case BuiltInToolNames.LSTool:

core/tools/definitions/index.ts

@@ -7,6 +7,7 @@ export { globSearchTool } from "./globSearch";
 export { grepSearchTool } from "./grepSearch";
 export { lsTool } from "./ls";
 export { multiEditTool } from "./multiEdit";
+export { memoryTool } from "./memory";
 export { readCurrentlyOpenFileTool } from "./readCurrentlyOpenFile";
 export { readFileTool } from "./readFile";
 

core/tools/definitions/memory.ts

@@ -0,0 +1,92 @@
+import { Tool } from "../..";
+import { BUILT_IN_GROUP_NAME, BuiltInToolNames } from "../builtIn";
+
+const COMMAND_OPTIONS = [
+  "view",
+  "create",
+  "insert",
+  "str_replace",
+  "delete",
+  "rename",
+];
+
+export const memoryTool: Tool = {
+  type: "function",
+  displayTitle: "Memory",
+  wouldLikeTo:
+    "manage persistent memories using the {{{ command }}} command at {{{ path }}}",
+  isCurrently:
+    "managing persistent memories using the {{{ command }}} command at {{{ path }}}",
+  hasAlready:
+    "managed persistent memories using the {{{ command }}} command at {{{ path }}}",
+  readonly: false,
+  group: BUILT_IN_GROUP_NAME,
+  function: {
+    name: BuiltInToolNames.Memory,
+    type: "memory_20250818",
+    description: "Anthropic claude memory tool",
+    parameters: {
+      type: "object",
+      required: ["command"],
+      properties: {
+        command: {
+          type: "string",
+          enum: COMMAND_OPTIONS,
+          description:
+            "The memory operation to perform: view, create, insert, str_replace, delete, or rename.",
+        },
+        path: {
+          type: "string",
+          description:
+            "Path within the /memories namespace targeted by the command. Must begin with /memories.",
+        },
+        view_range: {
+          type: "array",
+          description:
+            "Optional [start, end] line range (1-indexed, inclusive) when viewing a memory file. Use -1 for end to read to EOF.",
+          items: { type: "number" },
+        },
+        file_text: {
+          type: "string",
+          description: "Content to write when creating a new memory file.",
+        },
+        insert_line: {
+          type: "number",
+          description:
+            "0-based line number where insert_text should be added when using the insert command.",
+        },
+        insert_text: {
+          type: "string",
+          description: "Text to insert when using the insert command.",
+        },
+        old_str: {
+          type: "string",
+          description:
+            "Existing text to replace when using the str_replace command. Must appear exactly once.",
+        },
+        new_str: {
+          type: "string",
+          description:
+            "Replacement text to use when the str_replace command is invoked.",
+        },
+        old_path: {
+          type: "string",
+          description: "Existing path to rename when using the rename command.",
+        },
+        new_path: {
+          type: "string",
+          description: "New path to rename to when using the rename command.",
+        },
+      },
+    },
+  },
+  systemMessageDescription: {
+    prefix: `To manage long-term memories stored under /memories, use the ${BuiltInToolNames.Memory} tool. Always provide a command (view, create, insert, str_replace, delete, or rename) and paths that begin with /memories. For example, to view the index file you could respond with:`,
+    exampleArgs: [
+      ["command", "view"],
+      ["path", "/memories/index.md"],
+    ],
+  },
+  defaultToolPolicy: "allowedWithoutPermission",
+  toolCallIcon: "ArchiveBoxIcon",
+};