Map hostedtool.CodeInterpreter to the Anthropic code_execution tool and parse its result blocks

provider/anthropicprovider/agent.go

@@ -5,6 +5,7 @@ package anthropicprovider
 import (
 	"cmp"
 	"context"
+	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"iter"
@@ -20,6 +21,7 @@ import (
 	"github.com/microsoft/agent-framework-go/agent/harness/toolautocall"
 	"github.com/microsoft/agent-framework-go/message"
 	"github.com/microsoft/agent-framework-go/tool"
+	"github.com/microsoft/agent-framework-go/tool/hostedtool"
 )
 
 type messageNewParamsOpt anthropic.MessageNewParams
@@ -295,10 +297,80 @@ func (a *client) buildBlock(index int, v any, contents []message.Content, functi
 			Name:      v.Name,
 			Arguments: string(v.Input),
 		}
+	case anthropic.ServerToolUseBlock:
+		if v.Name == anthropic.ServerToolUseBlockNameCodeExecution {
+			call := &message.CodeInterpreterToolCallContent{
+				CallID: v.ID,
+				ContentHeader: message.ContentHeader{
+					RawRepresentation: v,
+				},
+			}
+			if code := codeExecutionInput(v.Input); code != "" {
+				call.Inputs = message.Contents{
+					&message.DataContent{
+						Data:      base64.StdEncoding.EncodeToString([]byte(code)),
+						MediaType: "text/x-python",
+					},
+				}
+			}
+			contents = append(contents, call)
+		}
+	case anthropic.CodeExecutionToolResultBlock:
+		result := &message.CodeInterpreterToolResultContent{
+			CallID: v.ToolUseID,
+			ContentHeader: message.ContentHeader{
+				RawRepresentation: v,
+			},
+		}
+		res := v.Content
+		if res.Stdout != "" {
+			result.Outputs = append(result.Outputs, &message.TextContent{
+				Text:          res.Stdout,
+				ContentHeader: message.ContentHeader{RawRepresentation: res},
+			})
+		}
+		if res.Stderr != "" {
+			result.Outputs = append(result.Outputs, &message.TextContent{
+				Text:          res.Stderr,
+				ContentHeader: message.ContentHeader{RawRepresentation: res},
+			})
+		}
+		if res.ErrorCode != "" {
+			result.Outputs = append(result.Outputs, &message.TextContent{
+				Text:          string(res.ErrorCode),
+				ContentHeader: message.ContentHeader{RawRepresentation: res},
+			})
+		}
+		for _, out := range res.Content {
+			result.Outputs = append(result.Outputs, &message.HostedFileContent{
+				FileID:        out.FileID,
+				ContentHeader: message.ContentHeader{RawRepresentation: out},
+			})
+		}
+		contents = append(contents, result)
 	}
 	return contents
 }
 
+// codeExecutionInput extracts the source code from an Anthropic server_tool_use
+// code_execution input payload (shaped as {"code": "..."}).
+func codeExecutionInput(input any) string {
+	if input == nil {
+		return ""
+	}
+	raw, err := json.Marshal(input)
+	if err != nil {
+		return ""
+	}
+	var parsed struct {
+		Code string `json:"code"`
+	}
+	if err := json.Unmarshal(raw, &parsed); err != nil {
+		return ""
+	}
+	return parsed.Code
+}
+
 // citationAnnotations converts Anthropic text-block citations into
 // [message.CitationAnnotation] values. It returns nil when there are no
 // citations so callers can leave the annotations slice unset.
@@ -398,6 +470,14 @@ func (a *client) buildMessageParams(messages []*message.Message, opts []agent.Op
 				toolParam.OfTool.Description = anthropic.String(description)
 			}
 			tools = append(tools, toolParam)
