Trace and Evaluate Claude Managed Agents

# triage.py

# Importing instrumentation first registers the tracer provider
# before the Claude SDK makes its first request.
from instrumentation import tracer_provider

import json

import anthropic

ISSUES = [
    {"number": 101, "title": "Login fails with SSO for all EU users",
     "labels": ["bug", "auth"], "comments": 14},
    {"number": 102, "title": "Typo in the README install section",
     "labels": ["docs"], "comments": 1},
    {"number": 103, "title": "Export to CSV drops the last row",
     "labels": ["bug", "export"], "comments": 6},
    {"number": 104, "title": "Add dark mode to the settings page",
     "labels": ["enhancement"], "comments": 9},
]

REQUEST = (
    "Triage the open issues. Use bash to count the open issues for each "
    "label, then name the single most urgent issue and explain why in "
    "two sentences."
)

client = anthropic.Anthropic()
tracer = tracer_provider.get_tracer("issue-triage")


def create_agent():
    environment = client.beta.environments.create(
        name="issue-triage",
        config={"type": "cloud", "networking": {"type": "limited"}},
    )
    agent = client.beta.agents.create(
        name="Issue Triage Agent",
        model="claude-opus-5-5",
        system=(
            "You triage GitHub issues for a small open-source project. "
            "Call list_issues to read the issues. Use bash for any "
            "counting or sorting."
        ),
        tools=[
            {
                "type": "agent_toolset_20260401",
                "configs": [
                    {"name": "web_fetch", "enabled": False},
                    {"name": "web_search", "enabled": False},
                ],
            },
            {
                "type": "custom",
                "name": "list_issues",
                "description": "List the repository's issues as JSON.",
                "input_schema": {
                    "type": "object",
                    "properties": {
                        "state": {"type": "string", "enum": ["open"]},
                    },
                    "required": ["state"],
                },
            },
        ],
    )
    return environment, agent


# Your own span for the tool your application runs. The Claude API
# can't see inside this function, so nothing else would trace it.
@tracer.tool(name="list_issues")
def list_issues(state: str) -> str:
    """List the repository's issues as JSON."""
    return json.dumps(ISSUES)


@tracer.chain(name="triage-request")
def run_triage(request: str) -> str:
    session = client.beta.sessions.create(
        agent={"type": "agent", "id": agent.id, "version": agent.version},
        environment_id=environment.id,
    )
    replies = []

    # Open the stream before sending the message so no events are
    # missed.
    with client.beta.sessions.events.stream(
        session_id=session.id,
    ) as stream:
        client.beta.sessions.events.send(
            session_id=session.id,
            events=[
                {
                    "type": "user.message",
                    "content": [{"type": "text", "text": request}],
                },
            ],
        )

        for event in stream:
            if event.type == "agent.message":
                for block in event.content:
                    if block.type == "text":
                        replies.append(block.text)
            elif event.type == "agent.custom_tool_use":
                client.beta.sessions.events.send(
                    session_id=session.id,
                    events=[
                        {
                            "type": "user.custom_tool_result",
                            "custom_tool_use_id": event.id,
                            "content": [
                                {
                                    "type": "text",
                                    "text": list_issues(**event.input),
                                },
                            ],
                        },
                    ],
                )
            elif event.type == "session.status_idle":
                if event.stop_reason.type != "requires_action":
                    break
            elif event.type == "session.status_terminated":
                break

    return "\n".join(replies)


environment, agent = create_agent()
print(run_triage(REQUEST))
tracer_provider.shutdown()

// triage.ts

// Importing instrumentation first registers the tracer provider
// before the Claude SDK makes its first request.
import { provider } from "./instrumentation";
import Anthropic from "@anthropic-ai/sdk";
import { traceChain, traceTool } from "@arizeai/openinference-core";

