Add anthropic container provider

Author: pokey

examples/src/createAgent/middleware/codeExecutionAnthropic.ts

@@ -0,0 +1,78 @@
+/**
+ * Example demonstrating the Code Execution Middleware with Anthropic.
+ *
+ * This middleware enables Claude to execute code in a sandboxed container,
+ * analyze uploaded files, and generate output files. The example demonstrates
+ * multi-turn conversation with container and file state persistence.
+ */
+
+import { ChatAnthropic } from "@langchain/anthropic";
+import { AnthropicContainerProvider } from "@langchain/anthropic/middleware";
+import { HumanMessage } from "@langchain/core/messages";
+import { MemorySaver } from "@langchain/langgraph";
+import {
+  codeExecutionMiddleware,
+  createAgent,
+  MemoryFileProvider,
+} from "langchain";
+import fs from "node:fs/promises";
+import { join } from "node:path";
+
+// Initial setup
+const model = new ChatAnthropic({
+  model: "claude-sonnet-4-20250514",
+});
+
+const middleware = codeExecutionMiddleware(
+  new AnthropicContainerProvider(),
+  new MemoryFileProvider()
+);
+
+const agent = createAgent({
+  model,
+  middleware: [middleware],
+  checkpointer: new MemorySaver(),
+});
+
+const thread = {
+  configurable: {
+    thread_id: "test-123",
+  },
+};
+
+// Read and add the test data file
+const testDataPath = "test_data.csv";
+const fileContent = await fs.readFile(testDataPath);
+
+// First invocation - should create container and analyze uploaded data
+const response1 = await agent.invoke(
+  {
+    messages: new HumanMessage("Filter to just widget A"),
+    files: [await middleware.addFile(testDataPath, fileContent)],
+  },
+  thread
+);
+console.log("Response 1:", response1.messages);
+
+// Second invocation - should reuse container and previous analysis
+const response2 = await agent.invoke(
+  {
+    messages: new HumanMessage(
+      "Turn that into a graph of sales and units over time."
+    ),
+  },
+  thread
+);
+console.log("Response 2:", response2.messages);
+
+// Extract and download generated files
+const generatedFiles = middleware
+  .files(response2)
+  .filter(({ type, path }) => type === "tool" && path.endsWith(".png"));
+
+for (const file of generatedFiles) {
+  const content = await file.getContent();
+  const outputPath = join(".", file.path);
+  await fs.writeFile(outputPath, content);
+  console.log(`Downloaded generated file: ${outputPath}`);
+}

libs/providers/langchain-anthropic/package.json

@@ -33,18 +33,26 @@
     "@anthropic-ai/sdk": "^0.65.0"
   },
   "peerDependencies": {
-    "@langchain/core": "^1.0.0-alpha.6"
+    "@langchain/core": "^1.0.0-alpha.6",
+    "langchain": "workspace:*"
+  },
+  "peerDependenciesMeta": {
+    "langchain": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@anthropic-ai/vertex-sdk": "^0.11.5",
     "@langchain/core": "workspace:*",
     "@langchain/eslint": "workspace:*",
+    "@langchain/langgraph-checkpoint": "^0.1.1",
     "@langchain/standard-tests": "workspace:*",
     "@tsconfig/recommended": "^1.0.10",
     "@vitest/coverage-v8": "^3.2.4",
     "dotenv": "^17.2.1",
     "dpdm": "^3.14.0",
     "eslint": "^9.34.0",
+    "langchain": "workspace:*",
     "prettier": "^2.8.3",
     "rimraf": "^5.0.1",
     "typescript": "~5.8.3",
@@ -82,9 +90,20 @@
       },
       "input": "./src/index.ts"
     },
+    "./middleware": {
+      "import": {
+        "types": "./dist/middleware/index.d.ts",
+        "default": "./dist/middleware/index.js"
+      },
+      "require": {
+        "types": "./dist/middleware/index.d.cts",
+        "default": "./dist/middleware/index.cjs"
+      },
+      "input": "./src/middleware/index.ts"
+    },
     "./package.json": "./package.json"
   },
   "files": [
     "dist/"
   ]
-}
+}

libs/providers/langchain-anthropic/src/middleware/containerProvider.ts