+			continue
+		}
+		if _, ok := tl.(*hostedtool.CodeInterpreter); ok {
+			// Map the hosted code-interpreter marker onto Anthropic's server-side
+			// code_execution tool, mirroring the OpenAI Responses provider.
+			tools = append(tools, anthropic.ToolUnionParam{
+				OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{},
+			})
 		}
 	}
 	if len(tools) > 0 {

provider/anthropicprovider/agent_test.go

@@ -3,6 +3,7 @@
 package anthropicprovider_test
 
 import (
+	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -18,6 +19,7 @@ import (
 	"github.com/microsoft/agent-framework-go/agent"
 	"github.com/microsoft/agent-framework-go/message"
 	"github.com/microsoft/agent-framework-go/provider/anthropicprovider"
+	"github.com/microsoft/agent-framework-go/tool/hostedtool"
 )
 
 // testOutput is the structured type used across structured output tests.
@@ -846,6 +848,161 @@ func TestToolUseEmptyArgumentsSerializeAsObject(t *testing.T) {
 	}
 }
 
+// TestCodeInterpreterToolMapsToCodeExecution verifies that passing the hosted
+// *hostedtool.CodeInterpreter marker causes the provider to include Anthropic's
+// server-side code_execution tool in the request, mirroring the OpenAI Responses
+// provider's code_interpreter mapping.
+func TestCodeInterpreterToolMapsToCodeExecution(t *testing.T) {
+	bodyCh := make(chan []byte, 1)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		body, err := io.ReadAll(r.Body)
+		if err != nil {
+			t.Errorf("read request body: %v", err)
+			http.Error(w, "internal error", http.StatusInternalServerError)
+			return
+		}
+		bodyCh <- body
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = io.WriteString(w, minimalMessageResponse("ok"))
+	}))
+	defer server.Close()
+
+	a := newTestClient(t, server)
+	if _, err := a.RunText(t.Context(), "run some code",
+		agent.WithTool(&hostedtool.CodeInterpreter{}),
+	).Collect(); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	var req map[string]any
+	if err := json.Unmarshal(<-bodyCh, &req); err != nil {
+		t.Fatalf("unmarshal request body: %v", err)
+	}
+	tools, ok := req["tools"].([]any)
+	if !ok {
+		t.Fatalf("request tools = %#v, want a JSON array", req["tools"])
+	}
+	found := false
+	for _, tl := range tools {
+		tool, ok := tl.(map[string]any)
+		if !ok {
+			continue
+		}
+		if tool["type"] == "code_execution_20250825" && tool["name"] == "code_execution" {
+			found = true
+		}
+	}
+	if !found {
+		t.Fatalf("code_execution tool not found in request tools: %#v", tools)
+	}
+}
+
+// TestCodeInterpreterResultBlocksBecomeStructuredContent verifies that Anthropic
+// server_tool_use (code_execution) and code_execution_tool_result response blocks
+// are surfaced as structured message.CodeInterpreterToolCallContent /
+// CodeInterpreterToolResultContent, mirroring the OpenAI Responses mapping.
+func TestCodeInterpreterResultBlocksBecomeStructuredContent(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = io.WriteString(w, `{
+			"id":"msg_code_exec",
+			"type":"message",
+			"role":"assistant",
+			"model":"claude-3-5-sonnet-20241022",
+			"stop_reason":"end_turn",
+			"stop_sequence":null,
+			"content":[
+				{
+					"type":"server_tool_use",
+					"id":"srvtoolu_1",
+					"name":"code_execution",
+					"input":{"code":"print(sum(range(1, 6)))"}
+				},
+				{
+					"type":"code_execution_tool_result",
+					"tool_use_id":"srvtoolu_1",
+					"content":{
+						"type":"code_execution_result",
+						"stdout":"15\n",
+						"stderr":"",
+						"return_code":0,
+						"content":[{"type":"code_execution_output","file_id":"file_abc"}]
+					}
+				},
+				{"type":"text","text":"The sum is 15."}
+			],
+			"usage":{"input_tokens":10,"output_tokens":5}
+		}`)
+	}))
+	defer server.Close()
+
+	a := newTestClient(t, server)
+	resp, err := a.RunText(t.Context(), "run some code",
+		agent.WithTool(&hostedtool.CodeInterpreter{}),
+	).Collect()
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	var call *message.CodeInterpreterToolCallContent
+	var result *message.CodeInterpreterToolResultContent
+	for content := range resp.Contents() {
+		switch c := content.(type) {
+		case *message.CodeInterpreterToolCallContent:
+			call = c
+		case *message.CodeInterpreterToolResultContent:
+			result = c
+		}
+	}
+
+	if call == nil {
+		t.Fatal("expected a CodeInterpreterToolCallContent")
+	}
+	if call.CallID != "srvtoolu_1" {
+		t.Errorf("call CallID = %q, want %q", call.CallID, "srvtoolu_1")
+	}
+	if len(call.Inputs) != 1 {
+		t.Fatalf("call Inputs length = %d, want 1", len(call.Inputs))
+	}
+	data, ok := call.Inputs[0].(*message.DataContent)
+	if !ok {
+		t.Fatalf("call input type = %T, want *message.DataContent", call.Inputs[0])
+	}
+	if data.MediaType != "text/x-python" {
+		t.Errorf("call input MediaType = %q, want %q", data.MediaType, "text/x-python")
+	}
+	decoded, err := base64.StdEncoding.DecodeString(data.Data)
+	if err != nil {
+		t.Fatalf("decode call input data: %v", err)
+	}
+	if string(decoded) != "print(sum(range(1, 6)))" {
+		t.Errorf("call input code = %q, want %q", string(decoded), "print(sum(range(1, 6)))")
+	}
+
+	if result == nil {
+		t.Fatal("expected a CodeInterpreterToolResultContent")
+	}
+	if result.CallID != "srvtoolu_1" {
+		t.Errorf("result CallID = %q, want %q", result.CallID, "srvtoolu_1")
+	}
+	var stdout *message.TextContent
+	var file *message.HostedFileContent
+	for _, out := range result.Outputs {
+		switch o := out.(type) {
+		case *message.TextContent:
+			stdout = o
+		case *message.HostedFileContent:
+			file = o
+		}
+	}
+	if stdout == nil || stdout.Text != "15\n" {
+		t.Errorf("result stdout = %#v, want text %q", stdout, "15\n")
+	}
+	if file == nil || file.FileID != "file_abc" {
+		t.Errorf("result file = %#v, want FileID %q", file, "file_abc")
+	}
+}
+
 // findToolResultBlock returns the tool_result block for the given call ID from
 // an Anthropic messages request body, or nil if not present.
 func findToolResultBlock(t *testing.T, body []byte, callID string) map[string]any {