const ISSUES = [
  { number: 101, title: "Login fails with SSO for all EU users",
    labels: ["bug", "auth"], comments: 14 },
  { number: 102, title: "Typo in the README install section",
    labels: ["docs"], comments: 1 },
  { number: 103, title: "Export to CSV drops the last row",
    labels: ["bug", "export"], comments: 6 },
  { number: 104, title: "Add dark mode to the settings page",
    labels: ["enhancement"], comments: 9 },
];

const LIST_ISSUES_PARAMETERS = {
  type: "object" as const,
  properties: { state: { type: "string", enum: ["open"] } },
  required: ["state"],
};

const REQUEST =
  "Triage the open issues. Use bash to count the open issues for each " +
  "label, then name the single most urgent issue and explain why in " +
  "two sentences.";

const client = new Anthropic();

async function createAgent() {
  const environment = await client.beta.environments.create({
    name: "issue-triage",
    config: { type: "cloud", networking: { type: "limited" } },
  });
  const agent = await client.beta.agents.create({
    name: "Issue Triage Agent",
    model: "claude-opus-5-5",
    system:
      "You triage GitHub issues for a small open-source project. " +
      "Call list_issues to read the issues. Use bash for any " +
      "counting or sorting.",
    tools: [
      {
        type: "agent_toolset_20260401",
        configs: [
          { name: "web_fetch", enabled: false },
          { name: "web_search", enabled: false },
        ],
      },
      {
        type: "custom",
        name: "list_issues",
        description: "List the repository's issues as JSON.",
        input_schema: LIST_ISSUES_PARAMETERS,
      },
    ],
  });
  return { environment, agent };
}

// Your own span for the tool your application runs. The Claude API
// can't see inside this function, so nothing else would trace it.
const listIssues = traceTool(
  (input: unknown): string => JSON.stringify(ISSUES),
  {
    name: "list_issues",
    attributes: {
      "tool.name": "list_issues",
      "tool.description": "List the repository's issues as JSON.",
      "tool.parameters": JSON.stringify(LIST_ISSUES_PARAMETERS),
    },
  },
);

function traceTriage(environmentId: string, agentId: string,
    agentVersion: number) {
  return traceChain(async (request: string): Promise<string> => {
    const session = await client.beta.sessions.create({
      agent: { type: "agent", id: agentId, version: agentVersion },
      environment_id: environmentId,
    });
    const replies: string[] = [];

    // Open the stream before sending the message so no events are missed.
    const stream = await client.beta.sessions.events.stream(session.id);
    await client.beta.sessions.events.send(session.id, {
      events: [
        { type: "user.message", content: [{ type: "text", text: request }] },
      ],
    });

    loop: for await (const event of stream) {
      switch (event.type) {
        case "agent.message":
          for (const block of event.content) {
            if (block.type === "text") replies.push(block.text);
          }
          break;
        case "agent.custom_tool_use":
          await client.beta.sessions.events.send(session.id, {
            events: [
              {
                type: "user.custom_tool_result",
                custom_tool_use_id: event.id,
                content: [{ type: "text", text: listIssues(event.input) }],
              },
            ],
          });
          break;
        case "session.status_idle":
          if (event.stop_reason.type !== "requires_action") break loop;
          break;
        case "session.status_terminated":
          break loop;
      }
    }

    return replies.join("\n");
  }, { name: "triage-request" });
}

async function main() {
  const { environment, agent } = await createAgent();
  const runTriage = traceTriage(environment.id, agent.id, agent.version);
  console.log(await runTriage(REQUEST));
  await provider.shutdown();
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

// main.go
package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "os"
    "strings"
    "time"

    arizeotel "github.com/Arize-ai/arize-otel-go"
    "github.com/anthropics/anthropic-sdk-go"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/codes"
    "go.opentelemetry.io/otel/propagation"
    "go.opentelemetry.io/otel/trace"
)

type issue struct {
    Number   int      `json:"number"`
    Title    string   `json:"title"`
    Labels   []string `json:"labels"`
    Comments int      `json:"comments"`
}