@@ -0,0 +1,118 @@
+import Anthropic, { toFile } from "@anthropic-ai/sdk";
+import { HumanMessage } from "@langchain/core/messages";
+import {
+  ContainerInfo,
+  ContainerProvider,
+  FileFromProvider,
+  ModelRequest,
+  UploadFileToContainerOpts,
+  UploadFileToContainerRet,
+} from "langchain";
+import { extractGeneratedFiles } from "../utils/extractGeneratedFiles.js";
+
+export class AnthropicContainerProvider implements ContainerProvider {
+  tools = [{ type: "code_execution_20250825", name: "code_execution" }];
+
+  async startContainer(): Promise<ContainerInfo> {
+    // Anthropic automatically creates a container when you first use the code
+    // execution tool, so we don't need to do anything here.
+    return {};
+  }
+
+  async uploadFileToContainer({
+    path,
+    providerId,
+    getContent,
+  }: UploadFileToContainerOpts): Promise<UploadFileToContainerRet> {
+    // This function doesn't actually upload the file to the container. Instead,
+    // we upload the file to Anthropic using the files API. We will pass the
+    // Anthropic-provided file ID to the container using a special message in
+    // modifyModelRequest.
+    if (providerId != null) {
+      // File already uploaded
+      return { providerId, isPendingModelResponse: true };
+    }
+
+    const response = await new Anthropic().beta.files.upload({
+      file: await toFile(await getContent(), path),
+      betas: ["files-api-2025-04-14"],
+    });
+
+    // We use isPendingModelResponse to indicate that the file won't be in the
+    // container until after the model responds.
+    return { providerId: response.id, isPendingModelResponse: true };
+  }
+
+  async modifyModelRequest<TState extends Record<string, unknown>, TContext>(
+    containerId: string | undefined,
+    newFiles: string[],
+    request: ModelRequest<TState, TContext>
+  ): Promise<ModelRequest<TState, TContext> | void> {
+    return {
+      ...request,
+      messages: [
+        ...newFiles.map(
+          (fileId) =>
+            new HumanMessage({
+              content: [{ type: "container_upload", file_id: fileId }],
+            })
+        ),
+        ...request.messages,
+      ],
+      modelSettings: {
+        // Pass container ID to reuse files across turns
+        container: containerId,
+
+        // Automatically inject required beta headers for Anthropic code execution
+        headers: {
+          "anthropic-beta": "code-execution-2025-08-25,files-api-2025-04-14",
+        },
+      },
+    };
+  }
+
+  extractFilesFromModelResponse(
+    messages: ModelRequest["messages"]
+  ): Promise<FileFromProvider[]> {
+    // TODO: Is it correct to just look at the last message?
+    return Promise.all(
+      extractGeneratedFiles(
+        messages[
+          messages.length - 1
+        ] as unknown as Anthropic.Beta.Messages.BetaMessage
+      ).map(async (fileId) => {
+        const content = Buffer.from(
+          await (await new Anthropic().beta.files.download(fileId)).bytes()
+        );
+
+        const metadata = await new Anthropic().beta.files.retrieveMetadata(
+          fileId
+        );
+
+        return {
+          providerId: fileId,
+          content,
+          path: metadata.filename,
+          type: "tool",
+        };
+      })
+    );
+  }
+
+  extractContainerFromModelResponse(
+    messages: ModelRequest["messages"]
+  ): ContainerInfo | undefined {
+    const newContainer = messages.find(
+      (message) => message.type === "ai" && message.additional_kwargs?.container
+    )?.additional_kwargs?.container as Container | undefined;
+
+    return newContainer == null
+      ? undefined
+      : { id: newContainer.id, expiresAt: new Date(newContainer.expires_at) };
+  }
+}
+
+interface Container {
+  id: string;
+  expires_at: string;
+}

libs/providers/langchain-anthropic/src/middleware/index.ts

@@ -0,0 +1 @@
+export { AnthropicContainerProvider } from "./containerProvider.js";

libs/providers/langchain-anthropic/src/middleware/tests/codeExecution.int.test.ts

