Agent 默认属于 TS/Python，但企业落地未必：我们为什么仍然选择 Java

import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class MiniAgent {
    record ToolCall(String name, Map<String, String> arguments) {}
    record Decision(ToolCall toolCall, String finalAnswer) {
        static Decision call(String name, Map<String, String> arguments) {
            return new Decision(new ToolCall(name, arguments), null);
        }

        static Decision finish(String answer) {
            return new Decision(null, answer);
        }
    }

    interface Tool {
        String name();
        String execute(Map<String, String> arguments) throws Exception;
    }

    interface Planner {
        Decision next(String goal, List<String> observations);
    }

    static final class ReadTextFileTool implements Tool {
        private final Path workspace;

        ReadTextFileTool(Path workspace) {
            this.workspace = workspace.toAbsolutePath().normalize();
        }

        @Override
        public String name() {
            return "read_text_file";
        }

        @Override
        public String execute(Map<String, String> arguments) throws Exception {
            String rawPath = arguments.get("path");
            if (rawPath == null || rawPath.isBlank()) {
                throw new IllegalArgumentException("path is required");
            }

            Path target = workspace.resolve(rawPath).normalize();
            if (!target.startsWith(workspace)) {
                throw new SecurityException("path escapes workspace");
            }

            String content = Files.readString(target, StandardCharsets.UTF_8);
            int limit = Math.min(content.length(), 2_000);
            return content.substring(0, limit);
        }
    }

    static final class DemoPlanner implements Planner {
        private final String requestedPath;

        DemoPlanner(String requestedPath) {
            this.requestedPath = requestedPath;
        }

        @Override
        public Decision next(String goal, List<String> observations) {
            if (observations.isEmpty()) {
                return Decision.call(
                    "read_text_file",
                    Map.of("path", requestedPath)
                );
            }
            return Decision.finish(
                "Task completed. File observation:\n" + observations.get(0)
            );
        }
    }

    public static void main(String[] args) throws Exception {
        if (args.length != 1) {
            System.err.println("Usage: java MiniAgent <relative-file-path>");
            System.exit(2);
        }

        Path workspace = Path.of(".");
        Tool readFile = new ReadTextFileTool(workspace);
        Map<String, Tool> tools = Map.of(readFile.name(), readFile);
        Planner planner = new DemoPlanner(args[0]);
        List<String> observations = new ArrayList<>();
        String goal = "Inspect a file in the current workspace";

        for (int step = 0; step < 3; step++) {
            Decision decision = planner.next(goal, List.copyOf(observations));

            if (decision.finalAnswer() != null) {
                System.out.println(decision.finalAnswer());
                return;
            }

            ToolCall call = decision.toolCall();
            Tool tool = tools.get(call.name());
            if (tool == null) {
                throw new IllegalStateException("Unknown tool: " + call.name());
            }

            try {
                String result = tool.execute(call.arguments());
                observations.add("SUCCESS: " + result);
            } catch (Exception e) {
                observations.add("ERROR: " + e.getMessage());
            }
        }

        throw new IllegalStateException("Agent exceeded maximum steps");
    }
}

javac MiniAgent.java
java MiniAgent README.md