var issues = []issue{
    {101, "Login fails with SSO for all EU users",
        []string{"bug", "auth"}, 14},
    {102, "Typo in the README install section", []string{"docs"}, 1},
    {103, "Export to CSV drops the last row",
        []string{"bug", "export"}, 6},
    {104, "Add dark mode to the settings page",
        []string{"enhancement"}, 9},
}

const request = "Triage the open issues. Use bash to count the open " +
    "issues for each label, then name the single most urgent issue " +
    "and explain why in two sentences."

var tracer = otel.Tracer("issue-triage")

// listIssuesParameters is the list_issues input schema, recorded on its
// TOOL span.
const listIssuesParameters = `{"type":"object",` +
    `"properties":{"state":{"type":"string","enum":["open"]}},` +
    `"required":["state"]}`

func main() {
    if err := run(context.Background()); err != nil {
        log.Fatal(err)
    }
}

// run returns errors instead of exiting, so the deferred Shutdown flushes
// the spans to Arize AX even when a request fails.
func run(ctx context.Context) error {
    // Register reads ARIZE_SPACE_ID, ARIZE_API_KEY, and
    // ARIZE_COLLECTOR_ENDPOINT from the environment.
    tp, err := arizeotel.Register(ctx, arizeotel.Options{
        ProjectName: os.Getenv("ARIZE_PROJECT_NAME"),
    })
    if err != nil {
        return fmt.Errorf("register tracer: %w", err)
    }
    defer func() {
        shutdownCtx, cancel := context.WithTimeout(
            context.Background(), 5*time.Second)
        defer cancel()
        _ = tp.Shutdown(shutdownCtx)
    }()
    // OpenTelemetry for Go registers no propagator by default. The Claude
    // SDK needs W3C trace context to link its spans to the API's spans.
    otel.SetTextMapPropagator(propagation.TraceContext{})

    client := anthropic.NewClient()

    environmentID, agentID, agentVersion, err := createAgent(ctx, client)
    if err != nil {
        return fmt.Errorf("create agent: %w", err)
    }

    answer, err := runTriage(ctx, client, environmentID, agentID,
        agentVersion)
    if err != nil {
        return fmt.Errorf("run triage: %w", err)
    }
    fmt.Println(answer)
    return nil
}

func createAgent(ctx context.Context, client anthropic.Client) (
    string, string, int64, error) {
    environment, err := client.Beta.Environments.New(ctx,
        anthropic.BetaEnvironmentNewParams{
            Name: "issue-triage",
            Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
                OfCloud: &anthropic.BetaCloudConfigParams{
                    Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
                        OfLimited: &anthropic.BetaLimitedNetworkParams{},
                    },
                },
            },
        })
    if err != nil {
        return "", "", 0, err
    }

    listIssuesTool := anthropic.BetaManagedAgentsCustomToolParams{
        Type:        anthropic.BetaManagedAgentsCustomToolParamsTypeCustom,
        Name:        "list_issues",
        Description: "List the repository's issues as JSON.",
    }
    listIssuesTool.InputSchema.Properties = map[string]any{
        "state": map[string]any{"type": "string", "enum": []string{"open"}},
    }
    listIssuesTool.InputSchema.Required = []string{"state"}

    agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
        Name: "Issue Triage Agent",
        Model: anthropic.BetaManagedAgentsModelConfigParams{
            ID: "claude-opus-5-5",
        },
        System: anthropic.String(
            "You triage GitHub issues for a small open-source project. " +
                "Call list_issues to read the issues. Use bash for any " +
                "counting or sorting."),
        Tools: []anthropic.BetaAgentNewParamsToolUnion{
            {OfAgentToolset20260401: toolset()},
            {OfCustom: &listIssuesTool},
        },
    })
    if err != nil {
        return "", "", 0, err
    }
    return environment.ID, agent.ID, agent.Version, nil
}