@@ -0,0 +1,107 @@
+import { HumanMessage } from "@langchain/core/messages";
+import { MemorySaver } from "@langchain/langgraph-checkpoint";
+import {
+  codeExecutionMiddleware,
+  createAgent,
+  MemoryFileProvider,
+} from "langchain";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import fs from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { ChatAnthropic } from "../../chat_models.js";
+import { AnthropicContainerProvider } from "../containerProvider.js";
+
+const thread = {
+  configurable: {
+    thread_id: "test-123",
+  },
+};
+
+describe("dataAnalysisMiddleware integration tests", () => {
+  let model: ChatAnthropic;
+  let outputDir: string;
+  const testDataPath = "test_data.csv";
+  const fullTestDataPath = join(__dirname, "fixtures", testDataPath);
+
+  beforeAll(() => {
+    model = new ChatAnthropic({
+      model: "claude-sonnet-4-20250514", // Haiku is a bit too dumb
+    });
+
+    // Create temporary directory for test outputs
+    outputDir = mkdtempSync(join(tmpdir(), "langchain-test-"));
+  });
+
+  afterAll(() => {
+    // Clean up temporary directory
+    if (existsSync(outputDir)) {
+      rmSync(outputDir, { recursive: true, force: true });
+    }
+  });
+
+  it(
+    "should upload file, analyze data, and download generated files",
+    {
+      timeout: 120000, // 2 minute timeout for API calls
+    },
+    async () => {
+      const middleware = codeExecutionMiddleware(
+        new AnthropicContainerProvider(),
+        new MemoryFileProvider()
+      );
+
+      // Create agent with data analysis middleware
+      const agent = createAgent({
+        model,
+        middleware: [middleware],
+        checkpointer: new MemorySaver(),
+      });
+
+      // Invoke agent with analysis task
+      const result1 = await agent.invoke(
+        {
+          messages: new HumanMessage("Filter to just widget A"),
+          files: [
+            await middleware.addFile(
+              testDataPath,
+              await fs.readFile(fullTestDataPath)
+            ),
+          ],
+        },
+        thread
+      );
+
+      // Verify first response
+      expect(result1.messages).toBeTruthy();
+      expect(result1.messages.length).toBeGreaterThan(0);
+
+      const result2 = await agent.invoke(
+        {
+          messages: new HumanMessage(
+            "Turn that into a graph of sales and units over time."
+          ),
+        },
+        thread
+      );
+
+      // Verify second response and extract generated files
+      expect(result2.messages).toBeTruthy();
+      expect(result2.messages.length).toBeGreaterThan(0);
+
+      const generatedImages = middleware
+        .files(result2)
+        .filter(({ type, path }) => type === "tool" && path.endsWith(".png"));
+
+      expect(generatedImages.length).toBeGreaterThan(0);
+
+      for (const img of generatedImages) {
+        const content = await img.getContent();
+        expect(content.length).toBeGreaterThan(0);
+        // Basic check that it's a PNG file
+        expect(content.subarray(0, 8).toString("hex")).toBe("89504e470d0a1a0a");
+      }
+    }
+  );
+});

libs/providers/langchain-anthropic/src/middleware/tests/fixtures/test_data.csv

@@ -0,0 +1,11 @@
+date,region,product,sales,units
+2024-01-15,North,Widget A,1250.50,25
+2024-01-16,South,Widget B,890.25,18
+2024-01-17,East,Widget A,1456.75,29
+2024-01-18,West,Widget C,2100.00,42
+2024-01-19,North,Widget B,765.50,15
+2024-01-20,South,Widget A,1890.00,38
+2024-01-21,East,Widget C,2340.25,47
+2024-01-22,West,Widget B,1123.75,22
+2024-01-23,North,Widget C,1567.50,31
+2024-01-24,South,Widget B,934.25,19

libs/providers/langchain-anthropic/src/types.ts

@@ -48,6 +48,7 @@ export type AnthropicWebSearchToolResultBlockParam =
 export type AnthropicWebSearchResultBlockParam =
   Anthropic.Messages.WebSearchResultBlockParam;
 export type AnthropicSearchResultBlockParam = Anthropic.SearchResultBlockParam;
+// TODO(hntrl): beta blocks should be separated
 export type AnthropicContainerUploadBlockParam =
   Anthropic.Beta.BetaContainerUploadBlockParam;