// listIssues records your own span for the tool your application runs.
// The Claude API can't see inside this function.
func listIssues(ctx context.Context, input map[string]any) string {
    _, span := tracer.Start(ctx, "list_issues")
    defer span.End()
    inputJSON, _ := json.Marshal(input)
    result, _ := json.Marshal(issues)
    span.SetAttributes(
        attribute.String("openinference.span.kind", "TOOL"),
        attribute.String("tool.name", "list_issues"),
        attribute.String("tool.description",
            "List the repository's issues as JSON."),
        attribute.String("tool.parameters", listIssuesParameters),
        attribute.String("input.value", string(inputJSON)),
        attribute.String("output.value", string(result)),
    )
    span.SetStatus(codes.Ok, "")
    return string(result)
}

func runTriage(ctx context.Context, client anthropic.Client,
    environmentID, agentID string,
    agentVersion int64) (answer string, err error) {
    ctx, root := tracer.Start(ctx, "triage-request", trace.WithAttributes(
        attribute.String("openinference.span.kind", "CHAIN"),
        attribute.String("input.value", request),
    ))
    defer func() {
        if err != nil {
            root.RecordError(err)
            root.SetStatus(codes.Error, err.Error())
        } else {
            root.SetStatus(codes.Ok, "")
        }
        root.End()
    }()

    sessionParams := anthropic.BetaSessionNewParams{
        Agent: anthropic.BetaSessionNewParamsAgentUnion{
            OfBetaManagedAgentsAgents: &anthropic.BetaManagedAgentsAgentParams{
                Type:    anthropic.BetaManagedAgentsAgentParamsTypeAgent,
                ID:      agentID,
                Version: anthropic.Int(agentVersion),
            },
        },
        EnvironmentID: environmentID,
    }
    session, err := client.Beta.Sessions.New(ctx, sessionParams)
    if err != nil {
        return "", err
    }

    // Open the stream before sending the message so no events are missed.
    stream := client.Beta.Sessions.Events.StreamEvents(ctx, session.ID,
        anthropic.BetaSessionEventStreamParams{})
    defer stream.Close()

    if err := send(ctx, client, session.ID,
        anthropic.BetaManagedAgentsEventParamsUnion{
            OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{
                Type: anthropic.
                    BetaManagedAgentsUserMessageEventParamsTypeUserMessage,
                Content: []anthropic.
                    BetaManagedAgentsUserMessageEventParamsContentUnion{{
                    OfText: textBlock(request),
                }},
            },
        }); err != nil {
        return "", err
    }

    var replies []string
events:
    for stream.Next() {
        switch event := stream.Current().AsAny().(type) {
        case anthropic.BetaManagedAgentsAgentMessageEvent:
            for _, block := range event.Content {
                replies = append(replies, block.Text)
            }
        case anthropic.BetaManagedAgentsAgentCustomToolUseEvent:
            result := toolResult(event.ID, listIssues(ctx, event.Input))
            if err := send(ctx, client, session.ID, result); err != nil {
                return "", err
            }
        case anthropic.BetaManagedAgentsSessionStatusIdleEvent:
            if event.StopReason.Type != "requires_action" {
                break events
            }
        case anthropic.BetaManagedAgentsSessionStatusTerminatedEvent:
            break events
        }
    }
    if err := stream.Err(); err != nil {
        return "", err
    }

    answer = strings.Join(replies, "\n")
    root.SetAttributes(attribute.String("output.value", answer))
    return answer, nil
}

func send(ctx context.Context, client anthropic.Client, sessionID string,
    event anthropic.BetaManagedAgentsEventParamsUnion) error {
    _, err := client.Beta.Sessions.Events.Send(ctx, sessionID,
        anthropic.BetaSessionEventSendParams{
            Events: []anthropic.BetaManagedAgentsEventParamsUnion{event},
        })
    return err
}

// toolResult answers a custom tool call. The SDK's
// BetaManagedAgentsEventParamsOfUserCustomToolResult helper leaves the
// event type unset, which the API rejects.
func toolResult(id, text string) anthropic.BetaManagedAgentsEventParamsUnion {
    var result anthropic.BetaManagedAgentsUserCustomToolResultEventParams
    result.Type = anthropic.
        BetaManagedAgentsUserCustomToolResultEventParamsTypeUserCustomToolResult
    result.CustomToolUseID = id
    result.Content = []anthropic.
        BetaManagedAgentsUserCustomToolResultEventParamsContentUnion{{
        OfText: textBlock(text),
    }}
    return anthropic.BetaManagedAgentsEventParamsUnion{
        OfUserCustomToolResult: &result,
    }
}

func textBlock(text string) *anthropic.BetaManagedAgentsTextBlockParam {
    return &anthropic.BetaManagedAgentsTextBlockParam{
        Type: anthropic.BetaManagedAgentsTextBlockTypeText,
        Text: text,
    }
}

func toolset() *anthropic.BetaManagedAgentsAgentToolset20260401Params {
    ts := &anthropic.BetaManagedAgentsAgentToolset20260401Params{
        Configs: []anthropic.BetaManagedAgentsAgentToolConfigParamsUnion{
            {OfWebFetch: &anthropic.BetaManagedAgentsWebFetchToolConfigParams{
                Enabled: anthropic.Bool(false),
            }},
            {OfWebSearch: &anthropic.BetaManagedAgentsWebSearchToolConfigParams{
                Enabled: anthropic.Bool(false),
            }},
        },
    }
    ts.Type = anthropic.
        BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401
    return ts
}

// src/main/java/example/Main.java
package example;

import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.core.JsonValue;
import com.anthropic.core.ObjectMappers;
import com.anthropic.models.beta.agents.*;
import com.anthropic.models.beta.environments.BetaCloudConfigParams;
import com.anthropic.models.beta.environments.BetaEnvironment;
import com.anthropic.models.beta.environments.BetaLimitedNetworkParams;
import com.anthropic.models.beta.environments.EnvironmentCreateParams;
import com.anthropic.models.beta.sessions.BetaManagedAgentsAgentParams;
import com.anthropic.models.beta.sessions.SessionCreateParams;
import com.anthropic.models.beta.sessions.events.*;
import com.fasterxml.jackson.core.JsonProcessingException;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.trace.StatusCode;
import io.opentelemetry.api.trace.Tracer;
import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator;
import io.opentelemetry.context.Scope;
import io.opentelemetry.context.propagation.ContextPropagators;
import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporter;
import io.opentelemetry.sdk.OpenTelemetrySdk;
import io.opentelemetry.sdk.resources.Resource;
import io.opentelemetry.sdk.trace.SdkTracerProvider;
import io.opentelemetry.sdk.trace.export.BatchSpanProcessor;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

public class Main {

    // The list_issues input schema, recorded on its TOOL span.
    private static final String LIST_ISSUES_PARAMETERS =
        "{\"type\":\"object\",\"properties\":{\"state\":"
            + "{\"type\":\"string\",\"enum\":[\"open\"]}},"
            + "\"required\":[\"state\"]}";

    private static final String ISSUES = """
        [
          {"number": 101, "title": "Login fails with SSO for all EU users",
           "labels": ["bug", "auth"], "comments": 14},
          {"number": 102, "title": "Typo in the README install section",
           "labels": ["docs"], "comments": 1},
          {"number": 103, "title": "Export to CSV drops the last row",
           "labels": ["bug", "export"], "comments": 6},
          {"number": 104, "title": "Add dark mode to the settings page",
           "labels": ["enhancement"], "comments": 9}
        ]
        """;

    private static final String REQUEST =
        "Triage the open issues. Use bash to count the open issues for "
            + "each label, then name the single most urgent issue and "
            + "explain why in two sentences.";

    private static AnthropicClient client;
    private static Tracer tracer;

    public static void main(String[] args) throws Exception {
        String project = System.getenv().getOrDefault(
            "ARIZE_PROJECT_NAME", "default");

        Resource resource = Resource.getDefault().merge(Resource.create(
            Attributes.of(
                AttributeKey.stringKey("service.name"), project,
                AttributeKey.stringKey("openinference.project.name"),
                project)));

        // For EU or Canada spaces, set ARIZE_COLLECTOR_ENDPOINT to your
        // region's endpoint, such as https://otlp.eu-west-1a.arize.com/v1.
        URI collector = URI.create(System.getenv().getOrDefault(
            "ARIZE_COLLECTOR_ENDPOINT", "https://otlp.arize.com/v1"));
        OtlpGrpcSpanExporter exporter = OtlpGrpcSpanExporter.builder()
            .setEndpoint("https://" + collector.getHost() + ":443")
            .setHeaders(() -> Map.of(
                "authorization", System.getenv("ARIZE_API_KEY"),
                "arize-space-id", System.getenv("ARIZE_SPACE_ID")))
            .build();

        SdkTracerProvider tracerProvider = SdkTracerProvider.builder()
            .addSpanProcessor(BatchSpanProcessor.builder(exporter).build())
            .setResource(resource)
            .build();

        // The Claude SDK reads the global OpenTelemetry instance. It needs
        // the W3C propagator to link its spans to the API's spans.
        OpenTelemetrySdk otel = OpenTelemetrySdk.builder()
            .setTracerProvider(tracerProvider)
            .setPropagators(ContextPropagators.create(
                W3CTraceContextPropagator.getInstance()))
            .buildAndRegisterGlobal();

        client = AnthropicOkHttpClient.fromEnv();
        tracer = otel.getTracer("issue-triage");

        BetaEnvironment environment = createEnvironment();
        BetaManagedAgentsAgent agent = createAgent();
        System.out.println(runTriage(environment, agent));

        tracerProvider.forceFlush().join(10, TimeUnit.SECONDS);
        tracerProvider.shutdown().join(10, TimeUnit.SECONDS);
    }

    private static BetaEnvironment createEnvironment() {
        return client.beta().environments().create(
            EnvironmentCreateParams.builder()
                .name("issue-triage")
                .config(BetaCloudConfigParams.builder()
                    .networking(BetaLimitedNetworkParams.builder().build())
                    .build())
                .build());
    }

    private static BetaManagedAgentsAgent createAgent() {
        var toolset = BetaManagedAgentsAgentToolset20260401Params.builder()
            .type(BetaManagedAgentsAgentToolset20260401Params.Type
                .AGENT_TOOLSET_20260401)
            .addConfig(BetaManagedAgentsWebFetchToolConfigParams.builder()
                .enabled(false).build())
            .addConfig(BetaManagedAgentsWebSearchToolConfigParams.builder()
                .enabled(false).build())
            .build();

        var listIssues = BetaManagedAgentsCustomToolParams.builder()
            .type(BetaManagedAgentsCustomToolParams.Type.CUSTOM)
            .name("list_issues")
            .description("List the repository's issues as JSON.")
            .inputSchema(BetaManagedAgentsCustomToolInputSchema.builder()
                .properties(BetaManagedAgentsCustomToolInputSchema.Properties
                    .builder()
                    .putAdditionalProperty("state", JsonValue.from(Map.of(
                        "type", "string", "enum", List.of("open"))))
                    .build())
                .addRequired("state")
                .build())
            .build();

        return client.beta().agents().create(AgentCreateParams.builder()
            .name("Issue Triage Agent")
            .model(BetaManagedAgentsModel.of("claude-opus-5-5"))
            .system("You triage GitHub issues for a small open-source "
                + "project. Call list_issues to read the issues. Use bash "
                + "for any counting or sorting.")
            .addTool(toolset)
            .addTool(listIssues)
            .build());
    }

    // Your own span for the tool your application runs. The Claude API
    // can't see inside this method, so nothing else would trace it.
    private static String listIssues(
            BetaManagedAgentsAgentCustomToolUseEvent call)
            throws JsonProcessingException {
        Span span = tracer.spanBuilder("list_issues").startSpan();
        try (Scope scope = span.makeCurrent()) {
            span.setAttribute("openinference.span.kind", "TOOL");
            span.setAttribute("tool.name", "list_issues");
            span.setAttribute("tool.description",
                "List the repository's issues as JSON.");
            span.setAttribute("tool.parameters", LIST_ISSUES_PARAMETERS);
            span.setAttribute("input.value",
                ObjectMappers.jsonMapper().writeValueAsString(call.input()));
            span.setAttribute("output.value", ISSUES);
            span.setStatus(StatusCode.OK);
            return ISSUES;
        } catch (Exception e) {
            span.recordException(e);
            span.setStatus(StatusCode.ERROR, e.getMessage());
            throw e;
        } finally {
            span.end();
        }
    }

    private static BetaManagedAgentsUserCustomToolResultEventParams
            toolResult(BetaManagedAgentsAgentCustomToolUseEvent call)
            throws JsonProcessingException {
        return BetaManagedAgentsUserCustomToolResultEventParams.builder()
            .type(BetaManagedAgentsUserCustomToolResultEventParams.Type
                .USER_CUSTOM_TOOL_RESULT)
            .customToolUseId(call.id())
            .addTextContent(listIssues(call))
            .build();
    }

    private static String runTriage(BetaEnvironment environment,
            BetaManagedAgentsAgent agent) throws JsonProcessingException {
        Span root = tracer.spanBuilder("triage-request").startSpan();
        try (Scope scope = root.makeCurrent()) {
            root.setAttribute("openinference.span.kind", "CHAIN");
            root.setAttribute("input.value", REQUEST);

            var session = client.beta().sessions().create(
                SessionCreateParams.builder()
                    .agent(BetaManagedAgentsAgentParams.builder()
                        .type(BetaManagedAgentsAgentParams.Type.AGENT)
                        .id(agent.id())
                        .version(agent.version())
                        .build())
                    .environmentId(environment.id())
                    .build());
            var events = client.beta().sessions().events();
            List<String> replies = new ArrayList<>();

            // Open the stream before sending the message so no events
            // are missed.
            try (var stream = events.streamStreaming(session.id())) {
                events.send(session.id(), EventSendParams.builder()
                    .addEvent(BetaManagedAgentsUserMessageEventParams.builder()
                        .type(BetaManagedAgentsUserMessageEventParams.Type
                            .USER_MESSAGE)
                        .addTextContent(REQUEST)
                        .build())
                    .build());

                Iterable<BetaManagedAgentsStreamSessionEvents> received =
                    stream.stream()::iterator;
                for (var event : received) {
                    if (event.isAgentMessage()) {
                        event.asAgentMessage().content()
                            .forEach(block -> block.text()
                                .ifPresent(text -> replies.add(text.text())));
                    } else if (event.isAgentCustomToolUse()) {
                        var call = event.asAgentCustomToolUse();
                        events.send(session.id(), EventSendParams.builder()
                            .addEvent(toolResult(call))
                            .build());
                    } else if (event.isSessionStatusIdle()) {
                        if (!event.asSessionStatusIdle().stopReason()
                                .isRequiresAction()) {
                            break;
                        }
                    } else if (event.isSessionStatusTerminated()) {
                        break;
                    }
                }
            }

            String answer = String.join("\n", replies);
            root.setAttribute("output.value", answer);
            root.setStatus(StatusCode.OK);
            return answer;
        } catch (Exception e) {
            root.recordException(e);
            root.setStatus(StatusCode.ERROR, e.getMessage());
            throw e;
        } finally {
            root.end();
        }
    }
}

python triage.py

npx tsx triage.ts

go run main.go

gradle run